lotus/chain/consensus/filcns/compute_state.go

318 lines
10 KiB
Go
Raw Normal View History

2021-09-02 16:07:23 +00:00
package filcns
import (
"context"
"sync/atomic"
"github.com/ipfs/go-cid"
cbg "github.com/whyrusleeping/cbor-gen"
"go.opencensus.io/stats"
"go.opencensus.io/trace"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-state-types/abi"
2022-09-06 15:49:29 +00:00
actorstypes "github.com/filecoin-project/go-state-types/actors"
2021-09-02 16:07:23 +00:00
"github.com/filecoin-project/go-state-types/big"
2022-09-06 15:49:29 +00:00
exported0 "github.com/filecoin-project/specs-actors/actors/builtin/exported"
2021-09-02 16:07:23 +00:00
blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
2022-09-06 15:49:29 +00:00
exported2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/exported"
exported3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/exported"
exported4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/exported"
exported5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/exported"
exported6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/exported"
exported7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/exported"
2021-09-02 16:07:23 +00:00
"github.com/filecoin-project/lotus/blockstore"
2021-09-02 16:07:23 +00:00
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/builtin/cron"
"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
2022-06-14 15:00:51 +00:00
"github.com/filecoin-project/lotus/chain/rand"
2021-09-02 16:07:23 +00:00
"github.com/filecoin-project/lotus/chain/stmgr"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/vm"
"github.com/filecoin-project/lotus/metrics"
)
func NewActorRegistry() *vm.ActorRegistry {
inv := vm.NewActorRegistry()
inv.Register(actorstypes.Version0, vm.ActorsVersionPredicate(actorstypes.Version0), builtin.MakeRegistryLegacy(exported0.BuiltinActors()))
inv.Register(actorstypes.Version2, vm.ActorsVersionPredicate(actorstypes.Version2), builtin.MakeRegistryLegacy(exported2.BuiltinActors()))
inv.Register(actorstypes.Version3, vm.ActorsVersionPredicate(actorstypes.Version3), builtin.MakeRegistryLegacy(exported3.BuiltinActors()))
inv.Register(actorstypes.Version4, vm.ActorsVersionPredicate(actorstypes.Version4), builtin.MakeRegistryLegacy(exported4.BuiltinActors()))
inv.Register(actorstypes.Version5, vm.ActorsVersionPredicate(actorstypes.Version5), builtin.MakeRegistryLegacy(exported5.BuiltinActors()))
inv.Register(actorstypes.Version6, vm.ActorsVersionPredicate(actorstypes.Version6), builtin.MakeRegistryLegacy(exported6.BuiltinActors()))
inv.Register(actorstypes.Version7, vm.ActorsVersionPredicate(actorstypes.Version7), builtin.MakeRegistryLegacy(exported7.BuiltinActors()))
inv.Register(actorstypes.Version8, vm.ActorsVersionPredicate(actorstypes.Version8), builtin.MakeRegistry(actorstypes.Version8))
inv.Register(actorstypes.Version9, vm.ActorsVersionPredicate(actorstypes.Version9), builtin.MakeRegistry(actorstypes.Version9))
2022-11-09 09:32:50 +00:00
inv.Register(actorstypes.Version10, vm.ActorsVersionPredicate(actorstypes.Version10), builtin.MakeRegistry(actorstypes.Version10))
2022-06-09 19:39:33 +00:00
2021-09-02 16:07:23 +00:00
return inv
}
2021-09-02 16:45:18 +00:00
type TipSetExecutor struct{}
2021-09-02 16:07:23 +00:00
2021-09-02 16:45:18 +00:00
func NewTipSetExecutor() *TipSetExecutor {
return &TipSetExecutor{}
2021-09-02 16:07:23 +00:00
}
2021-09-02 16:45:18 +00:00
func (t *TipSetExecutor) NewActorRegistry() *vm.ActorRegistry {
2021-09-02 16:07:23 +00:00
return NewActorRegistry()
}
type FilecoinBlockMessages struct {
store.BlockMessages
WinCount int64
}
func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
sm *stmgr.StateManager,
parentEpoch abi.ChainEpoch,
pstate cid.Cid,
bms []FilecoinBlockMessages,
epoch abi.ChainEpoch,
r vm.Rand,
em stmgr.ExecMonitor,
vmTracing bool,
baseFee abi.TokenAmount,
ts *types.TipSet) (cid.Cid, cid.Cid, error) {
2021-09-02 16:07:23 +00:00
done := metrics.Timer(ctx, metrics.VMApplyBlocksTotal)
defer done()
partDone := metrics.Timer(ctx, metrics.VMApplyEarly)
defer func() {
partDone()
}()
ctx = blockstore.WithHotView(ctx)
2022-03-15 22:46:56 +00:00
makeVmWithBaseStateAndEpoch := func(base cid.Cid, e abi.ChainEpoch) (vm.Interface, error) {
2021-09-02 16:07:23 +00:00
vmopt := &vm.VMOpts{
StateBase: base,
2022-01-17 21:08:16 +00:00
Epoch: e,
2021-09-02 16:07:23 +00:00
Rand: r,
Bstore: sm.ChainStore().StateBlockstore(),
Actors: NewActorRegistry(),
Syscalls: sm.Syscalls,
CircSupplyCalc: sm.GetVMCirculatingSupply,
2022-01-17 21:08:16 +00:00
NetworkVersion: sm.GetNetworkVersion(ctx, e),
2021-09-02 16:07:23 +00:00
BaseFee: baseFee,
LookbackState: stmgr.LookbackStateGetterForTipset(sm, ts),
Tracing: vmTracing,
2021-09-02 16:07:23 +00:00
}
return sm.VMConstructor()(ctx, vmopt)
}
2022-03-15 22:46:56 +00:00
runCron := func(vmCron vm.Interface, epoch abi.ChainEpoch) error {
2021-09-02 16:07:23 +00:00
cronMsg := &types.Message{
To: cron.Address,
From: builtin.SystemActorAddr,
Nonce: uint64(epoch),
Value: types.NewInt(0),
GasFeeCap: types.NewInt(0),
GasPremium: types.NewInt(0),
GasLimit: build.BlockGasLimit * 10000, // Make super sure this is never too little
Method: cron.Methods.EpochTick,
Params: nil,
}
2022-01-17 21:08:16 +00:00
ret, err := vmCron.ApplyImplicitMessage(ctx, cronMsg)
2021-09-02 16:07:23 +00:00
if err != nil {
2022-01-17 21:08:16 +00:00
return xerrors.Errorf("running cron: %w", err)
2021-09-02 16:07:23 +00:00
}
2022-01-17 21:08:16 +00:00
2021-09-02 16:07:23 +00:00
if em != nil {
if err := em.MessageApplied(ctx, ts, cronMsg.Cid(), cronMsg, ret, true); err != nil {
return xerrors.Errorf("callback failed on cron message: %w", err)
}
}
if ret.ExitCode != 0 {
2022-01-17 21:08:16 +00:00
return xerrors.Errorf("cron exit was non-zero: %d", ret.ExitCode)
2021-09-02 16:07:23 +00:00
}
return nil
}
for i := parentEpoch; i < epoch; i++ {
2022-01-17 21:08:16 +00:00
var err error
2021-09-02 16:07:23 +00:00
if i > parentEpoch {
2022-01-17 21:08:16 +00:00
vmCron, err := makeVmWithBaseStateAndEpoch(pstate, i)
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("making cron vm: %w", err)
}
2021-09-02 16:07:23 +00:00
// run cron for null rounds if any
2022-01-17 21:08:16 +00:00
if err = runCron(vmCron, i); err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("running cron: %w", err)
2021-09-02 16:07:23 +00:00
}
2022-01-17 21:08:16 +00:00
pstate, err = vmCron.Flush(ctx)
2021-09-02 16:07:23 +00:00
if err != nil {
2022-01-17 21:08:16 +00:00
return cid.Undef, cid.Undef, xerrors.Errorf("flushing cron vm: %w", err)
2021-09-02 16:07:23 +00:00
}
}
// handle state forks
// XXX: The state tree
2022-01-17 21:08:16 +00:00
pstate, err = sm.HandleStateForks(ctx, pstate, i, em, ts)
2021-09-02 16:07:23 +00:00
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("error handling state forks: %w", err)
}
}
partDone()
partDone = metrics.Timer(ctx, metrics.VMApplyMessages)
2022-01-17 21:08:16 +00:00
vmi, err := makeVmWithBaseStateAndEpoch(pstate, epoch)
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("making vm: %w", err)
}
2021-09-02 16:07:23 +00:00
var receipts []cbg.CBORMarshaler
processedMsgs := make(map[cid.Cid]struct{})
for _, b := range bms {
penalty := types.NewInt(0)
gasReward := big.Zero()
for _, cm := range append(b.BlsMessages, b.SecpkMessages...) {
m := cm.VMMessage()
if _, found := processedMsgs[m.Cid()]; found {
continue
}
r, err := vmi.ApplyMessage(ctx, cm)
if err != nil {
return cid.Undef, cid.Undef, err
}
receipts = append(receipts, &r.MessageReceipt)
gasReward = big.Add(gasReward, r.GasCosts.MinerTip)
penalty = big.Add(penalty, r.GasCosts.MinerPenalty)
if em != nil {
if err := em.MessageApplied(ctx, ts, cm.Cid(), m, r, false); err != nil {
return cid.Undef, cid.Undef, err
}
}
processedMsgs[m.Cid()] = struct{}{}
}
params, err := actors.SerializeParams(&reward.AwardBlockRewardParams{
Miner: b.Miner,
Penalty: penalty,
GasReward: gasReward,
WinCount: b.WinCount,
})
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("failed to serialize award params: %w", err)
}
rwMsg := &types.Message{
From: builtin.SystemActorAddr,
To: reward.Address,
Nonce: uint64(epoch),
Value: types.NewInt(0),
GasFeeCap: types.NewInt(0),
GasPremium: types.NewInt(0),
GasLimit: 1 << 30,
Method: reward.Methods.AwardBlockReward,
Params: params,
}
ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
if actErr != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, actErr)
}
if em != nil {
if err := em.MessageApplied(ctx, ts, rwMsg.Cid(), rwMsg, ret, true); err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("callback failed on reward message: %w", err)
}
}
if ret.ExitCode != 0 {
return cid.Undef, cid.Undef, xerrors.Errorf("reward application message failed (exit %d): %s", ret.ExitCode, ret.ActorErr)
}
}
partDone()
partDone = metrics.Timer(ctx, metrics.VMApplyCron)
2022-01-17 21:08:16 +00:00
if err := runCron(vmi, epoch); err != nil {
2021-09-02 16:07:23 +00:00
return cid.Cid{}, cid.Cid{}, err
}
partDone()
partDone = metrics.Timer(ctx, metrics.VMApplyFlush)
rectarr := blockadt.MakeEmptyArray(sm.ChainStore().ActorStore(ctx))
for i, receipt := range receipts {
if err := rectarr.Set(uint64(i), receipt); err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("failed to build receipts amt: %w", err)
}
}
rectroot, err := rectarr.Root()
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("failed to build receipts amt: %w", err)
}
st, err := vmi.Flush(ctx)
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("vm flush failed: %w", err)
}
stats.Record(ctx, metrics.VMSends.M(int64(atomic.LoadUint64(&vm.StatSends))),
metrics.VMApplied.M(int64(atomic.LoadUint64(&vm.StatApplied))))
return st, rectroot, nil
}
func (t *TipSetExecutor) ExecuteTipSet(ctx context.Context,
sm *stmgr.StateManager,
ts *types.TipSet,
em stmgr.ExecMonitor,
vmTracing bool) (stateroot cid.Cid, rectsroot cid.Cid, err error) {
2021-09-02 16:07:23 +00:00
ctx, span := trace.StartSpan(ctx, "computeTipSetState")
defer span.End()
blks := ts.Blocks()
for i := 0; i < len(blks); i++ {
for j := i + 1; j < len(blks); j++ {
if blks[i].Miner == blks[j].Miner {
return cid.Undef, cid.Undef,
xerrors.Errorf("duplicate miner in a tipset (%s %s)",
blks[i].Miner, blks[j].Miner)
}
}
}
var parentEpoch abi.ChainEpoch
pstate := blks[0].ParentStateRoot
if blks[0].Height > 0 {
2021-12-11 21:03:00 +00:00
parent, err := sm.ChainStore().GetBlock(ctx, blks[0].Parents[0])
2021-09-02 16:07:23 +00:00
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("getting parent block: %w", err)
}
parentEpoch = parent.Height
}
r := rand.NewStateRand(sm.ChainStore(), ts.Cids(), sm.Beacon(), sm.GetNetworkVersion)
2021-09-02 16:07:23 +00:00
2021-12-17 09:42:09 +00:00
blkmsgs, err := sm.ChainStore().BlockMsgsForTipset(ctx, ts)
2021-09-02 16:07:23 +00:00
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("getting block messages for tipset: %w", err)
}
fbmsgs := make([]FilecoinBlockMessages, len(blkmsgs))
for i := range fbmsgs {
fbmsgs[i].BlockMessages = blkmsgs[i]
fbmsgs[i].WinCount = ts.Blocks()[i].ElectionProof.WinCount
}
baseFee := blks[0].ParentBaseFee
return t.ApplyBlocks(ctx, sm, parentEpoch, pstate, fbmsgs, blks[0].Height, r, em, vmTracing, baseFee, ts)
2021-09-02 16:07:23 +00:00
}
2021-09-02 16:45:18 +00:00
var _ stmgr.Executor = &TipSetExecutor{}