2020-08-15 22:57:27 +00:00
|
|
|
package conformance
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2020-09-03 21:54:19 +00:00
|
|
|
|
2020-09-07 03:49:10 +00:00
|
|
|
"github.com/filecoin-project/go-state-types/crypto"
|
2020-08-15 22:57:27 +00:00
|
|
|
|
2020-09-01 14:35:19 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/stmgr"
|
|
|
|
"github.com/filecoin-project/lotus/chain/store"
|
2020-08-26 20:39:44 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
|
|
"github.com/filecoin-project/lotus/chain/vm"
|
2020-09-08 20:50:25 +00:00
|
|
|
"github.com/filecoin-project/lotus/conformance/chaos"
|
2020-08-26 20:39:44 +00:00
|
|
|
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
|
|
|
|
"github.com/filecoin-project/lotus/lib/blockstore"
|
|
|
|
|
2020-09-07 03:49:10 +00:00
|
|
|
"github.com/filecoin-project/go-state-types/abi"
|
2020-08-19 13:31:34 +00:00
|
|
|
|
2020-08-26 20:39:44 +00:00
|
|
|
"github.com/filecoin-project/test-vectors/schema"
|
2020-08-21 10:51:50 +00:00
|
|
|
|
2020-09-01 14:35:19 +00:00
|
|
|
"github.com/filecoin-project/go-address"
|
|
|
|
|
2020-08-26 20:39:44 +00:00
|
|
|
"github.com/ipfs/go-cid"
|
2020-09-01 14:35:19 +00:00
|
|
|
ds "github.com/ipfs/go-datastore"
|
2020-08-15 22:57:27 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
// BaseFee to use in the VM.
|
|
|
|
// TODO make parametrisable through vector.
|
|
|
|
BaseFee = abi.NewTokenAmount(100)
|
|
|
|
)
|
|
|
|
|
|
|
|
type Driver struct {
|
2020-09-01 14:35:19 +00:00
|
|
|
ctx context.Context
|
|
|
|
selector schema.Selector
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewDriver(ctx context.Context, selector schema.Selector) *Driver {
|
|
|
|
return &Driver{ctx: ctx, selector: selector}
|
|
|
|
}
|
|
|
|
|
|
|
|
type ExecuteTipsetResult struct {
|
|
|
|
ReceiptsRoot cid.Cid
|
|
|
|
PostStateRoot cid.Cid
|
|
|
|
|
|
|
|
// AppliedMessages stores the messages that were applied, in the order they
|
|
|
|
// were applied. It includes implicit messages (cron, rewards).
|
|
|
|
AppliedMessages []*types.Message
|
|
|
|
// AppliedResults stores the results of AppliedMessages, in the same order.
|
|
|
|
AppliedResults []*vm.ApplyRet
|
2020-08-15 22:57:27 +00:00
|
|
|
}
|
|
|
|
|
2020-09-01 14:35:19 +00:00
|
|
|
// ExecuteTipset executes the supplied tipset on top of the state represented
|
|
|
|
// by the preroot CID.
|
|
|
|
//
|
|
|
|
// parentEpoch is the last epoch in which an actual tipset was processed. This
|
|
|
|
// is used by Lotus for null block counting and cron firing.
|
|
|
|
//
|
|
|
|
// This method returns the the receipts root, the poststate root, and the VM
|
|
|
|
// message results. The latter _include_ implicit messages, such as cron ticks
|
|
|
|
// and reward withdrawal per miner.
|
|
|
|
func (d *Driver) ExecuteTipset(bs blockstore.Blockstore, ds ds.Batching, preroot cid.Cid, parentEpoch abi.ChainEpoch, tipset *schema.Tipset) (*ExecuteTipsetResult, error) {
|
|
|
|
var (
|
|
|
|
syscalls = mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier))
|
|
|
|
vmRand = new(testRand)
|
|
|
|
|
|
|
|
cs = store.NewChainStore(bs, ds, syscalls)
|
|
|
|
sm = stmgr.NewStateManager(cs)
|
|
|
|
)
|
|
|
|
|
|
|
|
blocks := make([]store.BlockMessages, 0, len(tipset.Blocks))
|
|
|
|
for _, b := range tipset.Blocks {
|
|
|
|
sb := store.BlockMessages{
|
|
|
|
Miner: b.MinerAddr,
|
|
|
|
WinCount: b.WinCount,
|
|
|
|
}
|
|
|
|
for _, m := range b.Messages {
|
|
|
|
msg, err := types.DecodeMessage(m)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
switch msg.From.Protocol() {
|
|
|
|
case address.SECP256K1:
|
2020-09-03 21:54:19 +00:00
|
|
|
sb.SecpkMessages = append(sb.SecpkMessages, toChainMsg(msg))
|
2020-09-01 14:35:19 +00:00
|
|
|
case address.BLS:
|
2020-09-03 21:54:19 +00:00
|
|
|
sb.BlsMessages = append(sb.BlsMessages, toChainMsg(msg))
|
2020-09-01 14:35:19 +00:00
|
|
|
default:
|
2020-09-03 21:54:19 +00:00
|
|
|
// sneak in messages originating from other addresses as both kinds.
|
|
|
|
// these should fail, as they are actually invalid senders.
|
|
|
|
sb.SecpkMessages = append(sb.SecpkMessages, msg)
|
|
|
|
sb.BlsMessages = append(sb.BlsMessages, msg)
|
2020-09-01 14:35:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
blocks = append(blocks, sb)
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
|
|
|
messages []*types.Message
|
|
|
|
results []*vm.ApplyRet
|
2020-09-08 20:50:25 +00:00
|
|
|
|
|
|
|
epoch = abi.ChainEpoch(tipset.Epoch)
|
|
|
|
basefee = abi.NewTokenAmount(tipset.BaseFee.Int64())
|
2020-09-01 14:35:19 +00:00
|
|
|
)
|
|
|
|
|
2020-09-08 20:50:25 +00:00
|
|
|
postcid, receiptsroot, err := sm.ApplyBlocks(context.Background(), parentEpoch, preroot, blocks, epoch, vmRand, func(_ cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
|
2020-09-01 14:35:19 +00:00
|
|
|
messages = append(messages, msg)
|
|
|
|
results = append(results, ret)
|
|
|
|
return nil
|
2020-09-09 12:04:41 +00:00
|
|
|
}, basefee, nil)
|
2020-09-01 14:35:19 +00:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
ret := &ExecuteTipsetResult{
|
|
|
|
ReceiptsRoot: receiptsroot,
|
|
|
|
PostStateRoot: postcid,
|
|
|
|
AppliedMessages: messages,
|
|
|
|
AppliedResults: results,
|
|
|
|
}
|
|
|
|
return ret, nil
|
2020-08-15 22:57:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ExecuteMessage executes a conformance test vector message in a temporary VM.
|
2020-09-01 14:35:19 +00:00
|
|
|
func (d *Driver) ExecuteMessage(bs blockstore.Blockstore, preroot cid.Cid, epoch abi.ChainEpoch, msg *types.Message) (*vm.ApplyRet, cid.Cid, error) {
|
2020-09-24 16:58:34 +00:00
|
|
|
// dummy state manager; only to reference the GetNetworkVersion method, which does not depend on state.
|
|
|
|
sm := new(stmgr.StateManager)
|
2020-08-15 22:57:27 +00:00
|
|
|
vmOpts := &vm.VMOpts{
|
|
|
|
StateBase: preroot,
|
|
|
|
Epoch: epoch,
|
|
|
|
Rand: &testRand{}, // TODO always succeeds; need more flexibility.
|
|
|
|
Bstore: bs,
|
|
|
|
Syscalls: mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier)), // TODO always succeeds; need more flexibility.
|
|
|
|
CircSupplyCalc: nil,
|
|
|
|
BaseFee: BaseFee,
|
2020-09-24 16:58:34 +00:00
|
|
|
NtwkVersion: sm.GetNtwkVersion,
|
2020-08-15 22:57:27 +00:00
|
|
|
}
|
|
|
|
|
2020-09-17 15:30:15 +00:00
|
|
|
lvm, err := vm.NewVM(context.TODO(), vmOpts)
|
2020-08-15 22:57:27 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, cid.Undef, err
|
|
|
|
}
|
|
|
|
|
2020-09-25 00:51:34 +00:00
|
|
|
invoker := vm.NewActorRegistry()
|
2020-08-21 10:51:50 +00:00
|
|
|
|
2020-09-02 14:57:19 +00:00
|
|
|
// register the chaos actor if required by the vector.
|
2020-09-01 14:35:19 +00:00
|
|
|
if chaosOn, ok := d.selector["chaos_actor"]; ok && chaosOn == "true" {
|
2020-09-28 19:48:08 +00:00
|
|
|
invoker.Register(nil, chaos.Actor{})
|
2020-08-19 17:10:56 +00:00
|
|
|
}
|
|
|
|
|
2020-08-15 22:57:27 +00:00
|
|
|
lvm.SetInvoker(invoker)
|
|
|
|
|
2020-09-03 21:54:19 +00:00
|
|
|
ret, err := lvm.ApplyMessage(d.ctx, toChainMsg(msg))
|
2020-08-15 22:57:27 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, cid.Undef, err
|
|
|
|
}
|
|
|
|
|
|
|
|
root, err := lvm.Flush(d.ctx)
|
|
|
|
return ret, root, err
|
|
|
|
}
|
2020-09-03 21:54:19 +00:00
|
|
|
|
|
|
|
// toChainMsg injects a synthetic 0-filled signature of the right length to
|
|
|
|
// messages that originate from secp256k senders, leaving all
|
|
|
|
// others untouched.
|
|
|
|
// TODO: generate a signature in the DSL so that it's encoded in
|
|
|
|
// the test vector.
|
|
|
|
func toChainMsg(msg *types.Message) (ret types.ChainMsg) {
|
|
|
|
ret = msg
|
|
|
|
if msg.From.Protocol() == address.SECP256K1 {
|
|
|
|
ret = &types.SignedMessage{
|
|
|
|
Message: *msg,
|
|
|
|
Signature: crypto.Signature{
|
|
|
|
Type: crypto.SigTypeSecp256k1,
|
|
|
|
Data: make([]byte, 65),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|