lotus/chain/actors/actor_init.go

package actors

import (
	"bytes"
	"context"
	"encoding/binary"
	"fmt"

	"github.com/filecoin-project/go-lotus/chain/address"
	"github.com/filecoin-project/go-lotus/chain/types"

	"github.com/ipfs/go-cid"
	hamt "github.com/ipfs/go-hamt-ipld"
	cbor "github.com/ipfs/go-ipld-cbor"
	logging "github.com/ipfs/go-log"
	mh "github.com/multiformats/go-multihash"
	"github.com/pkg/errors"
)

var log = logging.Logger("actors")

var EmptyCBOR cid.Cid

func init() {
	cbor.RegisterCborType(ExecParams{})
	cbor.RegisterCborType(struct{}{})

	n, err := cbor.WrapObject(map[string]string{}, mh.SHA2_256, -1)
	if err != nil {
		panic(err)
	}

	EmptyCBOR = n.Cid()
}

type InitActor struct{}

type InitActorState struct {
	// TODO: this needs to be a HAMT, its a dumb map for now
	AddressMap cid.Cid

	NextID uint64
}

func (ia InitActor) Exports() []interface{} {
	return []interface{}{
		nil,
		ia.Exec,
	}
}

type ExecParams struct {
	Code   cid.Cid
	Params []byte
}

func (ep *ExecParams) UnmarshalCBOR(b []byte) (int, error) {
	if err := cbor.DecodeInto(b, ep); err != nil {
		return 0, err
	}

	return len(b), nil
}

func CreateExecParams(act cid.Cid, obj interface{}) ([]byte, error) {
	encparams, err := cbor.DumpObject(obj)
	if err != nil {
		return nil, err
	}

	var ep ExecParams
	ep.Code = act
	ep.Params = encparams

	return cbor.DumpObject(ep)
}

func (ia InitActor) Exec(act *types.Actor, vmctx types.VMContext, p *ExecParams) (types.InvokeRet, error) {
	beginState := vmctx.Storage().GetHead()

	var self InitActorState
	if err := vmctx.Storage().Get(beginState, &self); err != nil {
		return types.InvokeRet{}, err
	}

	// Make sure that only the actors defined in the spec can be launched.
	if !IsBuiltinActor(p.Code) {
		log.Error("cannot launch actor instance that is not a builtin actor")
		return types.InvokeRet{
			ReturnCode: 1,
		}, nil
	}

	// Ensure that singeltons can be only launched once.
	// TODO: do we want to enforce this? If so how should actors be marked as such?
	if IsSingletonActor(p.Code) {
		log.Error("cannot launch another actor of this type")
		return types.InvokeRet{
			ReturnCode: 1,
		}, nil
	}

	// This generates a unique address for this actor that is stable across message
	// reordering
	creator := vmctx.Message().From
	nonce := vmctx.Message().Nonce
	addr, err := ComputeActorAddress(creator, nonce)
	if err != nil {
		return types.InvokeRet{}, err
	}

	// Set up the actor itself
	actor := types.Actor{
		Code:    p.Code,
		Balance: vmctx.Message().Value,
		Head:    EmptyCBOR,
		Nonce:   0,
	}
	_, err = vmctx.Storage().Put(struct{}{})
	if err != nil {
		return types.InvokeRet{}, err
	}

	// The call to the actors constructor will set up the initial state
	// from the given parameters, setting `actor.Head` to a new value when successful.
	// TODO: can constructors fail?
	//actor.Constructor(p.Params)

	// Store the mapping of address to actor ID.
	idAddr, err := self.AddActor(vmctx, addr)
	if err != nil {
		return types.InvokeRet{}, errors.Wrap(err, "adding new actor mapping")
	}

	// NOTE: This is a privileged call that only the init actor is allowed to make
	// FIXME: Had to comment this  because state is not in interface
	state, err := vmctx.StateTree()
	if err != nil {
		return types.InvokeRet{}, err
	}

	if err := state.SetActor(idAddr, &actor); err != nil {
		return types.InvokeRet{}, errors.Wrap(err, "inserting new actor into state tree")
	}

	_, _, err = vmctx.Send(idAddr, 0, vmctx.Message().Value, p.Params)
	if err != nil {
		return types.InvokeRet{}, err
	}

	c, err := vmctx.Storage().Put(self)
	if err != nil {
		return types.InvokeRet{}, err
	}

	if err := vmctx.Storage().Commit(beginState, c); err != nil {
		return types.InvokeRet{}, err
	}

	return types.InvokeRet{
		Result: idAddr.Bytes(),
	}, nil
}

func IsBuiltinActor(code cid.Cid) bool {
	switch code {
	case StorageMinerCodeCid, StorageMinerCodeCid, AccountActorCodeCid, InitActorCodeCid, MultisigActorCodeCid:
		return true
	default:
		return false
	}
}

func IsSingletonActor(code cid.Cid) bool {
	return code == StorageMarketActorCodeCid || code == InitActorCodeCid
}

func (ias *InitActorState) AddActor(vmctx types.VMContext, addr address.Address) (address.Address, error) {
	nid := ias.NextID
	ias.NextID++

	amap, err := hamt.LoadNode(context.TODO(), vmctx.Ipld(), ias.AddressMap)
	if err != nil {
		return address.Undef, err
	}

	if err := amap.Set(context.TODO(), string(addr.Bytes()), nid); err != nil {
		return address.Undef, err
	}

	if err := amap.Flush(context.TODO()); err != nil {
		return address.Undef, err
	}

	ncid, err := vmctx.Ipld().Put(context.TODO(), amap)
	if err != nil {
		return address.Undef, err
	}
	ias.AddressMap = ncid

	return address.NewIDAddress(nid)
}

func (ias *InitActorState) Lookup(cst *hamt.CborIpldStore, addr address.Address) (address.Address, error) {
	amap, err := hamt.LoadNode(context.TODO(), cst, ias.AddressMap)
	if err != nil {
		return address.Undef, err
	}

	val, err := amap.Find(context.TODO(), string(addr.Bytes()))
	if err != nil {
		return address.Undef, err
	}

	ival, ok := val.(uint64)
	if !ok {
		return address.Undef, fmt.Errorf("invalid value in init actor state, expected uint64, got %T", val)
	}

	return address.NewIDAddress(ival)
}

type AccountActorState struct {
	Address address.Address
}

func ComputeActorAddress(creator address.Address, nonce uint64) (address.Address, error) {
	buf := new(bytes.Buffer)
	_, err := buf.Write(creator.Bytes())
	if err != nil {
		return address.Address{}, err
	}

	err = binary.Write(buf, binary.BigEndian, nonce)
	if err != nil {
		return address.Address{}, err
	}

	return address.NewActorAddress(buf.Bytes())
}