fip-0100: constants and function to calculate daily fee (#363)

Author: rvagg

builtin/v16/miner/policy.go

@@ -141,6 +141,26 @@ const MinSectorExpiration = 180 * builtin.EpochsInDay // PARAM_SPEC
 // the associated seal proof's maximum lifetime.
 const MaxSectorExpirationExtension = 1278 * builtin.EpochsInDay // PARAM_SPEC
 
+// Numerator of the fraction of circulating supply that will be used to calculate
+// the daily fee for new sectors.
+const DailyFeeCirculatingSupplyQAPMultiplierNum = 21536
+
+// Denominator of the fraction of circulating supply that will be used to calculate
+// the daily fee for new sectors.
+var DailyFeeCirculatingSupplyQAPMultiplierDenom = (func() big.Int {
+	bi, err := big.FromString("100000000000000000000000000000")
+	if err != nil {
+		panic(err)
+	}
+	return bi
+})()
+
+// Denominator for the fraction of estimated daily block reward for the sector(s)
+// attracting a fee, to be used as a cap for the fees when payable.
+// No numerator is provided as the fee is calculated as a fraction of the estimated
+// daily block reward.
+const DailyFeeBlockRewardCapDenom = 2
+
 // QualityForWeight calculates the quality of a sector with the given size, duration, and verified weight.
 // VerifiedDealWeight is spacetime occupied by verified pieces in a sector.
 // VerifiedDealWeight should be less than or equal to total SpaceTime of a sector.
@@ -196,3 +216,11 @@ func QAPowerMax(size abi.SectorSize) abi.StoragePower {
 		big.Mul(big.NewInt(int64(size)), builtin.VerifiedDealWeightMultiplier),
 		builtin.QualityBaseMultiplier)
 }
+
+// DailyProofFee calculates the daily fee for a sector's quality-adjusted power based on the current
+// circulating supply.
+func DailyProofFee(circulatingSupply abi.TokenAmount, qaPower abi.StoragePower) abi.TokenAmount {
+	numerator := big.NewInt(DailyFeeCirculatingSupplyQAPMultiplierNum)
+	result := big.Mul(big.Mul(numerator, qaPower), circulatingSupply)
+	return big.Div(result, DailyFeeCirculatingSupplyQAPMultiplierDenom)
+}

builtin/v16/miner/policy_test.go

@@ -50,3 +50,33 @@ func TestQualityForWeight(t *testing.T) {
 		}
 	}
 }
+
+// matches builtin-actors/actors/miner/tests/policy_test.rs
+func TestDailyProofFeeCalc(t *testing.T) {
+	// Given a CS of 680M FIL, 32GiB QAP, a fee multiplier of 7.4e-15 per 32GiB QAP, the daily proof
+	// fee should be 5032 nanoFIL.
+	//   680M * 7.4e-15 = 0.000005032 FIL
+	//   0.000005032 * 1e9 = 5032 nanoFIL
+	//   0.000005032 * 1e18 = 5032000000000 attoFIL
+	// As a per-byte multiplier we use 2.1536e-25, a close approximation of 7.4e-15 / 32GiB.
+	//   680M * 32GiB * 2.1536e-25 = 0.000005031805013354 FIL
+	//   0.000005031805013354 * 1e18 = 5031805013354 attoFIL
+	circulatingSupply := big.Mul(big.NewInt(680_000_000), builtin.TokenPrecision)
+	ref32GibFee := big.NewInt(5031805013354)
+
+	for _, tc := range []struct {
+		size     uint64
+		expected big.Int
+	}{
+		{32, ref32GibFee},
+		{64, big.Mul(ref32GibFee, big.NewInt(2))},
+		{32 * 10, big.Mul(ref32GibFee, big.NewInt(10))},
+		{32 * 5, big.Mul(ref32GibFee, big.NewInt(5))},
+		{64 * 10, big.Mul(ref32GibFee, big.NewInt(20))},
+	} {
+		power := big.NewInt(int64(tc.size << 30)) // 32GiB raw QAP
+		fee := miner.DailyProofFee(circulatingSupply, power)
+		delta := big.Sub(fee, tc.expected).Abs()
+		require.LessOrEqual(t, delta.Uint64(), uint64(2), "fee: %s, expected: %s", fee, tc.expected)
+	}
+}