ATX reward with a sliding window


  1. Any miner who created a valid ATX will earn a reward without waiting for the next epoch.
    ** Receiving the money quickly is more user-friendly.
    ** No perverse incentive to create an ATX that gets published near the end of the epoch.
  2. Incentivizing the miners to publish their ATXs in a uniform random layer.
    ** Avoiding a communication burst in which many ATXs are broadcasted in a short timeframe.
  3. Clean in-protocol way to allow the miner to pay for a service by forgoing some of her ATX reward.
    ** Possible such services: PoET sequential work, k2pow, maybe delegated PoST initialization…
    ** Taking such a payment from the first-ballot-of-the-epoch reward is uglier (there’s more variance w.r.t. the total reward of the first ballot).


  • Rewarding a miner who might never perform any useful work.


  • p_{\text{atx}} = the portion the total revenues (that the miner earns in the epoch) that’s given as an ATX reward (for example, p_{\text{atx}} = 10%).
  • d_{\text{atx}} = the length of the sliding windows (for example, d_{\text{atx}} = 20).


  • UCB = unified content block
  • The UCB of each layer L_j includes a list A_j of ATX identities (not specified as coinbase) that should be rewarded when the UCB of layer L_{j+d_{\text{atx}}} is done
    ** A_j should contain the ATXs that were broadcasted prior to the starting time of L_j
    *** Honest tortoise proposals will list ATXs that were broadcasted and verified and haven’t been included in an earlier UCB
    *** A_j is the union of the listed ATXs from the accepted tortoise proposals
  • Denote by R_j the total revenues of the UCB of L_j
    ** Let R'_j = p_{\text{atx}} \cdot R_j be the amount that L_j should contribute towards ATX rewards
    ** R'_j is shared equally among the layers L_j,L_{j+1},L_{j+2},L_{j+3},\ldots,L_{j+d_{\text{atx}}-1}, meaning that each of these layers receives the amount of R'_j/d_{\text{atx}} (formally defined via F_j notation next)
    ** Denote F_j = R'_j/d_{\text{atx}} + R'_{j-1}/d_{\text{atx}} + R'_{j-2}/d_{\text{atx}} + \ldots + R'_{j-d_{\text{atx}}+1}/d_{\text{atx}} as the final amount that will be used by layer L_j to give ATX rewards
  • At layer L_{j+d_{\text{atx}}} each ATX in A_j will receive F_{j+d_{\text{atx}}}/|A_j| reward
    ** This reward isn’t written explicitly in any of the UCBs, but it’s enforced by the protocol rules
    *** This reward can be displayed in smapp and block explorers as soon as the UCB of layer L_{j+d_{\text{atx}}} is known
    ** In other words, each layer L_j gives rewards (that can be displayed) to ATXs in the list A_{j-d_{\text{atx}}} that’s part of the UCB of layer L_{j-d_{\text{atx}}}
    ** If |A_j|==0 then F_{j+d_{\text{atx}}} is burned


  1. Overall, if we denote the total revenues of the epoch by T, then p_{\text{atx}} \cdot T is given to the miners in the form of ATX rewards (such that each ATX is rewarded once), and (1-p_{\text{atx}}) \cdot T is given to the miners in the form of proposal/ballot (and other) rewards.
  2. Miners are incentivized to broadcast their ATX at a uniform random layer.
    ** If all the miners (of the next epoch) broadcast their ATX before layer L_j, then their total ATX reward pool will be just F_{j+d_{\text{atx}}} rather than p_{\text{atx}} \cdot T, and each miner will earn only F_{j+d_{\text{atx}}}/|A_j| where |A_j| in very large.
  3. The reason that the ATXs of layer L_j are rewarded in layer L_{j+d_{\text{atx}}} rather than layer L_{j+d_{\text{atx}}-1} is disincentivize rational miners from broadcasting their ATX when the mempool currently contains high-fee transactions.
  4. Upon launching this sliding window scheme, the 1st layer L_1 will confiscate the R'_1 = p_{\text{atx}} \cdot R_1 amount but won’t give anything back in ATX rewards, the 2nd layer L_2 will confiscate the amount R'_2 = p_{\text{atx}} \cdot R_2 and give back only R'_2/d_{\text{atx}} in ATX rewards, the 3rd layer L_3 will confiscate the amount R'_3 = p_{\text{atx}} \cdot R_3 and give back only 2R'_3/d_{\text{atx}} in ATX rewards, the 4th layer L_4 will confiscate the amount R'_4 = p_{\text{atx}} \cdot R_4 and give back only 3R'_4/d_{\text{atx}} in ATX rewards, and so on. Only starting at layer L_{d_{\text{atx}}+1} the layers will give back the entire amount that they confiscated.
    ** So, regarding just the first d_{\text{atx}} layers (all future layers afterwards are ok), we can simply burn the confiscated amounts, or specify a more complex rule.
  5. The amount of each next sliding window can be computed efficiently by simply subtracting a single number R'_j and adding a single number R'_{j+d_{\text{atx}}-1}
    ** The division by d_{\text{atx}} can be done afterwards (as in the illustration)
  6. With a phased PoET (as opposed to continuous PoET) there may still be a burst (depending on whether many miners finish the PoST proof generation at the same time), so the honest miner will perform a “random sleep” before broadcasting her ATX, where the duration of the random sleep depends on d_{\text{atx}} and the number of phased PoET servers.

The above isn’t good enough: while the reward that goes to a group of ATXs is indeed smoothed, the size of the group isn’t smoothed (e.g., if it’s group of size==1 then the single ATX id of this group is unusually lucky).

We should also smooth the list of participants that earns the reward, and to avoid bursts/epochs, it’s best to use a sliding window of rewarded partipants (just like the sliding window of the accumulated revenues), as follows:

We use another parameter d'_\text{atx} for the window size of participants (d'_\text{atx}=d_\text{atx} is ok).

The accumulated reward amount F_j won’t be shared equally just among the ATXs in A_{j-d_\text{atx}}

Rather, F_j will be shared equally among the ATXs in A'_{j-d_\text{atx}} such that:

  • A'_{j-d_\text{atx}} = A_{j-d_\text{atx}} \cup A_{j-d_\text{atx}-1} \cup A_{j-d_\text{atx}-2} \cup A_{j-d_\text{atx}-3} \cup \ldots \cup A_{j-d_\text{atx}-d'_\text{atx}+1}

For example, if d'_\text{atx}=3 then this implies the that the ATXs in A_{j-d_\text{atx}} will earn ATX rewards by participating in the following 3 overlapping windows:

  1. \ \ \bm{A_{j-d_\text{atx}}} \cup A_{j-d_\text{atx}-1} \cup A_{j-d_\text{atx}-2}\ earns the reward F_j
  2. \ \ A_{j-d_\text{atx}+1} \cup \bm{A_{j-d_\text{atx}}} \cup A_{j-d_\text{atx}-1}\ earns the reward F_{j+1}
  3. \ \ A_{j-d_\text{atx}+2} \cup A_{j-d_\text{atx}+1} \cup \bm{A_{j-d_\text{atx}}}\ earns the reward F_{j+2}

Of course, the intersection among the d'_\text{atx} overlapping windows (in which A_{j-d_\text{atx}} participates) is always just A_{j-d_\text{atx}}

Other than this, the only difference is regarding the “Upon launching” (point 4) in the above post:

  • The straightforward way to go about it is to treat the first d'_\text{atx}\! -\! 1 layers before the launch as dummy layers that money that’s sent to them is burned.

  • For example, suppose d'_\text{atx}=3 \ and we launch at layer 105

    • Meaning that the first list of rewarded ATXs is A_{105} that resides in the UCB of layer L_{105}

    • A_{105} will earn 1/3 of F_{105+d_\text{atx}}

      • The other 2/3 of F_{105+d_\text{atx}} are burned

        • By being sent to the non-existing A_{104} of L_{104} and A_{103} of L_{103}
    • A_{106} will earn 1/3 of F_{106+d_\text{atx}}

      • A_{105} will also earn 1/3 of F_{106+d_\text{atx}}

      • The other 1/3 will be burned (sent to the non-existing A_{104} of L_{104})

    • A_{107} will earn 1/3 of F_{107+d_\text{atx}}

      • A_{106} will also earn 1/3 of F_{106+d_\text{atx}}

      • A_{105} will also earn 1/3 of F_{106+d_\text{atx}}

BTW, the reward sharing is weighted (it was erroneously not mentioned in the first post):

  • The sharing is done according to the number of space units of each ATX

  • When we say that F_j is shared equally among A'_{j-d_\text{atx}} , the precise meaning is

    • Let S_\text{id} denote the number of space units of some specific ATX \text{id}

    • Let S_\text{sum} denote the number of space units of A'_{j-d_\text{atx}}

    • Each ATX \text{id} in A'_{j-d_\text{atx}} receives F_j \cdot S_\text{id} / S_\text{sum} reward.

    • For example:

      • A'_{j-d_\text{atx}} = \{\text{ATX}_\text{alice},\ \text{ATX}_\text{bob}\}

      • S_\text{alice}=4\ and \ S_\text{bob}\!=5

      • \text{ATX}_{alice}\ earns \ F_j\cdot 4/9

      • \text{ATX}_{bob}\ earns \ F_j\cdot 5/9