cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

actors: Remove addrass aliases

Browse Source
This commit is contained in:
Łukasz Magiera 2020-02-25 21:54:58 +01:00
parent cd10a3126b
commit ae634ef7df
30 changed files with 84 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
chain/actors/actors.go
View File

@ -1,22 +0,0 @@
package actors
import (
"github.com/filecoin-project/specs-actors/actors/builtin"
)
var AccountCodeCid = builtin.AccountActorCodeID
var CronCodeCid = builtin.CronActorCodeID
var StoragePowerCodeCid = builtin.StoragePowerActorCodeID
var StorageMarketCodeCid = builtin.StorageMarketActorCodeID
var StorageMinerCodeCid = builtin.StorageMinerActorCodeID
var MultisigCodeCid = builtin.MultisigActorCodeID
var InitCodeCid = builtin.InitActorCodeID
var PaymentChannelCodeCid = builtin.PaymentChannelActorCodeID
var SystemAddress = builtin.SystemActorAddr
var InitAddress = builtin.InitActorAddr
var RewardActor = builtin.RewardActorAddr
var CronAddress = builtin.CronActorAddr
var StoragePowerAddress = builtin.StoragePowerActorAddr
var StorageMarketAddress = builtin.StorageMarketActorAddr
var BurntFundsAddress = builtin.BurntFundsActorAddr

14
chain/actors/address.go
View File

@ -1,14 +0,0 @@
package actors
import (
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/lotus/chain/actors/aerrors"
)
func NewIDAddress(id uint64) (address.Address, ActorError) {
a, err := address.NewIDAddress(id)
if err != nil {
return address.Undef, aerrors.Escalate(err, "could not create ID Address")
}
return a, nil
}

5
chain/actors/error.go
View File

@ -1,5 +0,0 @@
package actors
import "github.com/filecoin-project/lotus/chain/actors/aerrors"
type ActorError = aerrors.ActorError

50
chain/actors/forks.go
View File

@ -1,50 +0,0 @@
package actors
import (
"reflect"
"sort"
logging "github.com/ipfs/go-log/v2"
"github.com/filecoin-project/lotus/chain/actors/aerrors"
"github.com/filecoin-project/lotus/chain/types"
)
var log = logging.Logger("actors")
type update struct {
start uint64
method interface{}
}
func withUpdates(updates ...update) interface{} {
sort.Slice(updates, func(i, j int) bool { // so we iterate from newest below
return updates[i].start > updates[j].start
})
// <script type="application/javascript">
typ := reflect.TypeOf(updates[0].method)
out := reflect.MakeFunc(typ, func(args []reflect.Value) (results []reflect.Value) {
vmctx := args[1].Interface().(types.VMContext)
for _, u := range updates {
if uint64(vmctx.BlockHeight()) > u.start {
return reflect.ValueOf(u.method).Call(args)
}
}
return reflect.ValueOf(notFound(vmctx)).Call([]reflect.Value{})
})
return out.Interface()
// </script>
}
func notFound(vmctx types.VMContext) func() ([]byte, ActorError) {
return func() ([]byte, ActorError) {
return nil, aerrors.Fatal("no code for method %d at height %d", vmctx.Message().Method, vmctx.BlockHeight())
}
}

4
chain/actors/params.go
View File

@ -7,10 +7,6 @@ import (
cbg "github.com/whyrusleeping/cbor-gen"
)
var (
EmptyStructCBOR = []byte{0xa0}
)
func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
buf := new(bytes.Buffer)
if err := i.MarshalCBOR(buf); err != nil {

21
chain/gen/genesis/genesis.go
View File

@ -20,7 +20,6 @@ import (
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/lotus/build"
actors "github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
@ -116,7 +115,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil {
return nil, xerrors.Errorf("setup init actor: %w", err)
}
if err := state.SetActor(actors.SystemAddress, sysact); err != nil {
if err := state.SetActor(builtin.SystemActorAddr, sysact); err != nil {
return nil, xerrors.Errorf("set init actor: %w", err)
}
@ -126,12 +125,12 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil {
return nil, xerrors.Errorf("setup init actor: %w", err)
}
if err := state.SetActor(actors.InitAddress, initact); err != nil {
if err := state.SetActor(builtin.InitActorAddr, initact); err != nil {
return nil, xerrors.Errorf("set init actor: %w", err)
}
// Setup reward
err = state.SetActor(actors.RewardActor, &types.Actor{
err = state.SetActor(builtin.RewardActorAddr, &types.Actor{
Code: builtin.RewardActorCodeID,
Balance: big.Int{Int: build.InitialReward},
Head: emptyobject, // TODO ?
@ -145,7 +144,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil {
return nil, xerrors.Errorf("setup cron actor: %w", err)
}
if err := state.SetActor(actors.CronAddress, cronact); err != nil {
if err := state.SetActor(builtin.CronActorAddr, cronact); err != nil {
return nil, xerrors.Errorf("set cron actor: %w", err)
}
@ -154,7 +153,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil {
return nil, xerrors.Errorf("setup storage market actor: %w", err)
}
if err := state.SetActor(actors.StoragePowerAddress, spact); err != nil {
if err := state.SetActor(builtin.StoragePowerActorAddr, spact); err != nil {
return nil, xerrors.Errorf("set storage market actor: %w", err)
}
@ -163,13 +162,13 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil {
return nil, xerrors.Errorf("setup storage market actor: %w", err)
}
if err := state.SetActor(actors.StorageMarketAddress, marketact); err != nil {
if err := state.SetActor(builtin.StorageMarketActorAddr, marketact); err != nil {
return nil, xerrors.Errorf("set market actor: %w", err)
}
// Setup burnt-funds
err = state.SetActor(actors.BurntFundsAddress, &types.Actor{
Code: actors.AccountCodeCid,
err = state.SetActor(builtin.BurntFundsActorAddr, &types.Actor{
Code: builtin.AccountActorCodeID,
Balance: types.NewInt(0),
Head: emptyobject,
})
@ -199,7 +198,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
}
err = state.SetActor(ida, &types.Actor{
Code: actors.AccountCodeCid,
Code: builtin.AccountActorCodeID,
Balance: info.Balance,
Head: st,
})
@ -255,7 +254,7 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys runtime.Sys
}
b := &types.BlockHeader{
Miner: actors.InitAddress,
Miner: builtin.InitActorAddr,
Ticket: genesisticket,
EPostProof: types.EPostProof{
Proof: []byte("not a real proof"),

9
chain/gen/genesis/miners.go
View File

@ -21,7 +21,6 @@ import (
"github.com/ipfs/go-cid"
"golang.org/x/xerrors"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/vm"
@ -43,7 +42,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
networkPower = big.Add(networkPower, big.NewInt(int64(m.SectorSize)*int64(len(m.Sectors))))
}
vm, err := vm.NewVM(sroot, 0, &fakeRand{}, actors.SystemAddress, cs.Blockstore(), cs.VMSys())
vm, err := vm.NewVM(sroot, 0, &fakeRand{}, builtin.SystemActorAddr, cs.Blockstore(), cs.VMSys())
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
}
@ -69,7 +68,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
}
params := mustEnc(constructorParams)
rval, err := doExecValue(ctx, vm, actors.StoragePowerAddress, m.Owner, m.PowerBalance, builtin.MethodsPower.CreateMiner, params)
rval, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, m.Owner, m.PowerBalance, builtin.MethodsPower.CreateMiner, params)
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
}
@ -90,14 +89,14 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
{
params := mustEnc(&maddr)
_, err := doExecValue(ctx, vm, actors.StorageMarketAddress, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
}
}
{
params := mustEnc(&m.Worker)
_, err := doExecValue(ctx, vm, actors.StorageMarketAddress, m.Worker, big.Zero(), builtin.MethodsMarket.AddBalance, params)
_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.AddBalance, params)
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
}

4
chain/gen/genesis/t01_init.go
View File

@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
"github.com/filecoin-project/specs-actors/actors/builtin"
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
"github.com/ipfs/go-hamt-ipld"
@ -11,7 +12,6 @@ import (
cbor "github.com/ipfs/go-ipld-cbor"
"golang.org/x/xerrors"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/genesis"
)
@ -61,7 +61,7 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
}
act := &types.Actor{
Code: actors.InitCodeCid,
Code: builtin.InitActorCodeID,
Head: statecid,
}

3
chain/gen/genesis/t03_cron.go
View File

@ -8,7 +8,6 @@ import (
bstore "github.com/ipfs/go-ipfs-blockstore"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types"
)
@ -26,7 +25,7 @@ func SetupCronActor(bs bstore.Blockstore) (*types.Actor, error) {
}
return &types.Actor{
Code: actors.CronCodeCid,
Code: builtin.CronActorCodeID,
Head: stcid,
Nonce: 0,
Balance: types.NewInt(0),

4
chain/gen/genesis/t04_power.go
View File

@ -2,6 +2,7 @@ package genesis
import (
"context"
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/abi/big"
"github.com/filecoin-project/specs-actors/actors/builtin/power"
@ -9,7 +10,6 @@ import (
bstore "github.com/ipfs/go-ipfs-blockstore"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types"
)
@ -38,7 +38,7 @@ func SetupStoragePowerActor(bs bstore.Blockstore) (*types.Actor, error) {
}
return &types.Actor{
Code: actors.StoragePowerCodeCid,
Code: builtin.StoragePowerActorCodeID,
Head: stcid,
Nonce: 0,
Balance: types.NewInt(0),

6
chain/gen/genesis/t05_market.go
View File

@ -2,14 +2,14 @@ package genesis
import (
"context"
"github.com/filecoin-project/go-amt-ipld/v2"
"github.com/ipfs/go-hamt-ipld"
"github.com/filecoin-project/go-amt-ipld/v2"
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/builtin/market"
bstore "github.com/ipfs/go-ipfs-blockstore"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types"
)
@ -33,7 +33,7 @@ func SetupStorageMarketActor(bs bstore.Blockstore) (*types.Actor, error) {
}
act := &types.Actor{
Code: actors.StorageMarketCodeCid,
Code: builtin.StorageMarketActorCodeID,
Head: stcid,
Balance: types.NewInt(0),
}

2
chain/market/fundmgr.go
View File

@ -63,7 +63,7 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr address.Address, am
}
smsg, err := fm.mpool.MpoolPushMessage(ctx, &types.Message{
To: actors.StorageMarketAddress,
To: builtin.StorageMarketActorAddr,
From: addr,
Value: toAdd,
GasPrice: types.NewInt(0),

6
chain/state/statetree.go
View File

@ -3,6 +3,7 @@ package state
import (
"context"
"fmt"
"github.com/filecoin-project/specs-actors/actors/builtin"
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
"github.com/filecoin-project/specs-actors/actors/util/adt"
@ -14,7 +15,6 @@ import (
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types"
)
@ -74,7 +74,7 @@ func (st *StateTree) LookupID(addr address.Address) (address.Address, error) {
return addr, nil
}
act, err := st.GetActor(actors.InitAddress)
act, err := st.GetActor(builtin.InitActorAddr)
if err != nil {
return address.Undef, xerrors.Errorf("getting init actor: %w", err)
}
@ -157,7 +157,7 @@ func (st *StateTree) Snapshot(ctx context.Context) error {
func (st *StateTree) RegisterNewAddress(addr address.Address, act *types.Actor) (address.Address, error) {
var out address.Address
err := st.MutateActor(actors.InitAddress, func(initact *types.Actor) error {
err := st.MutateActor(builtin.InitActorAddr, func(initact *types.Actor) error {
var ias init_.State
if err := st.Store.Get(context.TODO(), initact.Head, &ias); err != nil {
return err

4
chain/stmgr/call.go
View File

@ -3,6 +3,7 @@ package stmgr
import (
"context"
"fmt"
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/ipfs/go-cid"
@ -10,7 +11,6 @@ import (
"golang.org/x/xerrors"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/vm"
@ -20,7 +20,7 @@ func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate
ctx, span := trace.StartSpan(ctx, "statemanager.CallRaw")
defer span.End()
vmi, err := vm.NewVM(bstate, bheight, r, actors.SystemAddress, sm.cs.Blockstore(), sm.cs.VMSys())
vmi, err := vm.NewVM(bstate, bheight, r, builtin.SystemActorAddr, sm.cs.Blockstore(), sm.cs.VMSys())
if err != nil {
return nil, xerrors.Errorf("failed to set up vm: %w", err)
}

13
chain/stmgr/stmgr.go
View File

@ -8,7 +8,6 @@ import (
"github.com/filecoin-project/go-address"
amt "github.com/filecoin-project/go-amt-ipld/v2"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
@ -155,13 +154,13 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, blks []*types.Bl
return cid.Undef, cid.Undef, xerrors.Errorf("instantiating VM failed: %w", err)
}
rewardActor, err := vmi.StateTree().GetActor(actors.RewardActor)
rewardActor, err := vmi.StateTree().GetActor(builtin.RewardActorAddr)
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("failed to get network actor: %w", err)
}
reward := vm.MiningReward(rewardActor.Balance)
for _, b := range blks {
rewardActor, err = vmi.StateTree().GetActor(actors.RewardActor)
rewardActor, err = vmi.StateTree().GetActor(builtin.RewardActorAddr)
if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("failed to get network actor: %w", err)
}
@ -248,14 +247,14 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, blks []*types.Bl
}
// TODO: this nonce-getting is a tiny bit ugly
ca, err := vmi.StateTree().GetActor(actors.SystemAddress)
ca, err := vmi.StateTree().GetActor(builtin.SystemActorAddr)
if err != nil {
return cid.Undef, cid.Undef, err
}
ret, err := vmi.ApplyMessage(ctx, &types.Message{
To: actors.CronAddress,
From: actors.SystemAddress,
To: builtin.CronActorAddr,
From: builtin.SystemActorAddr,
Nonce: ca.Nonce,
Value: types.NewInt(0),
GasPrice: types.NewInt(0),
@ -629,7 +628,7 @@ func (sm *StateManager) ListAllActors(ctx context.Context, ts *types.TipSet) ([]
func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address, ts *types.TipSet) (api.MarketBalance, error) {
var state market.State
_, err := sm.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts)
_, err := sm.LoadActorState(ctx, builtin.StorageMarketActorAddr, &state, ts)
if err != nil {
return api.MarketBalance{}, err
}

7
chain/stmgr/utils.go
View File

@ -23,7 +23,6 @@ import (
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/vm"
@ -222,7 +221,7 @@ func GetMinerFaults(ctx context.Context, sm *StateManager, ts *types.TipSet, mad
func GetStorageDeal(ctx context.Context, sm *StateManager, dealId abi.DealID, ts *types.TipSet) (*api.MarketDeal, error) {
var state market.State
if _, err := sm.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
if _, err := sm.LoadActorState(ctx, builtin.StorageMarketActorAddr, &state, ts); err != nil {
return nil, err
}
@ -250,7 +249,7 @@ func GetStorageDeal(ctx context.Context, sm *StateManager, dealId abi.DealID, ts
func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([]address.Address, error) {
var state power.State
if _, err := sm.LoadActorState(ctx, actors.StoragePowerAddress, &state, ts); err != nil {
if _, err := sm.LoadActorState(ctx, builtin.StoragePowerActorAddr, &state, ts); err != nil {
return nil, err
}
@ -310,7 +309,7 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
}
r := store.NewChainRand(sm.cs, ts.Cids(), height)
vmi, err := vm.NewVM(fstate, height, r, actors.SystemAddress, sm.cs.Blockstore(), sm.cs.VMSys())
vmi, err := vm.NewVM(fstate, height, r, builtin.SystemActorAddr, sm.cs.Blockstore(), sm.cs.VMSys())
if err != nil {
return cid.Undef, err
}

3
chain/store/weight.go
View File

@ -5,7 +5,6 @@ import (
"math/big"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/vm"
@ -73,7 +72,7 @@ func (cs *ChainStore) call(ctx context.Context, msg *types.Message, ts *types.Ti
r := NewChainRand(cs, ts.Cids(), ts.Height())
vmi, err := vm.NewVM(bstate, ts.Height(), r, actors.SystemAddress, cs.bs, cs.vmcalls)
vmi, err := vm.NewVM(bstate, ts.Height(), r, builtin.SystemActorAddr, cs.bs, cs.vmcalls)
if err != nil {
return nil, xerrors.Errorf("failed to set up vm: %w", err)
}

4
chain/sync.go
View File

@ -5,6 +5,7 @@ import (
"crypto/sha256"
"errors"
"fmt"
"github.com/filecoin-project/specs-actors/actors/builtin"
"sync"
"time"
@ -33,7 +34,6 @@ import (
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/blocksync"
"github.com/filecoin-project/lotus/chain/gen"
"github.com/filecoin-project/lotus/chain/state"
@ -469,7 +469,7 @@ func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet)
func (syncer *Syncer) minerIsValid(ctx context.Context, maddr address.Address, baseTs *types.TipSet) error {
var spast power.State
_, err := syncer.sm.LoadActorState(ctx, actors.StoragePowerAddress, &spast, baseTs)
_, err := syncer.sm.LoadActorState(ctx, builtin.StoragePowerActorAddr, &spast, baseTs)
if err != nil {
return err
}

19
chain/vm/invoker.go
View File

@ -24,7 +24,6 @@ import (
vmr "github.com/filecoin-project/specs-actors/actors/runtime"
"github.com/filecoin-project/specs-actors/actors/util/adt"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/actors/aerrors"
"github.com/filecoin-project/lotus/chain/types"
)
@ -45,20 +44,20 @@ func NewInvoker() *invoker {
// add builtInCode using: register(cid, singleton)
inv.Register(builtin.SystemActorCodeID, system.Actor{}, adt.EmptyValue{})
inv.Register(actors.InitCodeCid, init_.Actor{}, init_.State{})
inv.Register(actors.CronCodeCid, cron.Actor{}, cron.State{})
inv.Register(actors.StoragePowerCodeCid, power.Actor{}, power.State{})
inv.Register(actors.StorageMarketCodeCid, market.Actor{}, market.State{})
inv.Register(actors.StorageMinerCodeCid, miner.Actor{}, miner.State{})
inv.Register(actors.MultisigCodeCid, multisig.Actor{}, multisig.State{})
inv.Register(actors.PaymentChannelCodeCid, paych.Actor{}, paych.State{})
inv.Register(builtin.InitActorCodeID, init_.Actor{}, init_.State{})
inv.Register(builtin.CronActorCodeID, cron.Actor{}, cron.State{})
inv.Register(builtin.StoragePowerActorCodeID, power.Actor{}, power.State{})
inv.Register(builtin.StorageMarketActorCodeID, market.Actor{}, market.State{})
inv.Register(builtin.StorageMinerActorCodeID, miner.Actor{}, miner.State{})
inv.Register(builtin.MultisigActorCodeID, multisig.Actor{}, multisig.State{})
inv.Register(builtin.PaymentChannelActorCodeID, paych.Actor{}, paych.State{})
return inv
}
func (inv *invoker) Invoke(act *types.Actor, vmctx types.VMContext, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
if act.Code == actors.AccountCodeCid {
if act.Code == builtin.AccountActorCodeID {
return nil, aerrors.Newf(254, "cannot invoke methods on account actors")
}
@ -264,7 +263,7 @@ func DecodeParams(b []byte, out interface{}) error {
}
func DumpActorState(code cid.Cid, b []byte) (interface{}, error) {
if code == actors.AccountCodeCid { // Account code special case
if code == builtin.AccountActorCodeID { // Account code special case
return nil, nil
}

6
chain/vm/mkactor.go
View File

@ -2,13 +2,13 @@ package vm
import (
"context"
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/builtin/account"
"github.com/ipfs/go-cid"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/go-address"
"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"
@ -64,7 +64,7 @@ func NewBLSAccountActor(st *state.StateTree, addr address.Address) (*types.Actor
}
nact := &types.Actor{
Code: actors.AccountCodeCid,
Code: builtin.AccountActorCodeID,
Balance: types.NewInt(0),
Head: c,
}
@ -74,7 +74,7 @@ func NewBLSAccountActor(st *state.StateTree, addr address.Address) (*types.Actor
func NewSecp256k1AccountActor(st *state.StateTree, addr address.Address) (*types.Actor, aerrors.ActorError) {
nact := &types.Actor{
Code: actors.AccountCodeCid,
Code: builtin.AccountActorCodeID,
Balance: types.NewInt(0),
Head: EmptyObjectCid,
}

6
chain/vm/vm.go
View File

@ -4,6 +4,7 @@ import (
"bytes"
"context"
"fmt"
"github.com/filecoin-project/specs-actors/actors/builtin"
"math/big"
"reflect"
@ -27,7 +28,6 @@ import (
"github.com/filecoin-project/specs-actors/actors/runtime"
"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"
@ -184,7 +184,7 @@ func (vmc *VMContext) ChargeGas(amount uint64) aerrors.ActorError {
}
func (vmc *VMContext) StateTree() (types.StateTree, aerrors.ActorError) {
if vmc.msg.To != actors.InitAddress {
if vmc.msg.To != builtin.InitActorAddr {
return nil, aerrors.Escalate(fmt.Errorf("only init actor can access state tree directly"), "invalid use of StateTree")
}
@ -235,7 +235,7 @@ func ResolveToKeyAddr(state types.StateTree, cst cbor.IpldStore, addr address.Ad
return address.Undef, aerrors.Newf(1, "failed to find actor: %s", addr)
}
if act.Code != actors.AccountCodeCid {
if act.Code != builtin.AccountActorCodeID {
return address.Undef, aerrors.New(1, "address was not for an account actor")
}

2
cli/chain.go
View File

@ -618,7 +618,7 @@ var slashConsensusFault = &cli.Command{
})
msg := &types.Message{
To: actors.StoragePowerAddress,
To: builtin.StoragePowerActorAddr,
From: def,
Value: types.NewInt(0),
GasPrice: types.NewInt(1),

4
cli/multisig.go
View File

@ -106,7 +106,7 @@ var msigCreateCmd = &cli.Command{
// new actors are created by invoking 'exec' on the init actor with the constructor params
execParams := &init_.ExecParams{
CodeCID: actors.MultisigCodeCid,
CodeCID: builtin.MultisigActorCodeID,
ConstructorParams: enc,
}
@ -117,7 +117,7 @@ var msigCreateCmd = &cli.Command{
// now we create the message to send this with
msg := types.Message{
To: actors.InitAddress,
To: builtin.InitActorAddr,
From: sendAddr,
Method: builtin.MethodsInit.Exec,
Params: enc,

14
cli/state.go
View File

@ -5,6 +5,7 @@ import (
"context"
"encoding/json"
"fmt"
"github.com/filecoin-project/specs-actors/actors/builtin"
"reflect"
"strconv"
"strings"
@ -20,7 +21,6 @@ import (
"golang.org/x/xerrors"
"github.com/filecoin-project/lotus/api"
actors "github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/miner"
@ -832,7 +832,7 @@ var stateCallCmd = &cli.Command{
&cli.StringFlag{
Name: "from",
Usage: "",
Value: actors.SystemAddress.String(),
Value: builtin.SystemActorAddr.String(),
},
&cli.StringFlag{
Name: "value",
@ -973,15 +973,15 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
var f interface{}
switch act {
case actors.StorageMarketCodeCid:
case builtin.StorageMarketActorCodeID:
f = market.Actor{}.Exports()[method]
case actors.StorageMinerCodeCid:
case builtin.StorageMinerActorCodeID:
f = miner2.Actor{}.Exports()[method]
case actors.StoragePowerCodeCid:
case builtin.StoragePowerActorCodeID:
f = power.Actor{}.Exports()[method]
case actors.MultisigCodeCid:
case builtin.MultisigActorCodeID:
f = samsig.Actor{}.Exports()[method]
case actors.PaymentChannelCodeCid:
case builtin.PaymentChannelActorCodeID:
f = paych.Actor{}.Exports()[method]
default:
return nil, fmt.Errorf("the lazy devs didnt add support for that actor to this call yet")

2
cmd/lotus-storage-miner/init.go
View File

@ -550,7 +550,7 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
}
createStorageMinerMsg := &types.Message{
To: actors.StoragePowerAddress,
To: builtin.StoragePowerActorAddr,
From: owner,
Value: types.BigAdd(collateral, types.BigDiv(collateral, types.NewInt(100))),

5
markets/storageadapter/client.go
View File

@ -18,7 +18,6 @@ import (
"github.com/filecoin-project/go-fil-markets/storagemarket"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/events"
"github.com/filecoin-project/lotus/chain/market"
"github.com/filecoin-project/lotus/chain/stmgr"
@ -123,7 +122,7 @@ func (n *ClientNodeAdapter) MostRecentStateId(ctx context.Context) (storagemarke
func (n *ClientNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) error {
// (Provider Node API)
smsg, err := n.MpoolPushMessage(ctx, &types.Message{
To: actors.StorageMarketAddress,
To: builtin.StorageMarketActorAddr,
From: addr,
Value: amount,
GasPrice: types.NewInt(0),
@ -178,7 +177,7 @@ func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal stor
return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider)
}
if pubmsg.To != actors.StorageMarketAddress {
if pubmsg.To != builtin.StorageMarketActorAddr {
return 0, xerrors.Errorf("deal publish message wasn't set to StorageMarket actor (to=%s)", pubmsg.To)
}

4
markets/storageadapter/provider.go
View File

@ -68,7 +68,7 @@ func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemark
// TODO: We may want this to happen after fetching data
smsg, err := n.MpoolPushMessage(ctx, &types.Message{
To: actors.StorageMarketAddress,
To: builtin.StorageMarketActorAddr,
From: worker,
Value: types.NewInt(0),
GasPrice: types.NewInt(0),
@ -156,7 +156,7 @@ func (n *ProviderNodeAdapter) MostRecentStateId(ctx context.Context) (storagemar
func (n *ProviderNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) error {
// (Provider Node API)
smsg, err := n.MpoolPushMessage(ctx, &types.Message{
To: actors.StorageMarketAddress,
To: builtin.StorageMarketActorAddr,
From: addr,
Value: amount,
GasPrice: types.NewInt(0),

22
node/impl/full/state.go
View File

@ -4,27 +4,27 @@ import (
"bytes"
"context"
"fmt"
"github.com/prometheus/common/log"
"strconv"
"github.com/filecoin-project/go-amt-ipld/v2"
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/filecoin-project/specs-actors/actors/abi/big"
"github.com/filecoin-project/specs-actors/actors/builtin/market"
"github.com/filecoin-project/specs-actors/actors/builtin/miner"
samsig "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
cid "github.com/ipfs/go-cid"
"github.com/ipfs/go-hamt-ipld"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/libp2p/go-libp2p-core/peer"
"github.com/prometheus/common/log"
cbg "github.com/whyrusleeping/cbor-gen"
"go.uber.org/fx"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-amt-ipld/v2"
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/filecoin-project/specs-actors/actors/abi/big"
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/builtin/market"
"github.com/filecoin-project/specs-actors/actors/builtin/miner"
samsig "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/gen"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/stmgr"
@ -333,7 +333,7 @@ func (a *StateAPI) StateMarketParticipants(ctx context.Context, tsk types.TipSet
if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
}
if _, err := a.StateManager.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
if _, err := a.StateManager.LoadActorState(ctx, builtin.StorageMarketActorAddr, &state, ts); err != nil {
return nil, err
}
cst := cbor.NewCborStore(a.StateManager.ChainStore().Blockstore())
@ -382,7 +382,7 @@ func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (m
if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
}
if _, err := a.StateManager.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
if _, err := a.StateManager.LoadActorState(ctx, builtin.StorageMarketActorAddr, &state, ts); err != nil {
return nil, err
}
@ -558,7 +558,7 @@ func (a *StateAPI) MsigGetAvailableBalance(ctx context.Context, addr address.Add
return types.EmptyInt, xerrors.Errorf("failed to load multisig actor state: %w", err)
}
if act.Code != actors.MultisigCodeCid {
if act.Code != builtin.MultisigActorCodeID {
return types.EmptyInt, fmt.Errorf("given actor was not a multisig")
}

4
paychmgr/simple.go
View File

@ -23,7 +23,7 @@ func (pm *Manager) createPaych(ctx context.Context, from, to address.Address, am
}
enc, aerr := actors.SerializeParams(&init_.ExecParams{
CodeCID: actors.PaymentChannelCodeCid,
CodeCID: builtin.PaymentChannelActorCodeID,
ConstructorParams: params,
})
if aerr != nil {
@ -31,7 +31,7 @@ func (pm *Manager) createPaych(ctx context.Context, from, to address.Address, am
}
msg := &types.Message{
To: actors.InitAddress,
To: builtin.InitActorAddr,
From: from,
Value: amt,
Method: builtin.MethodsInit.Exec,

2
storage/sealing/checks.go
View File

@ -98,7 +98,7 @@ func checkSeal(ctx context.Context, maddr address.Address, si SectorInfo, api se
}
ccmt := &types.Message{
To: actors.StorageMarketAddress,
To: builtin.StorageMarketActorAddr,
From: maddr,
Value: types.NewInt(0),
GasPrice: types.NewInt(0),