cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity
e13dea7da8
lotus/chain/actors/builtin/init/init.go

134 lines
3.5 KiB
Go
Raw Normal View History

[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
package init
import (
Allow starting networks from arbitrary actor versions
2021-05-15 01:11:23 +00:00
"github.com/filecoin-project/lotus/chain/actors"
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
"golang.org/x/xerrors"
Fix some build errors
2020-09-14 11:14:06 +00:00
"github.com/filecoin-project/go-address"
finish upgrading chainwatch
2020-09-18 20:43:14 +00:00
"github.com/filecoin-project/go-state-types/abi"
Fix some build errors
2020-09-14 11:14:06 +00:00
"github.com/filecoin-project/go-state-types/cbor"
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
"github.com/ipfs/go-cid"
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
"github.com/filecoin-project/lotus/chain/actors/adt"
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
"github.com/filecoin-project/lotus/chain/actors/builtin"
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
"github.com/filecoin-project/lotus/chain/types"
Progress
2020-09-14 22:43:12 +00:00
"github.com/filecoin-project/lotus/node/modules/dtypes"
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
rename actors v1 -> actors v2 The actual actors version is v2, not v1. Using Version1 internally was really confusing.
2020-09-28 20:13:18 +00:00
builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
Add v3 actors support for init
2021-01-16 04:21:33 +00:00
builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
v4 specs-actors integration, nv12 migration
2021-04-23 12:29:46 +00:00
builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
)
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
func init() {
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
builtin.RegisterActorState(builtin0.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
return load0(store, root)
})
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
rename actors v1 -> actors v2 The actual actors version is v2, not v1. Using Version1 internally was really confusing.
2020-09-28 20:13:18 +00:00
builtin.RegisterActorState(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
return load2(store, root)
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
})
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
register remaining state decoders
2021-01-18 23:01:44 +00:00
builtin.RegisterActorState(builtin3.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
return load3(store, root)
})
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
v4 specs-actors integration, nv12 migration
2021-04-23 12:29:46 +00:00
builtin.RegisterActorState(builtin4.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
return load4(store, root)
})
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
}
migrate methods to abstracted methods Method numbers never change anyways. At worst, we'll deprecate old methods and have to explicitly import them from the correct actors version to use them.
2020-10-08 20:32:54 +00:00
var (
v4 specs-actors integration, nv12 migration
2021-04-23 12:29:46 +00:00
Address = builtin4.InitActorAddr
Methods = builtin4.MethodsInit
migrate methods to abstracted methods Method numbers never change anyways. At worst, we'll deprecate old methods and have to explicitly import them from the correct actors version to use them.
2020-10-08 20:32:54 +00:00
)
Progress
2020-09-14 22:43:12 +00:00
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
func Load(store adt.Store, act *types.Actor) (State, error) {
switch act.Code {
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
rename imports to match actors code `sed -i 's/\bv0\(\w\)\(\w*\)/\L\1\E\20/g' **/*.go`
2020-09-18 21:59:27 +00:00
case builtin0.InitActorCodeID:
add a generic load method for actor state This will make it easier to load arbitrary actors. We can: * Type switch (sort of unsafe, may want marker methods?) * Use this with `vm.MutateActorState`.
2020-09-24 00:40:29 +00:00
return load0(store, act.Head)
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
rename actors v1 -> actors v2 The actual actors version is v2, not v1. Using Version1 internally was really confusing.
2020-09-28 20:13:18 +00:00
case builtin2.InitActorCodeID:
return load2(store, act.Head)
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
Add v3 actors support for init
2021-01-16 04:21:33 +00:00
case builtin3.InitActorCodeID:
return load3(store, act.Head)
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
v4 specs-actors integration, nv12 migration
2021-04-23 12:29:46 +00:00
case builtin4.InitActorCodeID:
return load4(store, act.Head)
Cleanup actor adapter templates
2021-04-30 15:51:24 +00:00
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
}
return nil, xerrors.Errorf("unknown actor code %s", act.Code)
}
Allow starting networks from arbitrary actor versions
2021-05-15 01:11:23 +00:00
func MakeState(store adt.Store, av actors.Version, networkName string) (State, error) {
switch av {
case actors.Version0:
return make0(store, networkName)
case actors.Version2:
return make2(store, networkName)
case actors.Version3:
return make3(store, networkName)
case actors.Version4:
return make4(store, networkName)
}
return nil, xerrors.Errorf("unknown actor version %d", av)
}
func GetActorCodeID(av actors.Version) (cid.Cid, error) {
switch av {
case actors.Version0:
return builtin0.InitActorCodeID, nil
case actors.Version2:
return builtin2.InitActorCodeID, nil
case actors.Version3:
return builtin3.InitActorCodeID, nil
case actors.Version4:
return builtin4.InitActorCodeID, nil
}
return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
}
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
type State interface {
cbor.Marshaler
Fix some build errors
2020-09-14 11:14:06 +00:00
ResolveAddress(address address.Address) (address.Address, bool, error)
MapAddressToNewID(address address.Address) (address.Address, error)
Progress
2020-09-14 22:43:12 +00:00
NetworkName() (dtypes.NetworkName, error)
finish upgrading chainwatch
2020-09-18 20:43:14 +00:00
ForEachActor(func(id abi.ActorID, address address.Address) error) error
add init.State#Remove() for testing.
2020-09-23 16:42:01 +00:00
// Remove exists to support tooling that manipulates state for testing.
// It should not be used in production code, as init actor entries are
// immutable.
Remove(addrs ...address.Address) error
make setNetworkName work with any actors version
2020-09-28 22:54:48 +00:00
// Sets the network's name. This should only be used on upgrade/fork.
SetNetworkName(name string) error
polish: add DeffAddressMap method to init wrapper - replace logic in predicates
2020-11-16 19:18:50 +00:00
Allow starting networks from arbitrary actor versions
2021-05-15 01:11:23 +00:00
// Sets the next ID for the init actor. This should only be used for testing.
SetNextID(id abi.ActorID) error
// Sets the address map for the init actor. This should only be used for testing.
SetAddressMap(mcid cid.Cid) error
AddressMap() (adt.Map, error)
GetState() interface{}
[WIP] Network upgrade support This patch starts adding support for network upgrades. * It adds an actors abstraction layer for loading abstract (cross-version) actors. * It starts switching over to a shared deadline type. * It adds an abstraction for ADTs (hamt/amt). * It removes the callback-based API in the StateManager (difficult to abstract across actor versions). * It _does not_ actually add support for actors v2. We can do that in a followup patch but that should be relatively easy. This patch is heavily WIP and does not compile. Feel free to push changes directly to this branch. Notes: * State tree access now needs a network version, because the HAMT type will change. * I haven't figured out a nice way to abstract over changes to the _message_ types. However, many of them will be type aliased to actors v0 in actors v2 so we can likely continue using the v0 versions (or use the v2 versions everywhere). I've been renaming imports to `v0*` to make it clear that we're importing types from a _specific_ actors version. TODO: * Consider merging incremental improvements? We'd have to get this compiling again first but we could merge in the new abstractions, and slowly switch over. * Finish migrating to the new abstractions. * Remove all actor state types from the public API. See `miner.State.Info()` for the planned approach here. * Fix the tests. This is likely going to be a massive pain.
2020-09-12 03:07:52 +00:00
}
Reference in New Issue Copy Permalink