Merge pull request #105 from filecoin-project/feat/multisig

Implement multisig

chain/actors/actor_multisig.go

@@ -0,0 +1,390 @@
+package actors
+
+import (
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/go-lotus/chain/actors/aerrors"
+	"github.com/filecoin-project/go-lotus/chain/address"
+	"github.com/filecoin-project/go-lotus/chain/types"
+)
+
+func init() {
+	cbor.RegisterCborType(MultiSigActorState{})
+	cbor.RegisterCborType(MultiSigConstructorParams{})
+	cbor.RegisterCborType(MultiSigProposeParams{})
+	cbor.RegisterCborType(MultiSigTxID{})
+	cbor.RegisterCborType(MultiSigSwapSignerParams{})
+	cbor.RegisterCborType(MultiSigChangeReqParams{})
+	cbor.RegisterCborType(MTransaction{})
+	cbor.RegisterCborType(MultiSigRemoveSignerParam{})
+	cbor.RegisterCborType(MultiSigAddSignerParam{})
+}
+
+type MultiSigActor struct{}
+type MultiSigActorState struct {
+	Signers  []address.Address
+	Required uint32
+	NextTxID uint64
+
+	//TODO: make this map/sharray/whatever
+	Transactions []MTransaction
+}
+
+func (msas MultiSigActorState) isSigner(addr address.Address) bool {
+	for _, s := range msas.Signers {
+		if s == addr {
+			return true
+		}
+	}
+	return false
+}
+
+func (msas MultiSigActorState) getTransaction(txid uint64) *MTransaction {
+	if txid > uint64(len(msas.Transactions)) {
+		return nil
+	}
+	return &msas.Transactions[txid]
+}
+
+type MTransaction struct {
+	Created uint64 // NOT USED ??
+	TxID    uint64
+
+	To     address.Address
+	Value  types.BigInt
+	Method uint64
+	Params []byte
+
+	Approved []address.Address
+	Complete bool
+	Canceled bool
+	RetCode  uint8
+}
+
+func (tx MTransaction) Active() ActorError {
+	if tx.Complete {
+		return aerrors.New(2, "transaction already completed")
+	}
+	if tx.Canceled {
+		return aerrors.New(3, "transaction canceled")
+	}
+	return nil
+}
+
+type musigMethods struct {
+	MultiSigConstructor uint64
+	Propose             uint64
+	Approve             uint64
+	Cancel              uint64
+	ClearCompleted      uint64
+	AddSigner           uint64
+	RemoveSigner        uint64
+	SwapSigner          uint64
+	ChangeRequirement   uint64
+}
+
+var MultiSigMethods = musigMethods{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+func (msa MultiSigActor) Exports() []interface{} {
+	return []interface{}{
+		1: msa.MultiSigConstructor,
+		2: msa.Propose,
+		3: msa.Approve,
+		4: msa.Cancel,
+		//5: msa.ClearCompleted,
+		6: msa.AddSigner,
+		7: msa.RemoveSigner,
+		8: msa.SwapSigner,
+		9: msa.ChangeRequirement,
+	}
+}
+
+type MultiSigConstructorParams struct {
+	Signers  []address.Address
+	Required uint32
+}
+
+func (MultiSigActor) MultiSigConstructor(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigConstructorParams) ([]byte, ActorError) {
+	self := &MultiSigActorState{
+		Signers:  params.Signers,
+		Required: params.Required,
+	}
+	head, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "could not put new head")
+	}
+	err = vmctx.Storage().Commit(EmptyCBOR, head)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "could not commit new head")
+	}
+	return nil, nil
+}
+
+type MultiSigProposeParams struct {
+	To     address.Address
+	Value  types.BigInt
+	Method uint64
+	Params []byte
+}
+
+func (MultiSigActor) load(vmctx types.VMContext) (cid.Cid, *MultiSigActorState, ActorError) {
+	var self MultiSigActorState
+	head := vmctx.Storage().GetHead()
+
+	err := vmctx.Storage().Get(head, &self)
+	if err != nil {
+		return cid.Undef, nil, aerrors.Wrap(err, "could not get self")
+	}
+	return head, &self, nil
+}
+
+func (msa MultiSigActor) loadAndVerify(vmctx types.VMContext) (cid.Cid, *MultiSigActorState, ActorError) {
+	head, self, err := msa.load(vmctx)
+	if err != nil {
+		return cid.Undef, nil, err
+	}
+
+	if !self.isSigner(vmctx.Message().From) {
+		return cid.Undef, nil, aerrors.New(1, "not authorized")
+	}
+	return head, self, nil
+}
+
+func (MultiSigActor) save(vmctx types.VMContext, oldHead cid.Cid, self *MultiSigActorState) ActorError {
+	newHead, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return aerrors.Wrap(err, "could not put new head")
+	}
+	err = vmctx.Storage().Commit(oldHead, newHead)
+	if err != nil {
+		return aerrors.Wrap(err, "could not commit new head")
+	}
+	return nil
+
+}
+
+func (msa MultiSigActor) Propose(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigProposeParams) ([]byte, ActorError) {
+
+	head, self, err := msa.loadAndVerify(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	txid := self.NextTxID
+	self.NextTxID++
+
+	{
+		tx := MTransaction{
+			TxID:     txid,
+			To:       params.To,
+			Value:    params.Value,
+			Method:   params.Method,
+			Params:   params.Params,
+			Approved: []address.Address{vmctx.Message().From},
+		}
+		self.Transactions = append(self.Transactions, tx)
+	}
+	tx := self.getTransaction(txid)
+
+	if self.Required == 1 {
+		_, err := vmctx.Send(tx.To, tx.Method, tx.Value, tx.Params)
+		if aerrors.IsFatal(err) {
+			return nil, err
+		}
+		tx.RetCode = aerrors.RetCode(err)
+		tx.Complete = true
+	}
+
+	err = msa.save(vmctx, head, self)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "saving state")
+	}
+
+	return SerializeParams(tx.TxID)
+}
+
+type MultiSigTxID struct {
+	TxID uint64
+}
+
+func (msa MultiSigActor) Approve(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigTxID) ([]byte, ActorError) {
+
+	head, self, err := msa.loadAndVerify(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	tx := self.getTransaction(params.TxID)
+	if err := tx.Active(); err != nil {
+		return nil, aerrors.Wrap(err, "could not approve")
+	}
+
+	for _, signer := range tx.Approved {
+		if signer == vmctx.Message().From {
+			return nil, aerrors.New(4, "already signed this message")
+		}
+	}
+	tx.Approved = append(tx.Approved, vmctx.Message().From)
+	if uint32(len(tx.Approved)) >= self.Required {
+		_, err := vmctx.Send(tx.To, tx.Method, tx.Value, tx.Params)
+		if aerrors.IsFatal(err) {
+			return nil, err
+		}
+		tx.RetCode = aerrors.RetCode(err)
+		tx.Complete = true
+	}
+
+	return nil, msa.save(vmctx, head, self)
+}
+
+func (msa MultiSigActor) Cancel(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigTxID) ([]byte, ActorError) {
+
+	head, self, err := msa.loadAndVerify(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	tx := self.getTransaction(params.TxID)
+	if err := tx.Active(); err != nil {
+		return nil, aerrors.Wrap(err, "could not cancel")
+	}
+
+	proposer := tx.Approved[0]
+	if proposer != vmctx.Message().From && self.isSigner(proposer) {
+		return nil, aerrors.New(4, "cannot cancel another signers transaction")
+	}
+	tx.Canceled = true
+
+	return nil, msa.save(vmctx, head, self)
+}
+
+type MultiSigAddSignerParam struct {
+	Signer   address.Address
+	Increase bool
+}
+
+func (msa MultiSigActor) AddSigner(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigAddSignerParam) ([]byte, ActorError) {
+
+	head, self, err := msa.load(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	msg := vmctx.Message()
+	if msg.From != msg.To {
+		return nil, aerrors.New(4, "add signer must be called by wallet itself")
+	}
+	if self.isSigner(params.Signer) {
+		return nil, aerrors.New(5, "new address is already a signer")
+	}
+
+	self.Signers = append(self.Signers, params.Signer)
+	if params.Increase {
+		self.Required = self.Required + 1
+	}
+
+	return nil, msa.save(vmctx, head, self)
+}
+
+type MultiSigRemoveSignerParam struct {
+	Signer   address.Address
+	Decrease bool
+}
+
+func (msa MultiSigActor) RemoveSigner(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigRemoveSignerParam) ([]byte, ActorError) {
+
+	head, self, err := msa.load(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	msg := vmctx.Message()
+	if msg.From != msg.To {
+		return nil, aerrors.New(4, "remove signer must be called by wallet itself")
+	}
+	if !self.isSigner(params.Signer) {
+		return nil, aerrors.New(5, "given address was not a signer")
+	}
+
+	newSigners := make([]address.Address, 0, len(self.Signers)-1)
+	for _, s := range self.Signers {
+		if s != params.Signer {
+			newSigners = append(newSigners, s)
+		}
+	}
+	if params.Decrease || uint32(len(self.Signers)-1) < self.Required {
+		self.Required = self.Required - 1
+	}
+
+	self.Signers = newSigners
+
+	return nil, msa.save(vmctx, head, self)
+}
+
+type MultiSigSwapSignerParams struct {
+	From address.Address
+	To   address.Address
+}
+
+func (msa MultiSigActor) SwapSigner(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigSwapSignerParams) ([]byte, ActorError) {
+
+	head, self, err := msa.load(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	msg := vmctx.Message()
+	if msg.From != msg.To {
+		return nil, aerrors.New(4, "swap signer must be called by wallet itself")
+	}
+
+	if !self.isSigner(params.From) {
+		return nil, aerrors.New(5, "given old address was not a signer")
+	}
+	if self.isSigner(params.To) {
+		return nil, aerrors.New(6, "given new address was already a signer")
+	}
+
+	newSigners := make([]address.Address, 0, len(self.Signers))
+	for _, s := range self.Signers {
+		if s != params.From {
+			newSigners = append(newSigners, s)
+		}
+	}
+	newSigners = append(newSigners, params.To)
+	self.Signers = newSigners
+
+	return nil, msa.save(vmctx, head, self)
+}
+
+type MultiSigChangeReqParams struct {
+	Req uint32
+}
+
+func (msa MultiSigActor) ChangeRequirement(act *types.Actor, vmctx types.VMContext,
+	params *MultiSigChangeReqParams) ([]byte, ActorError) {
+
+	head, self, err := msa.load(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	msg := vmctx.Message()
+	if msg.From != msg.To {
+		return nil, aerrors.New(4, "change requirement must be called by wallet itself")
+	}
+
+	if params.Req < 1 {
+		return nil, aerrors.New(5, "requirement must be at least 1")
+	}
+	self.Required = params.Req
+	return nil, msa.save(vmctx, head, self)
+}

chain/actors/actor_multisig_test.go

@@ -0,0 +1,108 @@
+package actors_test
+
+import (
+	"context"
+	"testing"
+
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/stretchr/testify/assert"
+	"go.opencensus.io/trace"
+
+	"github.com/filecoin-project/go-lotus/chain/actors"
+	"github.com/filecoin-project/go-lotus/chain/address"
+	"github.com/filecoin-project/go-lotus/chain/types"
+	"github.com/filecoin-project/go-lotus/chain/vm"
+	"github.com/filecoin-project/go-lotus/tracing"
+)
+
+func TestMultiSigCreate(t *testing.T) {
+	var creatorAddr, sig1Addr, sig2Addr, outsideAddr address.Address
+	opts := []HarnessOpt{
+		HarnessAddr(&creatorAddr, 10000),
+		HarnessAddr(&sig1Addr, 10000),
+		HarnessAddr(&sig2Addr, 10000),
+		HarnessAddr(&outsideAddr, 10000),
+	}
+
+	h := NewHarness2(t, opts...)
+	ret, _ := h.CreateActor(t, creatorAddr, actors.MultisigActorCodeCid,
+		actors.MultiSigConstructorParams{
+			Signers:  []address.Address{creatorAddr, sig1Addr, sig2Addr},
+			Required: 2,
+		})
+	ApplyOK(t, ret)
+}
+
+func ApplyOK(t testing.TB, ret *vm.ApplyRet) {
+	t.Helper()
+	if ret.ExitCode != 0 {
+		t.Fatalf("exit code should be 0, got %d, actorErr: %+v", ret.ExitCode, ret.ActorErr)
+	}
+}
+
+func TestMultiSigOps(t *testing.T) {
+	je := tracing.SetupJaegerTracing("test")
+	defer je.Flush()
+	ctx, span := trace.StartSpan(context.Background(), "/test-"+t.Name())
+	defer span.End()
+
+	var creatorAddr, sig1Addr, sig2Addr, outsideAddr address.Address
+	var multSigAddr address.Address
+	opts := []HarnessOpt{
+		HarnessCtx(ctx),
+		HarnessAddr(&creatorAddr, 10000),
+		HarnessAddr(&sig1Addr, 10000),
+		HarnessAddr(&sig2Addr, 10000),
+		HarnessAddr(&outsideAddr, 1000),
+		HarnessActor(&multSigAddr, &creatorAddr, actors.MultisigActorCodeCid,
+			func() interface{} {
+				return actors.MultiSigConstructorParams{
+					Signers:  []address.Address{creatorAddr, sig1Addr, sig2Addr},
+					Required: 2,
+				}
+			}),
+	}
+
+	curVal := types.NewInt(2000)
+	h := NewHarness2(t, opts...)
+	{
+		// Send funds into the multisig
+		ret, state := h.SendFunds(t, creatorAddr, multSigAddr, curVal)
+		ApplyOK(t, ret)
+		ms, err := state.GetActor(multSigAddr)
+		assert.NoError(t, err)
+		assert.Equal(t, curVal, ms.Balance)
+	}
+
+	{
+		// Transfer funds outside of multsig
+		sendVal := types.NewInt(100)
+		ret, _ := h.Invoke(t, creatorAddr, multSigAddr, actors.MultiSigMethods.Propose,
+			actors.MultiSigProposeParams{
+				To:    outsideAddr,
+				Value: sendVal,
+			})
+		ApplyOK(t, ret)
+		var txIDParam actors.MultiSigTxID
+		err := cbor.DecodeInto(ret.Return, &txIDParam.TxID)
+		assert.NoError(t, err, "decoding txid")
+
+		ret, _ = h.Invoke(t, outsideAddr, multSigAddr, actors.MultiSigMethods.Approve,
+			txIDParam)
+		assert.Equal(t, uint8(1), ret.ExitCode, "outsideAddr should not approve")
+
+		ret, state := h.Invoke(t, sig1Addr, multSigAddr, actors.MultiSigMethods.Approve,
+			txIDParam)
+		outAct, err := state.GetActor(outsideAddr)
+		ApplyOK(t, ret)
+		curVal = types.BigSub(curVal, sendVal)
+
+		assert.NoError(t, err)
+		assert.Equal(t, types.NewInt(1099), outAct.Balance)
+
+		msAct, err := state.GetActor(multSigAddr)
+		assert.NoError(t, err)
+		assert.Equal(t, curVal, msAct.Balance)
+	}
+
+}

chain/actors/actor_storagemarket_test.go

@@ -44,8 +44,8 @@ func TestStorageMarketCreateMiner(t *testing.T) {
 					t.Fatal(err)
 				}
 
-				if sminer.String() != "t0102" {
+				if sminer.String() != "t0103" {
-					t.Fatal("hold up")
+					t.Fatalf("hold up got: %s", sminer)
 				}
 				h.Steps[1].M.Params = h.DumpObject(&IsMinerParam{Addr: sminer})
 				h.Steps[2].M.Params = h.DumpObject(&PowerLookupParams{Miner: sminer})

chain/actors/harness2_test.go

@@ -0,0 +1,233 @@
+package actors_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ipfs/go-cid"
+	dstore "github.com/ipfs/go-datastore"
+	hamt "github.com/ipfs/go-hamt-ipld"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	bstore "github.com/ipfs/go-ipfs-blockstore"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-lotus/chain/actors"
+	"github.com/filecoin-project/go-lotus/chain/address"
+	"github.com/filecoin-project/go-lotus/chain/gen"
+	"github.com/filecoin-project/go-lotus/chain/state"
+	"github.com/filecoin-project/go-lotus/chain/store"
+	"github.com/filecoin-project/go-lotus/chain/types"
+	"github.com/filecoin-project/go-lotus/chain/vm"
+)
+
+type HarnessInit struct {
+	NAddrs uint64
+	Addrs  map[address.Address]types.BigInt
+	Miner  address.Address
+}
+
+type HarnessStage int
+
+const (
+	HarnessPreInit HarnessStage = iota
+	HarnessPostInit
+)
+
+type HarnessOpt func(testing.TB, *Harness2) error
+
+type Harness2 struct {
+	HI     HarnessInit
+	Stage  HarnessStage
+	Nonces map[address.Address]uint64
+
+	ctx context.Context
+	bs  blockstore.Blockstore
+	vm  *vm.VM
+	cs  *store.ChainStore
+}
+
+var HarnessMinerFunds = types.NewInt(1000000)
+
+func HarnessAddr(addr *address.Address, value uint64) HarnessOpt {
+	return func(t testing.TB, h *Harness2) error {
+		if h.Stage != HarnessPreInit {
+			return nil
+		}
+		hi := &h.HI
+		if addr.Empty() {
+			*addr = blsaddr(hi.NAddrs)
+			hi.NAddrs++
+		}
+		hi.Addrs[*addr] = types.NewInt(value)
+		return nil
+	}
+}
+
+func HarnessMiner(addr *address.Address) HarnessOpt {
+	return func(_ testing.TB, h *Harness2) error {
+		if h.Stage != HarnessPreInit {
+			return nil
+		}
+		hi := &h.HI
+		if addr.Empty() {
+			*addr = hi.Miner
+			return nil
+		}
+		delete(hi.Addrs, hi.Miner)
+		hi.Miner = *addr
+		return nil
+	}
+}
+
+func HarnessActor(actor *address.Address, creator *address.Address, code cid.Cid, params func() interface{}) HarnessOpt {
+	return func(t testing.TB, h *Harness2) error {
+		if h.Stage != HarnessPostInit {
+			return nil
+		}
+		if !actor.Empty() {
+			return xerrors.New("actor address should be empty")
+		}
+
+		ret, _ := h.CreateActor(t, *creator, code, params())
+		if ret.ExitCode != 0 {
+			return xerrors.Errorf("creating actor: %w", ret.ActorErr)
+		}
+		var err error
+		*actor, err = address.NewFromBytes(ret.Return)
+		return err
+	}
+
+}
+
+func HarnessCtx(ctx context.Context) HarnessOpt {
+	return func(t testing.TB, h *Harness2) error {
+		h.ctx = ctx
+		return nil
+	}
+}
+
+func NewHarness2(t *testing.T, options ...HarnessOpt) *Harness2 {
+	h := &Harness2{
+		Stage:  HarnessPreInit,
+		Nonces: make(map[address.Address]uint64),
+		HI: HarnessInit{
+			NAddrs: 1,
+			Miner:  blsaddr(0),
+			Addrs: map[address.Address]types.BigInt{
+				blsaddr(0): HarnessMinerFunds,
+			},
+		},
+
+		ctx: context.Background(),
+		bs:  bstore.NewBlockstore(dstore.NewMapDatastore()),
+	}
+	for _, opt := range options {
+		err := opt(t, h)
+		if err != nil {
+			t.Fatalf("Applying options: %v", err)
+		}
+	}
+
+	st, err := gen.MakeInitialStateTree(h.bs, h.HI.Addrs)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stateroot, err := st.Flush()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h.cs = store.NewChainStore(h.bs, nil)
+	h.vm, err = vm.NewVM(stateroot, 1, h.HI.Miner, h.cs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	h.Stage = HarnessPostInit
+	for _, opt := range options {
+		err := opt(t, h)
+		if err != nil {
+			t.Fatalf("Applying options: %v", err)
+		}
+	}
+
+	return h
+}
+
+func (h *Harness2) Apply(t testing.TB, msg types.Message) (*vm.ApplyRet, *state.StateTree) {
+	t.Helper()
+	if msg.Nonce == 0 {
+		msg.Nonce, _ = h.Nonces[msg.From]
+		h.Nonces[msg.From] = msg.Nonce + 1
+	}
+
+	ret, err := h.vm.ApplyMessage(h.ctx, &msg)
+	if err != nil {
+		t.Fatalf("Applying message: %+v", err)
+	}
+	stateroot, err := h.vm.Flush(context.TODO())
+	if err != nil {
+		t.Fatalf("Flushing VM: %+v", err)
+	}
+	cst := hamt.CSTFromBstore(h.bs)
+	state, err := state.LoadStateTree(cst, stateroot)
+	if err != nil {
+		t.Fatalf("Loading state tree: %+v", err)
+	}
+	return ret, state
+}
+
+func (h *Harness2) CreateActor(t testing.TB, from address.Address,
+	code cid.Cid, params interface{}) (*vm.ApplyRet, *state.StateTree) {
+	t.Helper()
+
+	return h.Apply(t, types.Message{
+		To:     actors.InitActorAddress,
+		From:   from,
+		Method: actors.IAMethods.Exec,
+		Params: DumpObject(t,
+			&actors.ExecParams{
+				Code:   code,
+				Params: DumpObject(t, params),
+			}),
+		GasPrice: types.NewInt(1),
+		GasLimit: types.NewInt(1),
+		Value:    types.NewInt(0),
+	})
+}
+
+func (h *Harness2) SendFunds(t testing.TB, from address.Address, to address.Address,
+	value types.BigInt) (*vm.ApplyRet, *state.StateTree) {
+	t.Helper()
+	return h.Apply(t, types.Message{
+		To:       to,
+		From:     from,
+		Method:   0,
+		Value:    value,
+		GasPrice: types.NewInt(1),
+		GasLimit: types.NewInt(1),
+	})
+}
+
+func (h *Harness2) Invoke(t testing.TB, from address.Address, to address.Address,
+	method uint64, params interface{}) (*vm.ApplyRet, *state.StateTree) {
+	t.Helper()
+	return h.Apply(t, types.Message{
+		To:       to,
+		From:     from,
+		Method:   method,
+		Value:    types.NewInt(0),
+		Params:   DumpObject(t, params),
+		GasPrice: types.NewInt(1),
+		GasLimit: types.NewInt(1),
+	})
+}
+
+func DumpObject(t testing.TB, obj interface{}) []byte {
+	t.Helper()
+	enc, err := cbor.DumpObject(obj)
+	if err != nil {
+		t.Fatalf("dumping params: %+v", err)
+	}
+	return enc
+}

chain/actors/harness_test.go

@@ -45,7 +45,7 @@ func NewHarness(t *testing.T) *Harness {
 
 	from := blsaddr(0)
 	maddr := blsaddr(1)
-	third := blsaddr(1)
+	third := blsaddr(2)
 
 	actors := map[address.Address]types.BigInt{
 		from:  types.NewInt(1000000),
@@ -64,7 +64,7 @@ func NewHarness(t *testing.T) *Harness {
 
 	h.cs = store.NewChainStore(h.bs, nil)
 
-	h.vm, err = vm.NewVM(stateroot, IAMethods.Exec, maddr, h.cs)
+	h.vm, err = vm.NewVM(stateroot, 1, maddr, h.cs)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -83,7 +83,7 @@ func (h *Harness) Execute() *state.StateTree {
 		} else {
 			h.NoError(h.t, err)
 		}
-		step.Ret(h.t, ret)
+		step.Ret(h.t, &ret.MessageReceipt)
 	}
 	stateroot, err := h.vm.Flush(context.TODO())
 	if err != nil {
@@ -141,7 +141,7 @@ func TestVMInvokeHarness(t *testing.T) {
 					t.Fatal(err)
 				}
 
-				if outaddr.String() != "t0102" {
+				if outaddr.String() != "t0103" {
 					t.Fatal("hold up")
 				}
 			},

chain/gen/mining.go

@@ -62,7 +62,7 @@ func MinerCreateBlock(ctx context.Context, cs *store.ChainStore, miner address.A
 			return nil, errors.Wrap(err, "apply message failure")
 		}
 
-		receipts = append(receipts, rec)
+		receipts = append(receipts, rec.MessageReceipt)
 	}
 
 	cst := hamt.CSTFromBstore(cs.Blockstore())

chain/sync.go

@@ -313,7 +313,7 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) err
 			return err
 		}
 
-		receipts = append(receipts, receipt)
+		receipts = append(receipts, receipt.MessageReceipt)
 	}
 
 	cst := hamt.CSTFromBstore(syncer.store.Blockstore())

chain/vm/invoker.go

@@ -27,6 +27,7 @@ func newInvoker() *invoker {
 	inv.register(actors.InitActorCodeCid, actors.InitActor{})
 	inv.register(actors.StorageMarketActorCodeCid, actors.StorageMarketActor{})
 	inv.register(actors.StorageMinerCodeCid, actors.StorageMinerActor{})
+	inv.register(actors.MultisigActorCodeCid, actors.MultiSigActor{})
 
 	return inv
 }

chain/vm/vm.go

@@ -112,21 +112,8 @@ func (vmc *VMContext) Send(to address.Address, method uint64, value types.BigInt
 		Params: params,
 	}
 
-	toAct, err := vmc.state.GetActor(to)
+	ret, err, _ := vmc.vm.send(ctx, vmc.origin, msg)
-	if err != nil {
+	return ret, err
-		return nil, aerrors.Absorb(err, 2, "could not find actor for Send")
-	}
-
-	nvmctx := vmc.vm.makeVMContext(ctx, toAct.Head, vmc.origin, msg)
-
-	res, aerr := vmc.vm.Invoke(toAct, nvmctx, method, params)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	toAct.Head = nvmctx.Storage().GetHead()
-
-	return res, nil
 }
 
 // BlockHeight returns the height of the block this message was added to the chain in
@@ -199,7 +186,46 @@ func NewVM(base cid.Cid, height uint64, maddr address.Address, cs *store.ChainSt
 	}, nil
 }
 
-func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*types.MessageReceipt, error) {
+type ApplyRet struct {
+	types.MessageReceipt
+	ActorErr aerrors.ActorError
+}
+
+func (vm *VM) send(ctx context.Context, origin address.Address, msg *types.Message) ([]byte, aerrors.ActorError, *VMContext) {
+	st := vm.cstate
+	fromActor, err := st.GetActor(msg.From)
+	if err != nil {
+		return nil, aerrors.Absorb(err, 1, "could not find source actor"), nil
+	}
+
+	toActor, err := st.GetActor(msg.To)
+	if err != nil {
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			a, err := TryCreateAccountActor(st, msg.To)
+			if err != nil {
+				return nil, aerrors.Absorb(err, 1, "could not create account"), nil
+			}
+			toActor = a
+		} else {
+			return nil, aerrors.Escalate(err, "getting actor"), nil
+		}
+	}
+
+	if err := DeductFunds(fromActor, msg.Value); err != nil {
+		return nil, aerrors.Absorb(err, 1, "failed to deduct funds"), nil
+	}
+	DepositFunds(toActor, msg.Value)
+	vmctx := vm.makeVMContext(ctx, toActor.Head, origin, msg)
+	if msg.Method != 0 {
+		ret, err := vm.Invoke(toActor, vmctx, msg.Method, msg.Params)
+		toActor.Head = vmctx.Storage().GetHead()
+		return ret, err, vmctx
+	}
+
+	return nil, nil, vmctx
+}
+
+func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*ApplyRet, error) {
 	ctx, span := trace.StartSpan(ctx, "vm.ApplyMessage")
 	defer span.End()
 
@@ -216,65 +242,30 @@ func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*types.Mess
 	gascost := types.BigMul(msg.GasLimit, msg.GasPrice)
 	totalCost := types.BigAdd(gascost, msg.Value)
 	if types.BigCmp(fromActor.Balance, totalCost) < 0 {
-		return nil, xerrors.Errorf("not enough funds")
+		return nil, xerrors.Errorf("not enough funds (%s < %s)", fromActor.Balance, totalCost)
+	}
+	if err := DeductFunds(fromActor, gascost); err != nil {
+		return nil, xerrors.Errorf("failed to deduct funds: %w", err)
 	}
 
 	if msg.Nonce != fromActor.Nonce {
 		return nil, xerrors.Errorf("invalid nonce (got %d, expected %d)", msg.Nonce, fromActor.Nonce)
 	}
 	fromActor.Nonce++
+	ret, actorErr, vmctx := vm.send(ctx, msg.From, msg)
 
-	toActor, err := st.GetActor(msg.To)
+	var errcode uint8
-	if err != nil {
+	if errcode = aerrors.RetCode(actorErr); errcode != 0 {
-		if xerrors.Is(err, types.ErrActorNotFound) {
+		// revert all state changes since snapshot
-			a, err := TryCreateAccountActor(st, msg.To)
+		if err := st.Revert(); err != nil {
-			if err != nil {
+			return nil, xerrors.Errorf("revert state failed: %w", err)
-				return nil, err
-			}
-			toActor = a
-		} else {
-			return nil, err
 		}
+	} else {
+		// refund unused gas
+		refund := types.BigMul(types.BigSub(msg.GasLimit, vmctx.GasUsed()), msg.GasPrice)
+		DepositFunds(fromActor, refund)
 	}
 
-	if err := DeductFunds(fromActor, totalCost); err != nil {
-		return nil, xerrors.Errorf("failed to deduct funds: %w", err)
-	}
-	DepositFunds(toActor, msg.Value)
-
-	vmctx := vm.makeVMContext(ctx, toActor.Head, msg.From, msg)
-
-	var errcode byte
-	var ret []byte
-	if msg.Method != 0 {
-		var err aerrors.ActorError
-		ret, err = vm.Invoke(toActor, vmctx, msg.Method, msg.Params)
-
-		if aerrors.IsFatal(err) {
-			return nil, xerrors.Errorf("during invoke: %w", err)
-		}
-
-		if errcode = aerrors.RetCode(err); errcode != 0 {
-			// revert all state changes since snapshot
-			if err := st.Revert(); err != nil {
-				return nil, xerrors.Errorf("revert state failed: %w", err)
-			}
-
-			gascost := types.BigMul(vmctx.GasUsed(), msg.GasPrice)
-			if err := DeductFunds(fromActor, gascost); err != nil {
-				panic("invariant violated: " + err.Error())
-			}
-
-		} else {
-			// Update actor head reference
-			toActor.Head = vmctx.storage.head
-			// refund unused gas
-			refund := types.BigMul(types.BigSub(msg.GasLimit, vmctx.GasUsed()), msg.GasPrice)
-			DepositFunds(fromActor, refund)
-		}
-	}
-
-	// reward miner gas fees
 	miner, err := st.GetActor(vm.blockMiner)
 	if err != nil {
 		return nil, xerrors.Errorf("getting block miner actor (%s) failed: %w", vm.blockMiner, err)
@@ -283,10 +274,13 @@ func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*types.Mess
 	gasReward := types.BigMul(msg.GasPrice, vmctx.GasUsed())
 	DepositFunds(miner, gasReward)
 
-	return &types.MessageReceipt{
+	return &ApplyRet{
-		ExitCode: errcode,
+		MessageReceipt: types.MessageReceipt{
-		Return:   ret,
+			ExitCode: errcode,
-		GasUsed:  vmctx.GasUsed(),
+			Return:   ret,
+			GasUsed:  vmctx.GasUsed(),
+		},
+		ActorErr: actorErr,
 	}, nil
 }
 

node/impl/full.go

@@ -111,7 +111,8 @@ func (a *FullNodeAPI) ChainCall(ctx context.Context, msg *types.Message, ts *typ
 	}
 
 	// TODO: maybe just use the invoker directly?
-	return vmi.ApplyMessage(ctx, msg)
+	ret, err := vmi.ApplyMessage(ctx, msg)
+	return &ret.MessageReceipt, err
 }
 
 func (a *FullNodeAPI) MpoolPending(ctx context.Context, ts *types.TipSet) ([]*types.SignedMessage, error) {