lotus/itests/kit/node_opts.go

package kit

import (
	"github.com/filecoin-project/go-state-types/abi"
	"github.com/filecoin-project/go-state-types/big"

	"github.com/filecoin-project/lotus/build"
	"github.com/filecoin-project/lotus/chain/types"
	"github.com/filecoin-project/lotus/chain/wallet/key"
	"github.com/filecoin-project/lotus/node"
	"github.com/filecoin-project/lotus/node/config"
	"github.com/filecoin-project/lotus/node/modules"
	"github.com/filecoin-project/lotus/node/modules/dtypes"
	"github.com/filecoin-project/lotus/node/repo"
	"github.com/filecoin-project/lotus/storage/paths"
	"github.com/filecoin-project/lotus/storage/pipeline/sealiface"
	"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
)

// DefaultPresealsPerBootstrapMiner is the number of preseals that every
// bootstrap miner has by default. It can be overridden through the
// PresealSectors option.
const DefaultPresealsPerBootstrapMiner = 2

const TestSpt = abi.RegisteredSealProof_StackedDrg2KiBV1_1

// nodeOpts is an options accumulating struct, where functional options are
// merged into.
type nodeOpts struct {
	balance       abi.TokenAmount
	lite          bool
	sectors       int
	rpc           bool
	ownerKey      *key.Key
	extraNodeOpts []node.Option
	cfgOpts       []CfgOption
	fsrepo        bool

	subsystems             MinerSubsystem
	mainMiner              *TestMiner
	disableLibp2p          bool
	optBuilders            []OptBuilder
	sectorSize             abi.SectorSize
	maxStagingDealsBytes   int64
	minerNoLocalSealing    bool // use worker
	minerAssigner          string
	disallowRemoteFinalize bool
	noStorage              bool

	workerTasks      []sealtasks.TaskType
	workerStorageOpt func(paths.Store) paths.Store
	workerName       string
}

// DefaultNodeOpts are the default options that will be applied to test nodes.
var DefaultNodeOpts = nodeOpts{
	balance:    big.Mul(big.NewInt(100000000), types.NewInt(build.FilecoinPrecision)),
	sectors:    DefaultPresealsPerBootstrapMiner,
	sectorSize: abi.SectorSize(2 << 10), // 2KiB.

	cfgOpts: []CfgOption{
		func(cfg *config.FullNode) error {
			// test defaults

			cfg.Fevm.EnableEthRPC = true
			return nil
		},
	},

	workerTasks:      []sealtasks.TaskType{sealtasks.TTFetch, sealtasks.TTCommit1, sealtasks.TTFinalize, sealtasks.TTFinalizeUnsealed},
	workerStorageOpt: func(store paths.Store) paths.Store { return store },
}

// OptBuilder is used to create an option after some other node is already
// active. Takes all active nodes as a parameter.
type OptBuilder func(activeNodes []*TestFullNode) node.Option

// NodeOpt is a functional option for test nodes.
type NodeOpt func(opts *nodeOpts) error

func WithAllSubsystems() NodeOpt {
	return func(opts *nodeOpts) error {
		opts.subsystems = opts.subsystems.Add(SMarkets)
		opts.subsystems = opts.subsystems.Add(SMining)
		opts.subsystems = opts.subsystems.Add(SSealing)
		opts.subsystems = opts.subsystems.Add(SSectorStorage)

		return nil
	}
}

func WithSubsystems(systems ...MinerSubsystem) NodeOpt {
	return func(opts *nodeOpts) error {
		for _, s := range systems {
			opts.subsystems = opts.subsystems.Add(s)
		}
		return nil
	}
}

func WithMaxStagingDealsBytes(size int64) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.maxStagingDealsBytes = size
		return nil
	}
}

func WithNoLocalSealing(nope bool) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.minerNoLocalSealing = nope
		return nil
	}
}

func WithAssigner(a string) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.minerAssigner = a
		return nil
	}
}

func WithDisallowRemoteFinalize(d bool) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.disallowRemoteFinalize = d
		return nil
	}
}

func DisableLibp2p() NodeOpt {
	return func(opts *nodeOpts) error {
		opts.disableLibp2p = true
		return nil
	}
}

func MainMiner(m *TestMiner) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.mainMiner = m
		return nil
	}
}

// OwnerBalance specifies the balance to be attributed to a miner's owner
// account. Only relevant when creating a miner.
func OwnerBalance(balance abi.TokenAmount) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.balance = balance
		return nil
	}
}

// LiteNode specifies that this node will be a lite node. Only relevant when
// creating a fullnode.
func LiteNode() NodeOpt {
	return func(opts *nodeOpts) error {
		opts.lite = true
		return nil
	}
}

// PresealSectors specifies the amount of preseal sectors to give to a miner
// at genesis. Only relevant when creating a miner.
func PresealSectors(sectors int) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.sectors = sectors
		return nil
	}
}

// NoStorage initializes miners with no writable storage paths (just read-only preseal paths)
func NoStorage() NodeOpt {
	return func(opts *nodeOpts) error {
		opts.noStorage = true
		return nil
	}
}

// ThroughRPC makes interactions with this node throughout the test flow through
// the JSON-RPC API.
func ThroughRPC() NodeOpt {
	return func(opts *nodeOpts) error {
		opts.rpc = true
		return nil
	}
}

// OwnerAddr sets the owner address of a miner. Only relevant when creating
// a miner.
func OwnerAddr(wk *key.Key) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.ownerKey = wk
		return nil
	}
}

// ConstructorOpts are Lotus node constructor options that are passed as-is to
// the node.
func ConstructorOpts(extra ...node.Option) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.extraNodeOpts = extra
		return nil
	}
}

func MutateSealingConfig(mut func(sc *config.SealingConfig)) NodeOpt {
	return ConstructorOpts(
		node.ApplyIf(node.IsType(repo.StorageMiner), node.Override(new(dtypes.GetSealingConfigFunc), func() (dtypes.GetSealingConfigFunc, error) {
			return func() (sealiface.Config, error) {
				cf := config.DefaultStorageMiner()
				mut(&cf.Sealing)
				return modules.ToSealingConfig(cf.Dealmaking, cf.Sealing), nil
			}, nil
		})))
}

// SectorSize sets the sector size for this miner. Start() will populate the
// corresponding proof type depending on the network version (genesis network
// version if the Ensemble is unstarted, or the current network version
// if started).
func SectorSize(sectorSize abi.SectorSize) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.sectorSize = sectorSize
		return nil
	}
}

func WithTaskTypes(tt []sealtasks.TaskType) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.workerTasks = tt
		return nil
	}
}

func WithWorkerName(n string) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.workerName = n
		return nil
	}
}

var WithSealWorkerTasks = WithTaskTypes(append([]sealtasks.TaskType{sealtasks.TTAddPiece, sealtasks.TTDataCid, sealtasks.TTPreCommit1, sealtasks.TTPreCommit2, sealtasks.TTCommit2, sealtasks.TTUnseal}, DefaultNodeOpts.workerTasks...))

func WithWorkerStorage(transform func(paths.Store) paths.Store) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.workerStorageOpt = transform
		return nil
	}
}

func FsRepo() NodeOpt {
	return func(opts *nodeOpts) error {
		opts.fsrepo = true
		return nil
	}
}

func WithCfgOpt(opt CfgOption) NodeOpt {
	return func(opts *nodeOpts) error {
		opts.cfgOpts = append(opts.cfgOpts, opt)
		return nil
	}
}

type CfgOption func(cfg *config.FullNode) error

func SplitstoreDiscard() NodeOpt {
	return WithCfgOpt(func(cfg *config.FullNode) error {
		cfg.Chainstore.EnableSplitstore = true
		cfg.Chainstore.Splitstore.HotStoreFullGCFrequency = 0 // turn off full gc
		cfg.Chainstore.Splitstore.ColdStoreType = "discard"   // no cold store
		return nil
	})
}

func SplitstoreUniversal() NodeOpt {
	return WithCfgOpt(func(cfg *config.FullNode) error {
		cfg.Chainstore.EnableSplitstore = true
		cfg.Chainstore.Splitstore.HotStoreFullGCFrequency = 0 // turn off full gc
		cfg.Chainstore.Splitstore.ColdStoreType = "universal" // universal bs is coldstore
		return nil
	})
}

func SplitstoreMessges() NodeOpt {
	return WithCfgOpt(func(cfg *config.FullNode) error {
		cfg.Chainstore.EnableSplitstore = true
		cfg.Chainstore.Splitstore.HotStoreFullGCFrequency = 0 // turn off full gc
		cfg.Chainstore.Splitstore.ColdStoreType = "messages"  // universal bs is coldstore, and it accepts messages
		return nil
	})
}

func WithEthRPC() NodeOpt {
	return WithCfgOpt(func(cfg *config.FullNode) error {
		cfg.Fevm.EnableEthRPC = true
		return nil
	})
}

func DisableEthRPC() NodeOpt {
	return WithCfgOpt(func(cfg *config.FullNode) error {
		cfg.Fevm.EnableEthRPC = false
		return nil
	})
}