lotus/chain/stmgr/call.go

110 lines
2.8 KiB
Go
Raw Normal View History

package stmgr
import (
"context"
2019-09-19 20:25:18 +00:00
"fmt"
2020-02-08 02:18:32 +00:00
"github.com/filecoin-project/specs-actors/actors/abi"
2019-10-15 04:33:29 +00:00
"github.com/ipfs/go-cid"
"go.opencensus.io/trace"
2019-10-15 04:33:29 +00:00
"golang.org/x/xerrors"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/vm"
)
2020-03-08 00:46:12 +00:00
func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate cid.Cid, r vm.Rand, bheight abi.ChainEpoch) (*api.InvocResult, error) {
ctx, span := trace.StartSpan(ctx, "statemanager.CallRaw")
defer span.End()
2020-04-07 18:26:43 +00:00
vmi, err := vm.NewVM(bstate, bheight, r, sm.cs.Blockstore(), sm.cs.VMSys())
if err != nil {
return nil, xerrors.Errorf("failed to set up vm: %w", err)
}
2020-03-18 20:45:37 +00:00
if msg.GasLimit == 0 {
msg.GasLimit = 10000000000
}
if msg.GasPrice == types.EmptyInt {
msg.GasPrice = types.NewInt(0)
}
if msg.Value == types.EmptyInt {
msg.Value = types.NewInt(0)
}
if span.IsRecordingEvents() {
span.AddAttributes(
2020-03-18 20:45:37 +00:00
trace.Int64Attribute("gas_limit", msg.GasLimit),
trace.Int64Attribute("gas_price", int64(msg.GasPrice.Uint64())),
trace.StringAttribute("value", msg.Value.String()),
)
}
fromActor, err := vmi.StateTree().GetActor(msg.From)
if err != nil {
2019-09-30 23:55:35 +00:00
return nil, xerrors.Errorf("call raw get actor: %s", err)
}
msg.Nonce = fromActor.Nonce
// TODO: maybe just use the invoker directly?
ret, err := vmi.ApplyImplicitMessage(ctx, msg)
if err != nil {
return nil, xerrors.Errorf("apply message failed: %w", err)
}
var errs string
if ret.ActorErr != nil {
errs = ret.ActorErr.Error()
log.Warnf("chain call failed: %s", ret.ActorErr)
}
return &api.InvocResult{
2020-03-08 00:46:12 +00:00
Msg: msg,
MsgRct: &ret.MessageReceipt,
InternalExecutions: ret.InternalExecutions,
2020-03-08 00:46:12 +00:00
Error: errs,
Duration: ret.Duration,
}, nil
}
func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
if ts == nil {
ts = sm.cs.GetHeaviestTipSet()
}
2019-08-16 19:39:09 +00:00
2019-10-02 20:03:27 +00:00
state := ts.ParentState()
r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
return sm.CallRaw(ctx, msg, state, r, ts.Height())
}
2019-09-19 20:25:18 +00:00
var errHaltExecution = fmt.Errorf("halt")
func (sm *StateManager) Replay(ctx context.Context, ts *types.TipSet, mcid cid.Cid) (*types.Message, *vm.ApplyRet, error) {
var outm *types.Message
var outr *vm.ApplyRet
2019-09-27 23:55:15 +00:00
_, _, err := sm.computeTipSetState(ctx, ts.Blocks(), func(c cid.Cid, m *types.Message, ret *vm.ApplyRet) error {
2019-09-19 20:25:18 +00:00
if c == mcid {
outm = m
outr = ret
return errHaltExecution
}
return nil
})
if err != nil && err != errHaltExecution {
return nil, nil, xerrors.Errorf("unexpected error during execution: %w", err)
}
if outr == nil {
return nil, nil, xerrors.Errorf("given message not found in tipset")
}
2019-09-19 20:25:18 +00:00
return outm, outr, nil
}