Merge pull request #2188 from filecoin-project/const-relaxation

make system constants configurable as vars.

Makefile

@@ -191,6 +191,12 @@ health:
 .PHONY: health
 BINS+=health
 
+testground:
+	go build -tags testground -o /dev/null ./cmd/lotus
+
+.PHONY: testground
+BINS+=testground
+
 # MISC
 
 buildall: $(BINS)

build/params_2k.go

@@ -20,10 +20,9 @@ func init() {
 	BuildType |= Build2k
 }
 
-// Seconds
+const BlockDelaySecs = uint64(2)
-const BlockDelay = 2
 
-const PropagationDelay = 3
+const PropagationDelaySecs = uint64(3)
 
 // SlashablePowerDelay is the number of epochs after ElectionPeriodStart, after
 // which the miner is slashed

build/params_shared_funcs.go

@@ -0,0 +1,38 @@
+package build
+
+import (
+	"sort"
+
+	"github.com/libp2p/go-libp2p-core/protocol"
+
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+func DefaultSectorSize() abi.SectorSize {
+	szs := make([]abi.SectorSize, 0, len(miner.SupportedProofTypes))
+	for spt := range miner.SupportedProofTypes {
+		ss, err := spt.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		szs = append(szs, ss)
+	}
+
+	sort.Slice(szs, func(i, j int) bool {
+		return szs[i] < szs[j]
+	})
+
+	return szs[0]
+}
+
+// Core network constants
+
+func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
+func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + string(netName) }
+func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
+	return protocol.ID("/fil/kad/" + string(netName))
+}

build/params_shared_vals.go

@@ -1,10 +1,9 @@
+// +build !testground
+
 package build
 
 import (
 	"math/big"
-	"sort"
-
-	"github.com/libp2p/go-libp2p-core/protocol"
 
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
@@ -13,32 +12,6 @@ import (
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
-func DefaultSectorSize() abi.SectorSize {
-	szs := make([]abi.SectorSize, 0, len(miner.SupportedProofTypes))
-	for spt := range miner.SupportedProofTypes {
-		ss, err := spt.SectorSize()
-		if err != nil {
-			panic(err)
-		}
-
-		szs = append(szs, ss)
-	}
-
-	sort.Slice(szs, func(i, j int) bool {
-		return szs[i] < szs[j]
-	})
-
-	return szs[0]
-}
-
-// Core network constants
-
-func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
-func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + string(netName) }
-func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
-	return protocol.ID("/fil/kad/" + string(netName))
-}
-
 // /////
 // Storage
 
@@ -48,8 +21,7 @@ const UnixfsLinksPerLevel = 1024
 // /////
 // Consensus / Network
 
-// Seconds
+const AllowableClockDriftSecs = uint64(1)
-const AllowableClockDrift = 1
 
 // Epochs
 const ForkLengthThreshold = Finality
@@ -59,12 +31,12 @@ var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
 
 // Epochs
 const Finality = miner.ChainFinalityish
-const MessageConfidence = 5
+const MessageConfidence = uint64(5)
 
 // constants for Weight calculation
 // The ratio of weight contributed by short-term vs long-term factors in a given round
 const WRatioNum = int64(1)
-const WRatioDen = 2
+const WRatioDen = uint64(2)
 
 // /////
 // Proofs
@@ -82,25 +54,25 @@ const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from spe
 // Mining
 
 // Epochs
-const TicketRandomnessLookback = 1
+const TicketRandomnessLookback = abi.ChainEpoch(1)
 
-const WinningPoStSectorSetLookback = 10
+const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
 
 // /////
 // Devnet settings
 
-const TotalFilecoin = 2_000_000_000
+const TotalFilecoin = uint64(2_000_000_000)
-const MiningRewardTotal = 1_400_000_000
+const MiningRewardTotal = uint64(1_400_000_000)
 
-const FilecoinPrecision = 1_000_000_000_000_000_000
+const FilecoinPrecision = uint64(1_000_000_000_000_000_000)
 
 var InitialRewardBalance *big.Int
 
 // TODO: Move other important consts here
 
 func init() {
-	InitialRewardBalance = big.NewInt(MiningRewardTotal)
+	InitialRewardBalance = big.NewInt(int64(MiningRewardTotal))
-	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(FilecoinPrecision))
+	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
 }
 
 // Sync

build/params_testground.go

@@ -0,0 +1,73 @@
+// +build testground
+
+// This file makes hardcoded parameters (const) configurable as vars.
+//
+// Its purpose is to unlock various degrees of flexibility and parametrization
+// when writing Testground plans for Lotus.
+//
+package build
+
+import (
+	"math/big"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+var (
+	UnixfsChunkSize     = uint64(1 << 20)
+	UnixfsLinksPerLevel = 1024
+
+	BlocksPerEpoch       = uint64(builtin.ExpectedLeadersPerEpoch)
+	BlockMessageLimit    = 512
+	BlockGasLimit        = int64(100_000_000_000)
+	BlockDelaySecs       = uint64(builtin.EpochDurationSeconds)
+	PropagationDelaySecs = uint64(6)
+
+	AllowableClockDriftSecs = uint64(1)
+
+	Finality            = miner.ChainFinalityish
+	ForkLengthThreshold = Finality
+
+	SlashablePowerDelay        = 20
+	InteractivePoRepConfidence = 6
+
+	MessageConfidence uint64 = 5
+
+	WRatioNum = int64(1)
+	WRatioDen = uint64(2)
+
+	BadBlockCacheSize     = 1 << 15
+	BlsSignatureCacheSize = 40000
+	VerifSigCacheSize     = 32000
+
+	SealRandomnessLookback      = Finality
+	SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
+	MaxSealLookback             = SealRandomnessLookbackLimit + 2000
+
+	TicketRandomnessLookback     = abi.ChainEpoch(1)
+	WinningPoStSectorSetLookback = abi.ChainEpoch(10)
+
+	TotalFilecoin     uint64 = 2_000_000_000
+	MiningRewardTotal uint64 = 1_400_000_000
+
+	FilecoinPrecision uint64 = 1_000_000_000_000_000_000
+
+	InitialRewardBalance = func() *big.Int {
+		v := big.NewInt(int64(MiningRewardTotal))
+		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
+		return v
+	}()
+
+	DrandConfig = dtypes.DrandConfig{
+		Servers: []string{
+			"https://pl-eu.testnet.drand.sh",
+			"https://pl-us.testnet.drand.sh",
+			"https://pl-sin.testnet.drand.sh",
+		},
+		ChainInfoJSON: `{"public_key":"922a2e93828ff83345bae533f5172669a26c02dc76d6bf59c80892e12ab1455c229211886f35bb56af6d5bea981024df","period":25,"genesis_time":1590445175,"hash":"138a324aa6540f93d0dad002aa89454b1bec2b6e948682cde6bd4db40f4b7c9b"}`,
+	}
+)

build/params_testnet.go

@@ -1,5 +1,6 @@
 // +build !debug
 // +build !2k
+// +build !testground
 
 package build
 
@@ -19,7 +20,6 @@ func init() {
 	}
 }
 
-// Seconds
+const BlockDelaySecs = uint64(builtin.EpochDurationSeconds)
-const BlockDelay = builtin.EpochDurationSeconds
 
-const PropagationDelay = 6
+const PropagationDelaySecs = uint64(6)

chain/gen/gen.go

@@ -196,7 +196,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 			*genm2,
 		},
 		NetworkName: "",
-		Timestamp:   uint64(time.Now().Add(-500 * build.BlockDelay * time.Second).Unix()),
+		Timestamp:   uint64(time.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
 	}
 
 	genb, err := genesis2.MakeGenesisBlock(context.TODO(), bs, sys, tpl)
@@ -223,7 +223,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 	miners := []address.Address{maddr1, maddr2}
 
 	beac := beacon.NewMockBeacon(time.Second)
-	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelay)
+	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelaySecs)
 	//if err != nil {
 	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
 	//}
@@ -414,7 +414,7 @@ func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, vrfticke
 	if cg.Timestamper != nil {
 		ts = cg.Timestamper(parents, height-parents.Height())
 	} else {
-		ts = parents.MinTimestamp() + uint64((height-parents.Height())*build.BlockDelay)
+		ts = parents.MinTimestamp() + uint64(height-parents.Height())*build.BlockDelaySecs
 	}
 
 	fblk, err := MinerCreateBlock(context.TODO(), cg.sm, cg.w, &api.BlockTemplate{

chain/messagepool/messagepool.go

@@ -187,7 +187,7 @@ func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName) (*Messa
 
 	mp := &MessagePool{
 		closer:        make(chan struct{}),
-		repubTk:       time.NewTicker(build.BlockDelay * 10 * time.Second),
+		repubTk:       time.NewTicker(time.Duration(build.BlockDelaySecs) * 10 * time.Second),
 		localAddrs:    make(map[address.Address]struct{}),
 		pending:       make(map[address.Address]*msgSet),
 		minGasPrice:   types.NewInt(0),

chain/sync.go

@@ -666,18 +666,18 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (er
 	// fast checks first
 
 	now := uint64(time.Now().Unix())
-	if h.Timestamp > now+build.AllowableClockDrift {
+	if h.Timestamp > now+build.AllowableClockDriftSecs {
 		return xerrors.Errorf("block was from the future (now=%d, blk=%d): %w", now, h.Timestamp, ErrTemporal)
 	}
 	if h.Timestamp > now {
 		log.Warn("Got block from the future, but within threshold", h.Timestamp, time.Now().Unix())
 	}
 
-	if h.Timestamp < baseTs.MinTimestamp()+(build.BlockDelay*uint64(h.Height-baseTs.Height())) {
+	if h.Timestamp < baseTs.MinTimestamp()+(build.BlockDelaySecs*uint64(h.Height-baseTs.Height())) {
 		log.Warn("timestamp funtimes: ", h.Timestamp, baseTs.MinTimestamp(), h.Height, baseTs.Height())
-		diff := (baseTs.MinTimestamp() + (build.BlockDelay * uint64(h.Height-baseTs.Height()))) - h.Timestamp
+		diff := (baseTs.MinTimestamp() + (build.BlockDelaySecs * uint64(h.Height-baseTs.Height()))) - h.Timestamp
 
-		return xerrors.Errorf("block was generated too soon (h.ts:%d < base.mints:%d + BLOCK_DELAY:%d * deltaH:%d; diff %d)", h.Timestamp, baseTs.MinTimestamp(), build.BlockDelay, h.Height-baseTs.Height(), diff)
+		return xerrors.Errorf("block was generated too soon (h.ts:%d < base.mints:%d + BLOCK_DELAY:%d * deltaH:%d; diff %d)", h.Timestamp, baseTs.MinTimestamp(), build.BlockDelaySecs, h.Height-baseTs.Height(), diff)
 	}
 
 	msgsCheck := async.Err(func() error {

chain/sync_test.go

@@ -408,7 +408,7 @@ func TestSyncBadTimestamp(t *testing.T) {
 
 	base := tu.g.CurTipset
 	tu.g.Timestamper = func(pts *types.TipSet, tl abi.ChainEpoch) uint64 {
-		return pts.MinTimestamp() + (build.BlockDelay / 2)
+		return pts.MinTimestamp() + (build.BlockDelaySecs / 2)
 	}
 
 	fmt.Println("BASE: ", base.Cids())

chain/types/fil.go

@@ -11,7 +11,7 @@ import (
 type FIL BigInt
 
 func (f FIL) String() string {
-	r := new(big.Rat).SetFrac(f.Int, big.NewInt(build.FilecoinPrecision))
+	r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(build.FilecoinPrecision)))
 	if r.Sign() == 0 {
 		return "0"
 	}
@@ -33,7 +33,7 @@ func ParseFIL(s string) (FIL, error) {
 		return FIL{}, fmt.Errorf("failed to parse %q as a decimal number", s)
 	}
 
-	r = r.Mul(r, big.NewRat(build.FilecoinPrecision, 1))
+	r = r.Mul(r, big.NewRat(int64(build.FilecoinPrecision), 1))
 	if !r.IsInt() {
 		return FIL{}, fmt.Errorf("invalid FIL value: %q", s)
 	}

cli/sync.go

@@ -186,7 +186,7 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {
 
 		fmt.Printf("\r\x1b[2KWorker %d: Target: %s\tState: %s\tHeight: %d", working, target, chain.SyncStageString(ss.Stage), ss.Height)
 
-		if time.Now().Unix()-int64(head.MinTimestamp()) < build.BlockDelay {
+		if time.Now().Unix()-int64(head.MinTimestamp()) < int64(build.BlockDelaySecs) {
 			fmt.Println("\nDone!")
 			return nil
 		}

cmd/lotus-health/main.go

@@ -63,7 +63,7 @@ var watchHeadCmd = &cli.Command{
 		},
 		&cli.IntFlag{
 			Name:  "interval",
-			Value: build.BlockDelay,
+			Value: int(build.BlockDelaySecs),
 			Usage: "interval in seconds between chain head checks",
 		},
 		&cli.StringFlag{
@@ -73,7 +73,8 @@ var watchHeadCmd = &cli.Command{
 		},
 		&cli.IntFlag{
 			Name: "api-timeout",
-			Value: build.BlockDelay,
+			// TODO: this default value seems spurious.
+			Value: int(build.BlockDelaySecs),
 			Usage: "timeout between API retries",
 		},
 		&cli.IntFlag{
@@ -236,7 +237,7 @@ func waitForSyncComplete(ctx context.Context, a api.FullNode, r int, t time.Dura
 				return err
 			}
 
-			if time.Now().Unix()-int64(head.MinTimestamp()) < build.BlockDelay {
+			if time.Now().Unix()-int64(head.MinTimestamp()) < int64(build.BlockDelaySecs) {
 				return nil
 			}
 		}

cmd/lotus-seed/genesis.go

@@ -124,7 +124,7 @@ var genesisAddMinerCmd = &cli.Command{
 			log.Infof("Giving %s some initial balance", miner.Owner)
 			template.Accounts = append(template.Accounts, genesis.Actor{
 				Type:    genesis.TAccount,
-				Balance: big.Mul(big.NewInt(50_000_000), big.NewInt(build.FilecoinPrecision)),
+				Balance: big.Mul(big.NewInt(50_000_000), big.NewInt(int64(build.FilecoinPrecision))),
 				Meta:    (&genesis.AccountMeta{Owner: miner.Owner}).ActorMeta(),
 			})
 		}

cmd/lotus-storage-miner/info.go

@@ -128,7 +128,7 @@ var infoCmd = &cli.Command{
 				if expWinChance > 1 {
 					expWinChance = 1
 				}
-				winRate := time.Duration(float64(time.Second*build.BlockDelay) / expWinChance)
+				winRate := time.Duration(float64(time.Second*time.Duration(build.BlockDelaySecs)) / expWinChance)
 				winPerDay := float64(time.Hour*24) / float64(winRate)
 
 				fmt.Print("Expected block win rate: ")

cmd/lotus-storage-miner/market.go

@@ -123,7 +123,7 @@ var setAskCmd = &cli.Command{
 			return xerrors.Errorf("cannot parse duration: %w", err)
 		}
 
-		qty := dur.Seconds() / build.BlockDelay
+		qty := dur.Seconds() / float64(build.BlockDelaySecs)
 
 		min, err := units.RAMInBytes(cctx.String("min-piece-size"))
 		if err != nil {
@@ -208,7 +208,7 @@ var getAskCmd = &cli.Command{
 		dlt := ask.Expiry - head.Height()
 		rem := "<expired>"
 		if dlt > 0 {
-			rem = (time.Second * time.Duration(dlt*build.BlockDelay)).String()
+			rem = (time.Second * time.Duration(int64(dlt)*int64(build.BlockDelaySecs))).String()
 		}
 
 		fmt.Fprintf(w, "%s\t%s\t%s\t%d\t%s\t%d\n", ask.Price, types.SizeStr(types.NewInt(uint64(ask.MinPieceSize))), types.SizeStr(types.NewInt(uint64(ask.MaxPieceSize))), ask.Expiry, rem, ask.SeqNo)

cmd/lotus-storage-miner/proving.go

@@ -211,11 +211,11 @@ var provingInfoCmd = &cli.Command{
 func epochTime(curr, e abi.ChainEpoch) string {
 	switch {
 	case curr > e:
-		return fmt.Sprintf("%d (%s ago)", e, time.Second*time.Duration(build.BlockDelay*(curr-e)))
+		return fmt.Sprintf("%d (%s ago)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(curr-e)))
 	case curr == e:
 		return fmt.Sprintf("%d (now)", e)
 	case curr < e:
-		return fmt.Sprintf("%d (in %s)", e, time.Second*time.Duration(build.BlockDelay*(e-curr)))
+		return fmt.Sprintf("%d (in %s)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(e-curr)))
 	}
 
 	panic("math broke")

cmd/lotus/debug_advance.go

@@ -69,7 +69,7 @@ func init() {
 			}
 			// TODO: beacon
 
-			uts := head.MinTimestamp() + uint64(build.BlockDelay)
+			uts := head.MinTimestamp() + uint64(build.BlockDelaySecs)
 			nheight := head.Height() + 1
 			blk, err := api.MinerCreateBlock(ctx, &lapi.BlockTemplate{
 				addr, head.Key(), ticket, &types.ElectionProof{}, nil, msgs, nheight, uts, gen.ValidWpostForTesting,

documentation/en/block-validation.md

@@ -43,7 +43,7 @@ Assemble a `FullTipSet` populated with the single block received earlier.
 This function contains most of the validation logic grouped in separate closures that run asynchronously, this list does not reflect validation order then.
 
 `V:` Block `Timestamp`:
-  * Is not bigger than current time plus `AllowableClockDrift`.
+  * Is not bigger than current time plus `AllowableClockDriftSecs`.
   * Is not smaller than previous block's `Timestamp` plus `BlockDelay` (including null blocks).
 
 ### Messages

markets/storageadapter/client.go

@@ -330,7 +330,7 @@ func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider
 		}
 	}
 
-	if err := c.ev.Called(checkFunc, called, revert, build.MessageConfidence+1, build.SealRandomnessLookbackLimit, matchEvent); err != nil {
+	if err := c.ev.Called(checkFunc, called, revert, int(build.MessageConfidence+1), build.SealRandomnessLookbackLimit, matchEvent); err != nil {
 		return xerrors.Errorf("failed to set up called handler: %w", err)
 	}
 

markets/storageadapter/provider.go

@@ -321,7 +321,7 @@ func (n *ProviderNodeAdapter) OnDealSectorCommitted(ctx context.Context, provide
 
 	}
 
-	if err := n.ev.Called(checkFunc, called, revert, build.MessageConfidence+1, build.SealRandomnessLookbackLimit, matchEvent); err != nil {
+	if err := n.ev.Called(checkFunc, called, revert, int(build.MessageConfidence+1), build.SealRandomnessLookbackLimit, matchEvent); err != nil {
 		return xerrors.Errorf("failed to set up called handler: %w", err)
 	}
 

miner/miner.go

@@ -42,7 +42,7 @@ func NewMiner(api api.FullNode, epp gen.WinningPoStProver, addr address.Address)
 		address: addr,
 		waitFunc: func(ctx context.Context, baseTime uint64) (func(bool), error) {
 			// Wait around for half the block time in case other parents come in
-			deadline := baseTime + build.PropagationDelay
+			deadline := baseTime + build.PropagationDelaySecs
 			time.Sleep(time.Until(time.Unix(int64(deadline), 0)))
 
 			return func(bool) {}, nil
@@ -150,7 +150,7 @@ func (m *Miner) mine(ctx context.Context) {
 		}
 		if base.TipSet.Equals(lastBase.TipSet) && lastBase.NullRounds == base.NullRounds {
 			log.Warnf("BestMiningCandidate from the previous round: %s (nulls:%d)", lastBase.TipSet.Cids(), lastBase.NullRounds)
-			m.niceSleep(build.BlockDelay * time.Second)
+			m.niceSleep(time.Duration(build.BlockDelaySecs) * time.Second)
 			continue
 		}
 
@@ -194,7 +194,7 @@ func (m *Miner) mine(ctx context.Context) {
 			// has enough time to form.
 			//
 			// See:  https://github.com/filecoin-project/lotus/issues/1845
-			nextRound := time.Unix(int64(base.TipSet.MinTimestamp()+uint64(build.BlockDelay*base.NullRounds))+int64(build.PropagationDelay), 0)
+			nextRound := time.Unix(int64(base.TipSet.MinTimestamp()+build.BlockDelaySecs*uint64(base.NullRounds))+int64(build.PropagationDelaySecs), 0)
 
 			select {
 			case <-time.After(time.Until(nextRound)):
@@ -255,12 +255,16 @@ func (m *Miner) hasPower(ctx context.Context, addr address.Address, ts *types.Ti
 	return mpower.MinerPower.QualityAdjPower.GreaterThanEqual(power.ConsensusMinerMinPower), nil
 }
 
-// mineOne mines a single block, and does so synchronously, if and only if we
+// mineOne attempts to mine a single block, and does so synchronously, if and
-// have won the current round.
+// only if we are eligible to mine.
 //
 // {hint/landmark}: This method coordinates all the steps involved in mining a
 // block, including the condition of whether mine or not at all depending on
 // whether we win the round or not.
+//
+// This method does the following:
+//
+//  1.
 func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (*types.BlockMsg, error) {
 	log.Debugw("attempting to mine a block", "tipset", types.LogCids(base.TipSet.Cids()))
 	start := time.Now()
@@ -352,7 +356,7 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (*types.BlockMsg,
 	tCreateBlock := time.Now()
 	dur := tCreateBlock.Sub(start)
 	log.Infow("mined new block", "cid", b.Cid(), "height", b.Header.Height, "took", dur)
-	if dur > time.Second*build.BlockDelay {
+	if dur > time.Second*time.Duration(build.BlockDelaySecs) {
 		log.Warn("CAUTION: block production took longer than the block delay. Your computer may not be fast enough to keep up")
 
 		log.Warnw("tMinerBaseInfo ", "duration", tMBI.Sub(start))
@@ -413,7 +417,7 @@ func (m *Miner) createBlock(base *MiningBase, addr address.Address, ticket *type
 		msgs = msgs[:build.BlockMessageLimit]
 	}
 
-	uts := base.TipSet.MinTimestamp() + uint64(build.BlockDelay*(base.NullRounds+1))
+	uts := base.TipSet.MinTimestamp() + build.BlockDelaySecs*(uint64(base.NullRounds)+1)
 
 	nheight := base.TipSet.Height() + base.NullRounds + 1
 

node/impl/common/common.go

@@ -122,7 +122,7 @@ func (a *CommonAPI) Version(context.Context) (api.Version, error) {
 		Version:    build.UserVersion(),
 		APIVersion: build.APIVersion,
 
-		BlockDelay: build.BlockDelay,
+		BlockDelay: build.BlockDelaySecs,
 	}, nil
 }
 

node/modules/services.go

@@ -123,6 +123,6 @@ func RandomBeacon(p RandomBeaconParams, _ dtypes.AfterGenesisSet) (beacon.Random
 		return nil, err
 	}
 
-	//return beacon.NewMockBeacon(build.BlockDelay * time.Second)
+	//return beacon.NewMockBeacon(build.BlockDelaySecs * time.Second)
-	return drand.NewDrandBeacon(gen.Timestamp, build.BlockDelay, p.PubSub, p.DrandConfig)
+	return drand.NewDrandBeacon(gen.Timestamp, build.BlockDelaySecs, p.PubSub, p.DrandConfig)
 }

node/modules/testing/beacon.go

@@ -8,5 +8,5 @@ import (
 )
 
 func RandomBeacon() (beacon.RandomBeacon, error) {
-	return beacon.NewMockBeacon(build.BlockDelay * time.Second), nil
+	return beacon.NewMockBeacon(time.Duration(build.BlockDelaySecs) * time.Second), nil
 }

node/node_test.go

@@ -349,7 +349,7 @@ func mockSbBuilder(t *testing.T, nFull int, storage []test.StorageMiner) ([]test
 	templ := &genesis.Template{
 		Accounts:  genaccs,
 		Miners:    genms,
-		Timestamp: uint64(time.Now().Unix() - (build.BlockDelay * 20000)),
+		Timestamp: uint64(time.Now().Unix()) - (build.BlockDelaySecs * 20000),
 	}
 
 	// END PRESEAL SECTION

tools/stats/rpc.go

@@ -114,7 +114,7 @@ sync_complete:
 			// If we get within 20 blocks of the current exected block height we
 			// consider sync complete. Block propagation is not always great but we still
 			// want to be recording stats as soon as we can
-			if timestampDelta < build.BlockDelay*20 {
+			if timestampDelta < int64(build.BlockDelaySecs)*20 {
 				return nil
 			}
 		}