lotus/chain/vm/vm.go

751 lines
19 KiB
Go
Raw Normal View History

2019-07-26 04:54:22 +00:00
package vm
2019-07-05 14:29:17 +00:00
import (
"bytes"
2019-07-05 14:29:17 +00:00
"context"
"fmt"
2019-09-21 00:22:28 +00:00
"math/big"
2020-02-18 21:37:59 +00:00
"reflect"
2019-07-05 14:29:17 +00:00
block "github.com/ipfs/go-block-format"
2019-07-05 14:29:17 +00:00
cid "github.com/ipfs/go-cid"
hamt "github.com/ipfs/go-hamt-ipld"
2019-10-18 11:39:31 +00:00
blockstore "github.com/ipfs/go-ipfs-blockstore"
2020-02-04 22:19:05 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
logging "github.com/ipfs/go-log/v2"
2020-02-19 19:39:00 +00:00
mh "github.com/multiformats/go-multihash"
2019-10-17 08:57:56 +00:00
cbg "github.com/whyrusleeping/cbor-gen"
"go.opencensus.io/trace"
"golang.org/x/xerrors"
2019-10-17 08:57:56 +00:00
"github.com/filecoin-project/go-address"
2020-02-22 13:10:46 +00:00
commcid "github.com/filecoin-project/go-fil-commcid"
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/filecoin-project/specs-actors/actors/builtin/account"
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
"github.com/filecoin-project/specs-actors/actors/crypto"
"github.com/filecoin-project/specs-actors/actors/runtime"
2020-02-17 21:11:03 +00:00
2019-10-17 08:57:56 +00:00
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/actors/aerrors"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/lib/bufbstore"
"github.com/filecoin-project/lotus/lib/sigs"
2019-07-05 14:29:17 +00:00
)
var log = logging.Logger("vm")
const (
gasFundTransfer = 10
gasInvoke = 5
gasGetObj = 10
gasGetPerByte = 1
gasPutObj = 20
gasPutPerByte = 2
gasCommit = 50
gasPerMessageByte = 2
)
const (
outOfGasErrCode = 200
)
2019-07-05 14:29:17 +00:00
type VMContext struct {
ctx context.Context
vm *VM
state *state.StateTree
msg *types.Message
2020-02-08 02:18:32 +00:00
height abi.ChainEpoch
2020-02-04 22:19:05 +00:00
cst cbor.IpldStore
gasAvailable types.BigInt
gasUsed types.BigInt
sys runtime.Syscalls
// root cid of the state of the actor this invocation will be on
sroot cid.Cid
2019-10-22 08:14:10 +00:00
// address that started invoke chain
origin address.Address
2019-07-05 14:29:17 +00:00
}
// Message is the message that kicked off the current invocation
func (vmc *VMContext) Message() *types.Message {
2019-07-05 14:29:17 +00:00
return vmc.msg
}
2020-02-23 20:00:47 +00:00
func (vmc *VMContext) GetRandomness(personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, aerrors.ActorError) {
res, err := vmc.vm.rand.GetRandomness(vmc.ctx, personalization, int64(randEpoch), entropy)
if err != nil {
return nil, aerrors.Escalate(err, "could not get randomness")
}
return res, nil
}
func (vmc *VMContext) Sys() runtime.Syscalls {
return vmc.sys
}
// Storage interface
func (vmc *VMContext) Put(i cbg.CBORMarshaler) (cid.Cid, aerrors.ActorError) {
c, err := vmc.cst.Put(context.TODO(), i)
if err != nil {
2019-12-18 03:41:58 +00:00
return cid.Undef, aerrors.HandleExternalError(err, fmt.Sprintf("putting object %T", i))
}
return c, nil
}
func (vmc *VMContext) Get(c cid.Cid, out cbg.CBORUnmarshaler) aerrors.ActorError {
err := vmc.cst.Get(context.TODO(), c, out)
if err != nil {
2019-12-18 03:41:58 +00:00
return aerrors.HandleExternalError(err, "getting cid")
}
return nil
}
func (vmc *VMContext) GetHead() cid.Cid {
return vmc.sroot
}
func (vmc *VMContext) Commit(oldh, newh cid.Cid) aerrors.ActorError {
if err := vmc.ChargeGas(gasCommit); err != nil {
return aerrors.Wrap(err, "out of gas")
}
if vmc.sroot != oldh {
return aerrors.New(1, "failed to update, inconsistent base reference")
}
vmc.sroot = newh
return nil
}
// End of storage interface
2019-07-05 14:29:17 +00:00
// Storage provides access to the VM storage layer
func (vmc *VMContext) Storage() types.Storage {
return vmc
2019-07-05 14:29:17 +00:00
}
2020-02-04 22:19:05 +00:00
func (vmc *VMContext) Ipld() cbor.IpldStore {
2019-07-05 14:29:17 +00:00
return vmc.cst
}
func (vmc *VMContext) Origin() address.Address {
return vmc.origin
}
2019-07-05 14:29:17 +00:00
// Send allows the current execution context to invoke methods on other actors in the system
func (vmc *VMContext) Send(to address.Address, method abi.MethodNum, value types.BigInt, params []byte) ([]byte, aerrors.ActorError) {
ctx, span := trace.StartSpan(vmc.ctx, "vmc.Send")
defer span.End()
if span.IsRecordingEvents() {
span.AddAttributes(
trace.StringAttribute("to", to.String()),
trace.Int64Attribute("method", int64(method)),
trace.StringAttribute("value", value.String()),
)
}
msg := &types.Message{
From: vmc.msg.To,
To: to,
Method: method,
Value: value,
Params: params,
GasLimit: vmc.gasAvailable,
}
ret, err, _ := vmc.vm.send(ctx, msg, vmc, 0)
return ret, err
2019-07-05 14:29:17 +00:00
}
// BlockHeight returns the height of the block this message was added to the chain in
2020-02-08 02:18:32 +00:00
func (vmc *VMContext) BlockHeight() abi.ChainEpoch {
2019-07-05 14:29:17 +00:00
return vmc.height
}
func (vmc *VMContext) GasUsed() types.BigInt {
return vmc.gasUsed
}
func (vmc *VMContext) ChargeGas(amount uint64) aerrors.ActorError {
toUse := types.NewInt(amount)
vmc.gasUsed = types.BigAdd(vmc.gasUsed, toUse)
2019-09-23 17:11:44 +00:00
if vmc.gasUsed.GreaterThan(vmc.gasAvailable) {
return aerrors.Newf(outOfGasErrCode, "not enough gas: used=%s, available=%s", vmc.gasUsed, vmc.gasAvailable)
}
return nil
2019-07-05 14:29:17 +00:00
}
func (vmc *VMContext) StateTree() (types.StateTree, aerrors.ActorError) {
if vmc.msg.To != actors.InitAddress {
return nil, aerrors.Escalate(fmt.Errorf("only init actor can access state tree directly"), "invalid use of StateTree")
}
return vmc.state, nil
}
2020-02-17 21:11:03 +00:00
func (vmc *VMContext) ActorCodeCID(addr address.Address) (ret cid.Cid, err error) {
act, err := vmc.state.GetActor(addr)
if err != nil {
return cid.Undef, err
}
return act.Code, nil
}
2020-02-21 16:57:40 +00:00
func (vmc *VMContext) LookupID(a address.Address) (address.Address, error) {
return vmc.state.LookupID(a)
}
const GasVerifySignature = 50
2020-02-12 23:52:36 +00:00
func (vmctx *VMContext) VerifySignature(sig *crypto.Signature, act address.Address, data []byte) aerrors.ActorError {
if err := vmctx.ChargeGas(GasVerifySignature); err != nil {
return err
}
if act.Protocol() == address.ID {
2019-08-27 00:46:39 +00:00
kaddr, err := ResolveToKeyAddr(vmctx.state, vmctx.cst, act)
if err != nil {
return aerrors.Wrap(err, "failed to resolve address to key address")
}
act = kaddr
}
if err := sigs.Verify(sig, act, data); err != nil {
return aerrors.New(2, "signature verification failed")
}
return nil
}
2020-02-04 22:19:05 +00:00
func ResolveToKeyAddr(state types.StateTree, cst cbor.IpldStore, addr address.Address) (address.Address, aerrors.ActorError) {
if addr.Protocol() == address.BLS || addr.Protocol() == address.SECP256K1 {
return addr, nil
}
2019-08-27 00:46:39 +00:00
act, err := state.GetActor(addr)
if err != nil {
return address.Undef, aerrors.Newf(1, "failed to find actor: %s", addr)
}
if act.Code != actors.AccountCodeCid {
return address.Undef, aerrors.New(1, "address was not for an account actor")
}
2020-02-12 07:44:20 +00:00
var aast account.State
2019-08-27 00:46:39 +00:00
if err := cst.Get(context.TODO(), act.Head, &aast); err != nil {
return address.Undef, aerrors.Escalate(err, fmt.Sprintf("failed to get account actor state for %s", addr))
}
return aast.Address, nil
}
2019-09-12 04:12:35 +00:00
func (vmctx *VMContext) GetBalance(a address.Address) (types.BigInt, aerrors.ActorError) {
act, err := vmctx.state.GetActor(a)
switch err {
default:
return types.EmptyInt, aerrors.Escalate(err, "failed to look up actor balance")
case hamt.ErrNotFound:
return types.NewInt(0), nil
case nil:
return act.Balance, nil
}
}
2019-10-13 09:08:34 +00:00
func (vmctx *VMContext) Context() context.Context {
return vmctx.ctx
}
2020-02-04 22:19:05 +00:00
var _ cbor.IpldBlockstore = (*gasChargingBlocks)(nil)
type gasChargingBlocks struct {
chargeGas func(uint64) aerrors.ActorError
2020-02-04 22:19:05 +00:00
under cbor.IpldBlockstore
}
2020-02-04 22:19:05 +00:00
func (bs *gasChargingBlocks) Get(c cid.Cid) (block.Block, error) {
if err := bs.chargeGas(gasGetObj); err != nil {
return nil, err
}
2020-02-04 22:19:05 +00:00
blk, err := bs.under.Get(c)
if err != nil {
return nil, aerrors.Escalate(err, "failed to get block from blockstore")
}
if err := bs.chargeGas(uint64(len(blk.RawData())) * gasGetPerByte); err != nil {
return nil, err
}
return blk, nil
}
2020-02-04 22:19:05 +00:00
func (bs *gasChargingBlocks) Put(blk block.Block) error {
if err := bs.chargeGas(gasPutObj + uint64(len(blk.RawData()))*gasPutPerByte); err != nil {
return err
}
2020-02-04 22:19:05 +00:00
if err := bs.under.Put(blk); err != nil {
return aerrors.Escalate(err, "failed to write data to disk")
}
return nil
}
func (vm *VM) makeVMContext(ctx context.Context, sroot cid.Cid, msg *types.Message, origin address.Address, usedGas types.BigInt) *VMContext {
vmc := &VMContext{
ctx: ctx,
vm: vm,
state: vm.cstate,
sroot: sroot,
2019-07-05 14:29:17 +00:00
msg: msg,
origin: origin,
height: vm.blockHeight,
sys: vm.Syscalls,
gasUsed: usedGas,
gasAvailable: msg.GasLimit,
2019-07-05 14:29:17 +00:00
}
2020-02-04 22:19:05 +00:00
vmc.cst = &cbor.BasicIpldStore{
Blocks: &gasChargingBlocks{vmc.ChargeGas, vm.cst.Blocks},
Atlas: vm.cst.Atlas,
}
return vmc
2019-07-05 14:29:17 +00:00
}
type VM struct {
cstate *state.StateTree
2019-07-05 14:29:17 +00:00
base cid.Cid
2020-02-04 22:19:05 +00:00
cst *cbor.BasicIpldStore
buf *bufbstore.BufferedBS
2020-02-08 02:18:32 +00:00
blockHeight abi.ChainEpoch
2019-07-05 14:29:17 +00:00
blockMiner address.Address
inv *invoker
rand Rand
Syscalls runtime.Syscalls
2019-07-05 14:29:17 +00:00
}
func NewVM(base cid.Cid, height abi.ChainEpoch, r Rand, maddr address.Address, cbs blockstore.Blockstore, syscalls runtime.Syscalls) (*VM, error) {
2019-10-15 04:33:29 +00:00
buf := bufbstore.NewBufferedBstore(cbs)
2020-02-04 22:19:05 +00:00
cst := cbor.NewCborStore(buf)
state, err := state.LoadStateTree(cst, base)
2019-07-05 14:29:17 +00:00
if err != nil {
return nil, err
}
return &VM{
cstate: state,
base: base,
2019-07-26 04:54:22 +00:00
cst: cst,
2019-07-05 14:29:17 +00:00
buf: buf,
blockHeight: height,
blockMiner: maddr,
inv: NewInvoker(),
2020-01-13 20:47:27 +00:00
rand: r, // TODO: Probably should be a syscall
Syscalls: syscalls,
2019-07-05 14:29:17 +00:00
}, nil
}
type Rand interface {
2020-02-23 20:00:47 +00:00
GetRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round int64, entropy []byte) ([]byte, error)
}
type ApplyRet struct {
types.MessageReceipt
ActorErr aerrors.ActorError
}
func (vm *VM) send(ctx context.Context, msg *types.Message, parent *VMContext,
gasCharge uint64) ([]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 {
2020-02-22 13:10:46 +00:00
if xerrors.Is(err, init_.ErrAddressNotFound) {
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
}
}
gasUsed := types.NewInt(gasCharge)
origin := msg.From
if parent != nil {
gasUsed = types.BigAdd(parent.gasUsed, gasUsed)
origin = parent.origin
}
vmctx := vm.makeVMContext(ctx, toActor.Head, msg, origin, gasUsed)
if parent != nil {
defer func() {
parent.gasUsed = vmctx.gasUsed
}()
}
if types.BigCmp(msg.Value, types.NewInt(0)) != 0 {
if aerr := vmctx.ChargeGas(gasFundTransfer); aerr != nil {
return nil, aerrors.Wrap(aerr, "sending funds"), nil
}
if err := Transfer(fromActor, toActor, msg.Value); err != nil {
return nil, aerrors.Absorb(err, 1, "failed to transfer funds"), nil
}
}
if msg.Method != 0 {
ret, err := vm.Invoke(toActor, vmctx, msg.Method, msg.Params)
2019-10-22 12:37:04 +00:00
if !aerrors.IsFatal(err) {
toActor.Head = vmctx.Storage().GetHead()
}
return ret, err, vmctx
}
return nil, nil, vmctx
}
func checkMessage(msg *types.Message) error {
if msg.GasLimit == types.EmptyInt {
return xerrors.Errorf("message gas no gas limit set")
}
if msg.GasPrice == types.EmptyInt {
return xerrors.Errorf("message gas no gas price set")
}
if msg.Value == types.EmptyInt {
return xerrors.Errorf("message no value set")
}
return nil
}
func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*ApplyRet, error) {
ctx, span := trace.StartSpan(ctx, "vm.ApplyMessage")
defer span.End()
2019-10-10 11:13:26 +00:00
if span.IsRecordingEvents() {
span.AddAttributes(
trace.StringAttribute("to", msg.To.String()),
trace.Int64Attribute("method", int64(msg.Method)),
trace.StringAttribute("value", msg.Value.String()),
)
}
if err := checkMessage(msg); err != nil {
return nil, err
}
2019-07-05 14:29:17 +00:00
st := vm.cstate
if err := st.Snapshot(ctx); err != nil {
return nil, xerrors.Errorf("snapshot failed: %w", err)
}
2019-07-05 14:29:17 +00:00
fromActor, err := st.GetActor(msg.From)
if err != nil {
return nil, xerrors.Errorf("from actor not found: %w", err)
2019-07-05 14:29:17 +00:00
}
serMsg, err := msg.Serialize()
if err != nil {
return nil, xerrors.Errorf("could not serialize message: %w", err)
}
msgGasCost := uint64(len(serMsg)) * gasPerMessageByte
gascost := types.BigMul(msg.GasLimit, msg.GasPrice)
totalCost := types.BigAdd(gascost, msg.Value)
2019-09-23 17:11:44 +00:00
if fromActor.Balance.LessThan(totalCost) {
return nil, xerrors.Errorf("not enough funds (%s < %s)", fromActor.Balance, totalCost)
}
gasHolder := &types.Actor{Balance: types.NewInt(0)}
if err := Transfer(fromActor, gasHolder, gascost); err != nil {
return nil, xerrors.Errorf("failed to withdraw gas 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, nil, msgGasCost)
if aerrors.IsFatal(actorErr) {
return nil, xerrors.Errorf("[from=%s,to=%s,n=%d,m=%d,h=%d] fatal error: %w", msg.From, msg.To, msg.Nonce, msg.Method, vm.blockHeight, actorErr)
}
if actorErr != nil {
log.Warnw("Send actor error", "from", msg.From, "to", msg.To, "nonce", msg.Nonce, "method", msg.Method, "height", vm.blockHeight, "error", fmt.Sprintf("%+v", actorErr))
}
var errcode uint8
var gasUsed types.BigInt
if errcode = aerrors.RetCode(actorErr); errcode != 0 {
gasUsed = msg.GasLimit
// revert all state changes since snapshot
if err := st.Revert(); err != nil {
return nil, xerrors.Errorf("revert state failed: %w", err)
2019-07-05 14:29:17 +00:00
}
} else {
// refund unused gas
gasUsed = vmctx.GasUsed()
refund := types.BigMul(types.BigSub(msg.GasLimit, gasUsed), msg.GasPrice)
if err := Transfer(gasHolder, fromActor, refund); err != nil {
return nil, xerrors.Errorf("failed to refund gas")
}
}
miner, err := st.GetActor(vm.blockMiner)
if err != nil {
return nil, xerrors.Errorf("getting block miner actor (%s) failed: %w", vm.blockMiner, err)
}
2019-07-05 14:29:17 +00:00
2019-10-28 18:22:40 +00:00
// TODO: support multiple blocks in a tipset
// TODO: actually wire this up (miner is undef for now)
gasReward := types.BigMul(msg.GasPrice, gasUsed)
if err := Transfer(gasHolder, miner, gasReward); err != nil {
return nil, xerrors.Errorf("failed to give miner gas reward: %w", err)
}
if types.BigCmp(types.NewInt(0), gasHolder.Balance) != 0 {
return nil, xerrors.Errorf("gas handling math is wrong")
}
2019-07-05 14:29:17 +00:00
return &ApplyRet{
MessageReceipt: types.MessageReceipt{
ExitCode: errcode,
Return: ret,
GasUsed: gasUsed,
},
ActorErr: actorErr,
}, nil
2019-07-05 14:29:17 +00:00
}
func (vm *VM) SetBlockMiner(m address.Address) {
vm.blockMiner = m
}
func (vm *VM) ActorBalance(addr address.Address) (types.BigInt, aerrors.ActorError) {
act, err := vm.cstate.GetActor(addr)
if err != nil {
return types.EmptyInt, aerrors.Absorb(err, 1, "failed to find actor")
}
return act.Balance, nil
}
2019-07-05 14:29:17 +00:00
func (vm *VM) Flush(ctx context.Context) (cid.Cid, error) {
_, span := trace.StartSpan(ctx, "vm.Flush")
defer span.End()
from := vm.buf
to := vm.buf.Read()
2019-07-05 14:29:17 +00:00
root, err := vm.cstate.Flush(ctx)
2019-07-05 14:29:17 +00:00
if err != nil {
return cid.Undef, xerrors.Errorf("flushing vm: %w", err)
2019-07-05 14:29:17 +00:00
}
if err := Copy(from, to, root); err != nil {
return cid.Undef, xerrors.Errorf("copying tree: %w", err)
2019-07-05 14:29:17 +00:00
}
return root, nil
}
2020-02-18 21:37:59 +00:00
// vm.MutateState(idAddr, func(cst cbor.IpldStore, st *ActorStateType) error {...})
func (vm *VM) MutateState(ctx context.Context, addr address.Address, fn interface{}) error {
act, err := vm.cstate.GetActor(addr)
if err != nil {
return xerrors.Errorf("actor not found: %w", err)
}
st := reflect.New(reflect.TypeOf(fn).In(1).Elem())
if err := vm.cst.Get(ctx, act.Head, st.Interface()); err != nil {
return xerrors.Errorf("read actor head: %w", err)
}
out := reflect.ValueOf(fn).Call([]reflect.Value{reflect.ValueOf(vm.cst), st})
if !out[0].IsNil() && out[0].Interface().(error) != nil {
return out[0].Interface().(error)
}
head, err := vm.cst.Put(ctx, st.Interface())
if err != nil {
return xerrors.Errorf("put new actor head: %w", err)
}
act.Head = head
if err := vm.cstate.SetActor(addr, act); err != nil {
return xerrors.Errorf("set actor: %w", err)
}
return nil
}
func linksForObj(blk block.Block) ([]cid.Cid, error) {
switch blk.Cid().Prefix().Codec {
case cid.DagCBOR:
return cbg.ScanForLinks(bytes.NewReader(blk.RawData()))
default:
return nil, xerrors.Errorf("vm flush copy method only supports dag cbor")
}
}
func Copy(from, to blockstore.Blockstore, root cid.Cid) error {
2019-11-17 17:50:04 +00:00
var batch []block.Block
batchCp := func(blk block.Block) error {
batch = append(batch, blk)
if len(batch) > 100 {
if err := to.PutMany(batch); err != nil {
return xerrors.Errorf("batch put in copy: %w", err)
}
batch = batch[:0]
}
return nil
}
if err := copyRec(from, to, root, batchCp); err != nil {
return err
}
if len(batch) > 0 {
if err := to.PutMany(batch); err != nil {
return xerrors.Errorf("batch put in copy: %w", err)
}
}
return nil
}
func copyRec(from, to blockstore.Blockstore, root cid.Cid, cp func(block.Block) error) error {
if root.Prefix().MhType == 0 {
// identity cid, skip
return nil
}
blk, err := from.Get(root)
if err != nil {
return xerrors.Errorf("get %s failed: %w", root, err)
}
links, err := linksForObj(blk)
if err != nil {
return err
}
for _, link := range links {
2020-02-23 15:50:36 +00:00
if link.Prefix().MhType == mh.IDENTITY || link.Prefix().MhType == uint64(commcid.FC_SEALED_V1) || link.Prefix().MhType == uint64(commcid.FC_UNSEALED_V1) {
2019-07-25 22:15:33 +00:00
continue
}
has, err := to.Has(link)
if err != nil {
return err
}
if has {
continue
}
2019-11-17 17:50:04 +00:00
if err := copyRec(from, to, link, cp); err != nil {
return err
}
}
2019-11-17 17:50:04 +00:00
if err := cp(blk); err != nil {
return err
}
return nil
}
2019-08-15 02:30:21 +00:00
func (vm *VM) StateTree() types.StateTree {
return vm.cstate
}
2020-02-08 02:18:32 +00:00
func (vm *VM) SetBlockHeight(h abi.ChainEpoch) {
vm.blockHeight = h
}
func (vm *VM) Invoke(act *types.Actor, vmctx *VMContext, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
ctx, span := trace.StartSpan(vmctx.ctx, "vm.Invoke")
defer span.End()
2019-11-12 19:54:25 +00:00
if span.IsRecordingEvents() {
span.AddAttributes(
trace.StringAttribute("to", vmctx.Message().To.String()),
trace.Int64Attribute("method", int64(method)),
trace.StringAttribute("value", vmctx.Message().Value.String()),
)
}
2019-10-10 11:13:26 +00:00
var oldCtx context.Context
oldCtx, vmctx.ctx = vmctx.ctx, ctx
defer func() {
vmctx.ctx = oldCtx
}()
if err := vmctx.ChargeGas(gasInvoke); err != nil {
return nil, aerrors.Wrap(err, "invokeing")
}
ret, err := vm.inv.Invoke(act, vmctx, method, params)
if err != nil {
return nil, err
}
return ret, nil
}
2019-07-26 04:54:22 +00:00
func Transfer(from, to *types.Actor, amt types.BigInt) error {
2019-10-22 11:57:20 +00:00
if from == to {
return nil
}
if amt.LessThan(types.NewInt(0)) {
return xerrors.Errorf("attempted to transfer negative value")
}
if err := deductFunds(from, amt); err != nil {
return err
}
depositFunds(to, amt)
return nil
}
func (vm *VM) SetInvoker(i *invoker) {
vm.inv = i
}
func deductFunds(act *types.Actor, amt types.BigInt) error {
2019-09-23 17:11:44 +00:00
if act.Balance.LessThan(amt) {
2019-07-26 04:54:22 +00:00
return fmt.Errorf("not enough funds")
}
act.Balance = types.BigSub(act.Balance, amt)
return nil
}
func depositFunds(act *types.Actor, amt types.BigInt) {
2019-07-26 04:54:22 +00:00
act.Balance = types.BigAdd(act.Balance, amt)
}
2019-07-25 22:15:33 +00:00
var miningRewardTotal = types.FromFil(build.MiningRewardTotal)
2019-10-28 18:22:40 +00:00
var blocksPerEpoch = types.NewInt(build.BlocksPerEpoch)
// MiningReward returns correct mining reward
// coffer is amount of FIL in NetworkAddress
func MiningReward(remainingReward types.BigInt) types.BigInt {
ci := big.NewInt(0).Set(remainingReward.Int)
res := ci.Mul(ci, build.InitialReward)
res = res.Div(res, miningRewardTotal.Int)
2019-10-28 18:22:40 +00:00
res = res.Div(res, blocksPerEpoch.Int)
return types.BigInt{res}
2019-07-25 22:15:33 +00:00
}