This week a new mining pool "Ocean" was announced. The mining pool uses a payout scheme called Transparent Index of Distinct Extended Shares (TIDES). The Ocean website describes the scheme as follows.

Our reward scheme is called Transparent Index of Distinct Extended Shares (TIDES). As blocks are being mined, they generate the reward by a weighted percentage of effort to the most recently found proofs. The proof period funds are distributed across has been chosen such that each proof should be paid on average 8 times. Instead of a set amount of bitcoins per proof, the block reward is divided by percent, so transaction fees are included. Because of this design, each payout to you is fully auditable. Previous implementations of similar systems such as PPLNS would distort the payouts owed to miners by using “shifts” and much smaller proof windows, resulting in miners getting significantly less accurate payments for their contributed hashrate.

TIDES is the most accurate payout scheme available in Bitcoin today and unlike other schemes like FPPS it does not require the pool to serve as a custodial intermediary for payment processing.

Can someone explain in more details how much a miner gets paid in each blocks? Let’s say Alice is contributing 20% of the shares continuously to the mining pool. Bob hops mining pools and contributes 30% to the first block but then doesn’t return to mine with Ocean. How much would they get paid and when?


1 Answer 1


I am also wondering how this actually works since there hasn't been any official documentation about it. However, given the already available information on the website, 'cause all miners shares and hashrate are public and some questions answered on Twitter by @wk057 and @GrassFedBitcoin; I think I can already have a full picture of it.

The reward system consist of three main concepts:

  1. shares earn by each user,
  2. total shares on the pool,
  3. and earnings based on shares.


Earnings are the simplest thing to explain. If a user has s shares and the pool has a total of total_shares (the sum of all user shares) the moment a block is found, the user earns

s * (block_reward) / total_shares

where block_reward means subsidy plus fees.

Share Window

The share window Z is the maximum number of shares the pool will consider at any time. That is only up to the newest Z shares are considered for the reward distribution. This number is 8 times the current block difficulty Z = 8 * network_difficulty. I will show below that this factor 8 translates into the number of blocks for which each share is expected to generate an earning.

Once the pool is running for quite some time the number of accumulated shares is enough to have total_shares = Z hence in the examples below we will consider that to be the case. Though in general this is not the case at the beginning of the pool operation.

User's shares

One share is equivalent to the work needed to mine a block with difficulty 1. Ocean, like any other pool, challenges the individual miners with some difficulty d and each time a hash is accepted d shares are added to this miner's account.

Because there is a maximum number Z of shares considered for the distribution of rewards, when a miner starts contributing with a constant hashrate H, his share number starts growing linearly until a maximum is reached, this is when the sum of shares in the pool up to Z starting from the most recent leaves out the oldest shares generated by the user.

Fig 1. A miner entering the pool sees his shares increasing linearly over time.

In the plot, I call T the relaxation time which is in fact the temporal dimension of the share window, or simply the time difference between the newest and the oldest share in the share window. For as long as the pool has a constant hashrate H_pool, T can be understood as the expected time for the pool to produce Z shares:

T = W1 * Z / H_pool

where W1=0x100010001 is (by the definition of difficulty 1), the expected work needed to solve a difficulty 1 block.

Also in the plot, we see the miner with a constant hashrate H reaches a share number <S>_T which is the expected number of shares this miner will receive after T seconds of work:

<S>_T = H * T / W1 
      = Z * H / H_pool

If a miner with hashrate H reaches the expected maximum number of shares and then leaves the pool forever, his shares will linearly decrease as the oldest shares are thrown away from the share window.

Fig 2. A miner leaving the pool sees his shares decay linearly over time.

We can understand the distribution of rewards from the point of view of individual shares. For instance, assuming a constant hashrate of the pool, a share earned at any time will stay valid for a time frame of about T. Now consider the expected number of blocks found by the pool in this time frame <N>_T:

<N>_T = H_pool * T / W1 / network_difficulty 
      = Z / network_difficulty 
      = 8

hence each share won by a miner is expected to reward him 8 earnings before it is thrown away from the share window.


A pool has a fair earning distribution if the expected earning(W) for a certain amount of work W diluted over time is:

earning(W) = block_reward * W / (W1 * network_difficulty)

assuming a constant block_reward and network_difficulty. We stress that the denominator W1 * network_difficulty is the expected work needed to mine a block, approximately the number of hashes tried by the entire network in 10 minutes.

We had seen that each individual share earned by a miner in the Ocean pool is obtained after W1 of work on average and it earns the miner a 1/Z fraction of the reward in an expected number of 8 blocks found by the pool from the moment the share is added until it is dropped from the share window. Therefore we have earnings per share computed as:

earning_per_share = 1/Z * 8 * block_reward 
                  = block_reward / network_difficulty 
                  = earning(W1)

thus the earning distribution is fair according to our definition, independently of the miner's online time, hashrate, the pool's hashrate or the network global parameters.

Eventually, if we know a miner's share function in time we can compute the total expected reward for his shares. For instance in a time interval [0, t] the share function is s(t), we split the interval into M small pieces of length dt = t / M. Then the probability of finding a block in each of these time intervals is p = H_pool * dt/ (W1 * network_difficulty). The reward for the miner in the entire time period is a random variable R which is the sum of the reward for the miner in each of the tiny time intervals:

R = sum_i r_i

where r_i = b_i * block_reward * s(t_i) / Z, in which b_i denotes a Bernoulli variable that takes values 1 with probability p and 0 with probability 1-p. So the expected value of the reward for the single miner becomes:

<R> = sum_i <r_i> 
    = block_reward * H_pool / (Z * W1 * network_difficulty) sum_i s(t_i) dt

that converges to a Riemann integral in the limit of M -> infinity, the integral is the area under the curve of shares vs time. We can use this relation to compute the total earnings of a miner in different example situations.

Example 1. Alice mining always

Let the hashrate of the pool be H_pool = 1.25 EH/s, consider Alice a miner with a hashrate of H_alice = 250 PH/s, which corresponds to a 20% of the pool's hashrate. And let network_difficulty = 80T.

The share window of the pool is Z = 8*network_difficulty = 640T and the time window would correspond to T = Z * W1/H_pool = 330 Ms or about 25 days.

Alice has been mining non-stop since the beginning, so she has already reached the maximum number of shares in the window: S_alice = H_alice * T / W1 = 128T. If a block is found, Alice will get S_alice / Z = 20% of the block reward.

That means on average in a time frame t Alice does a total work W_total = H_alice * t and the pool finds <N>_t = H_pool * t/ (W1 * network_difficulty) blocks so Alice earns

<R>_t = <N>_t * block_reward * S_alice / Z 
      = block_reward * W_total / (network_difficulty * W1)
      = earning(W_total)

which is fair for Alice.

To put some numbers into it, it means that for blocks with block_reward = 7 BTC, Alice is earning on average 0.003 BTC every 10 minutes or 0.44 BTC/day, and this number only depends on Alice hashrate and the network parameters (block_reward and network_difficulty).

Example 2. Charlie the small miner

Now consider a small miner that arrives to the pool, it is small so the total hashrate of the pool doesn't change. Let's say Charlie has H_charlie = 1 TH/s. At a constant hashrate and difficulty, Charlie would have to wait for at least T seconds or 25 days until it can reach the maximum number of shares, see fig 3. If after some time dt Charlie leaves the pool, his shares will start to fall linearly to zero in a time period of 25 days (relax time T).

Fig 3.

During all the time Charlie was hashing for the pool, he contributed to a total of W_total = H_charlie * (T + dt). The expected earnings of Charlie in the three regions in fig. 3 are (using the integral under the curve):

<R1> = H_pool * block_reward / (Z * W1 * network_difficulty) * (S*T/2)

<R2> = H_pool * block_reward / (Z * W1 * network_difficulty) * S* dt

<R3> = H_pool * block_reward / (Z * W1 * network_difficulty) * (S*T/2)

where S = H_charlie * T / W1 is the maximum number of shares of Charlie. When these three are summed up we find

<R1 + R2 + R3> = block_reward * S / network_difficulty * (1 + dt/T) 
               = block_reward * W_total  / (W1 * network_difficulty)
               = earning(W_total)

Which means that a fair earning is expected for Charlie if he comes and mines for a long time (until it reaches constant shares) and then leaves the pool.

For example, if Charlie mines for T = 25 days reaching constant shares and then after mining for 10 more days he turns off his miner. Then <R1> = <R3> = 2240 sat and <R2> = 1760 sat, and a total expected earning of <R1 + R2 + R3> = 6240 sat before his share count in the window is 0, or 176 sat/day for the ratio of total earnings divided by the work time.

Example 3. Charlie leaves early

Consider again the small miner Charlie, but this time he mines for some time t1 < T, so his shares start to accumulate linearly until, at time t1, he turns off his miner; then for some time his shares remain constant, until at time T his oldest share falls out of the share window and his share count starts to decrease linearly until it reaches zero at time T + t1, see fig. 4.

Fig. 4.

The total work is W_total = H_charlie * t1 and the expected earnings are:

<R1> = H_pool * block_reward / (Z * W1 * network_difficulty) * (S*t1/2)

<R2> = H_pool * block_reward / (Z * W1 * network_difficulty) * S*(T-t1)

<R3> = H_pool * block_reward / (Z * W1 * network_difficulty) * (S*t1/2)

where S = H_charlie * t1 / W1. When we add them up we find:

<R1 + R2 + R3> = block_reward * S / network_difficulty 
               = block_reward * W_total / (W1 * network_difficulty)
               = earning(W_total)

Which means a fair earning is expected for Charlie even if he participates for a short period of time.

For example, let t1 = 1 day, it follows that <R1> = <R3> = 3.5 sat and <R2> = 169 sat, in total <R1 + R2 + R3> = 176 sat or 176 sat/day (earnings per time of work).

Example 4. Bob the big miner

Now assume, a big miner Bob enters the pool with H_bob = 1.25 EH/s, doubling the pool's hashrate. Bob quickly starts adding shares and the pool would need to discard old shares as twice as fast than previously to keep the window size at constant Z. In other words the relaxation time changes from T = 25.5 days to T' = Z * W1 / (H_pool + H_bob) = 12.7 days. It will take Bob 12 days, until he reaches the maximum number of shares: S = Z/2 = 320T. After this moment, every time a block is found Bob will earn half of the block reward.

If Bob decides to leave after some time dt of having a constant share count, then his shares will start decreasing linearly with time, see fig. 5.

Fig. 5.

But since the pool has now less hashrate than when Bob was mining, it will take 25 days before all of Bob's shares are gone. But still the expected number of blocks is 8. Due to the fairness argument described above, each one of Bob shares is as good as any other miner shares.

The total work done by Bob is W_total = H_bob * (T' + dt) while the expected earnings on each region are

<R1> = (H_pool+H_bob) * block_reward / (Z * W1 * network_difficulty) * (S*T'/2)

<R2> = (H_pool+H_bob) * block_reward / (Z * W1 * network_difficulty) * S*dt

<R3> = H_pool * block_reward / (Z * W1 * network_difficulty) * (S*T)/2

again adding them up we find that

<R1 + R2 + R3> = block_reward / network_difficulty * (S + S*dt/T')
               = block_reward * W_total / (W1*network_difficulty)
               = earning(W_total)

Also for the big miner we verify that earnings are fair.

For instance if dt = 7 days we find that <R1> = <R3> = 14 BTC and <R2> = 15.4 BTC, for a total expected earning of <R1+R2+R3> = 43.3 BTC or 2.2 BTC/day (total earnings per day of work), notice this is always 176 sat/day for each TH/s of hashrate.

Example 5. Bob the big miner leaves early

Now assume, Bob enters the pool but mines only for a short period of time t1 < T'. While Bob is mining his shares grow linearly up to S = t1 * H_bob, then after he stops the number of shares remain constant for some time dt until the oldest shares by Bob start to leave the share window:

t1 * (H_pool + H_bob) + dt * H_pool = Z * W1

Afterwards, his shares starts decreasing linearly until zero at time t1 + T; see fig. 6.

Fig. 6.

The total work done by Bob is W_total = H_bob * t1 while the expected earnings on each region are:

<R1> = (H_pool+H_bob) * block_reward / (Z * W1 * network_difficulty) * (S*t1/2)

<R2> = H_pool * block_reward / (Z * W1 * network_difficulty) * S*dt

<R3> = H_pool * block_reward / (Z * W1 * network_difficulty) * S * (T-dt)/2

again adding them up we find that:

<R1 + R2 + R3> = block_reward / network_difficulty * S * (t1/T' + dt/T + 1 )/2
               = block_reward * W_total / (W1 * network_difficulty)
               = earning(W_total)

Earnings are always fair.

Now let's say t1 = 1 day, during that period of time the miner will earn <R1> = 0.086 BTC. Then, the miner turns off and during the following dt = (1-t1/T') * T = 23.5 days in which the shares remain constant the miner will earn <R2> = 2.027 BTC. Then finally the shares will start to decrease linearly for the next T-dt = 2 days and the miner will earn <R3> = 0.086 BTC, for a total expected earnings of <R1 + R2 + R3> = 2.2 BTC or 2.2 BTC/day (total earnings for time of work) or 176 sat/day for each TH/s.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.