diff --git a/api/mocks/mock_full.go b/api/mocks/mock_full.go index db41332a114..5fc97b58bdc 100644 --- a/api/mocks/mock_full.go +++ b/api/mocks/mock_full.go @@ -28,7 +28,7 @@ import ( auth "github.com/filecoin-project/go-jsonrpc/auth" abi "github.com/filecoin-project/go-state-types/abi" big "github.com/filecoin-project/go-state-types/big" - miner "github.com/filecoin-project/go-state-types/builtin/v16/miner" + miner "github.com/filecoin-project/go-state-types/builtin/v17/miner" paych "github.com/filecoin-project/go-state-types/builtin/v8/paych" miner0 "github.com/filecoin-project/go-state-types/builtin/v9/miner" verifreg "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" diff --git a/api/types.go b/api/types.go index 6943d127e35..864b735665e 100644 --- a/api/types.go +++ b/api/types.go @@ -195,6 +195,7 @@ type ForkUpgradeParams struct { UpgradeTuktukHeight abi.ChainEpoch UpgradeTeepHeight abi.ChainEpoch UpgradeTockHeight abi.ChainEpoch + UpgradeXxHeight abi.ChainEpoch } // ChainExportConfig holds configuration for chain ranged exports. diff --git a/api/v0api/v0mocks/mock_full.go b/api/v0api/v0mocks/mock_full.go index b2a4125675a..035440c7cd1 100644 --- a/api/v0api/v0mocks/mock_full.go +++ b/api/v0api/v0mocks/mock_full.go @@ -23,7 +23,7 @@ import ( auth "github.com/filecoin-project/go-jsonrpc/auth" abi "github.com/filecoin-project/go-state-types/abi" big "github.com/filecoin-project/go-state-types/big" - miner "github.com/filecoin-project/go-state-types/builtin/v16/miner" + miner "github.com/filecoin-project/go-state-types/builtin/v17/miner" paych "github.com/filecoin-project/go-state-types/builtin/v8/paych" miner0 "github.com/filecoin-project/go-state-types/builtin/v9/miner" verifreg "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" diff --git a/build/actors/v17.tar.zst b/build/actors/v17.tar.zst new file mode 100644 index 00000000000..a53254b9db5 Binary files /dev/null and b/build/actors/v17.tar.zst differ diff --git a/build/buildconstants/params.go b/build/buildconstants/params.go index a8279f8179d..3c895ead171 100644 --- a/build/buildconstants/params.go +++ b/build/buildconstants/params.go @@ -45,6 +45,6 @@ const UserAgent = "lotus" /* inline-gen template const TestNetworkVersion = network.Version{{.latestNetworkVersion}} /* inline-gen start */ -const TestNetworkVersion = network.Version25 +const TestNetworkVersion = network.Version27 /* inline-gen end */ diff --git a/build/buildconstants/params_2k.go b/build/buildconstants/params_2k.go index 837c26b8d8b..f262596616a 100644 --- a/build/buildconstants/params_2k.go +++ b/build/buildconstants/params_2k.go @@ -22,7 +22,7 @@ const GenesisFile = "" var NetworkBundle = "devnet" var ActorDebugging = true -var GenesisNetworkVersion = network.Version24 +var GenesisNetworkVersion = network.Version26 var UpgradeBreezeHeight = abi.ChainEpoch(-1) @@ -72,29 +72,31 @@ const UpgradeWatermelonFixHeight = -100 // This fix upgrade only ran on calibrationnet const UpgradeWatermelonFix2Height = -101 -var UpgradeDragonHeight = abi.ChainEpoch(-24) +var UpgradeDragonHeight = abi.ChainEpoch(-25) // This fix upgrade only ran on calibrationnet const UpgradeCalibrationDragonFixHeight = -102 -var UpgradePhoenixHeight = abi.ChainEpoch(-25) +var UpgradePhoenixHeight = abi.ChainEpoch(-26) -var UpgradeWaffleHeight = abi.ChainEpoch(-26) +var UpgradeWaffleHeight = abi.ChainEpoch(-27) -var UpgradeTuktukHeight = abi.ChainEpoch(-27) +var UpgradeTuktukHeight = abi.ChainEpoch(-28) // FIP-0081: for the power actor state for pledge calculations. // UpgradeTuktukPowerRampDurationEpochs ends up in the power actor state after // Tuktuk migration. along with a RampStartEpoch matching the upgrade height. var UpgradeTuktukPowerRampDurationEpochs uint64 = 200 -var UpgradeTeepHeight = abi.ChainEpoch(200) +var UpgradeTeepHeight = abi.ChainEpoch(-29) var UpgradeTeepInitialFilReserved = wholeFIL(1_400_000_000) // FIP-0100: 300M -> 1.4B FIL -var UpgradeTockHeight = abi.ChainEpoch(300) +var UpgradeTockHeight = abi.ChainEpoch(-30) -var UpgradeTockFixHeight = abi.ChainEpoch(-28) +const UpgradeTockFixHeight = -103 + +var UpgradeXxHeight = abi.ChainEpoch(200) var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandQuicknet, @@ -174,7 +176,8 @@ func init() { UpgradeTuktukHeight = getUpgradeHeight("LOTUS_TUKTUK_HEIGHT", UpgradeTuktukHeight) UpgradeTeepHeight = getUpgradeHeight("LOTUS_TEEP_HEIGHT", UpgradeTeepHeight) UpgradeTockHeight = getUpgradeHeight("LOTUS_TOCK_HEIGHT", UpgradeTockHeight) - UpgradeTockFixHeight = getUpgradeHeight("LOTUS_TOCK_FIX_HEIGHT", UpgradeTockFixHeight) + // UpgradeTockFixHeight = getUpgradeHeight("LOTUS_TOCK_FIX_HEIGHT", UpgradeTockFixHeight) + UpgradeXxHeight = getUpgradeHeight("LOTUS_XX_HEIGHT", UpgradeXxHeight) DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandQuicknet, diff --git a/build/buildconstants/params_butterfly.go b/build/buildconstants/params_butterfly.go index 0b05ac96b03..52b8524554b 100644 --- a/build/buildconstants/params_butterfly.go +++ b/build/buildconstants/params_butterfly.go @@ -74,14 +74,17 @@ const UpgradeTuktukHeight = -28 // Tuktuk migration. along with a RampStartEpoch matching the upgrade height. var UpgradeTuktukPowerRampDurationEpochs = uint64(builtin.EpochsInYear) -// ?????? -const UpgradeTeepHeight = 4320 +const UpgradeTeepHeight = -29 var UpgradeTeepInitialFilReserved = wholeFIL(1_600_000_000) // FIP-0100: 300M -> 1.6B FIL +const UpgradeTockHeight = -30 + +// This fix upgrade only ran on calibrationnet +const UpgradeTockFixHeight = -103 + // ?????? -const UpgradeTockHeight = UpgradeTeepHeight + builtin.EpochsInDay*2 -const UpgradeTockFixHeight = -29 +const UpgradeXxHeight = 999999999999999 var ConsensusMinerMinPower = abi.NewStoragePower(2 << 30) var PreCommitChallengeDelay = abi.ChainEpoch(150) diff --git a/build/buildconstants/params_calibnet.go b/build/buildconstants/params_calibnet.go index fb159933254..1b81753f161 100644 --- a/build/buildconstants/params_calibnet.go +++ b/build/buildconstants/params_calibnet.go @@ -125,6 +125,9 @@ var UpgradeTockHeight abi.ChainEpoch = UpgradeTeepHeight + builtin.EpochsInDay*7 // 2025-04-07T23:00:00Z const UpgradeTockFixHeight abi.ChainEpoch = 2558014 +// ?????? +const UpgradeXxHeight = 999999999999999 + var ConsensusMinerMinPower = abi.NewStoragePower(32 << 30) var PreCommitChallengeDelay = abi.ChainEpoch(150) diff --git a/build/buildconstants/params_interop.go b/build/buildconstants/params_interop.go index 80f2733c10e..2f3179a96dd 100644 --- a/build/buildconstants/params_interop.go +++ b/build/buildconstants/params_interop.go @@ -73,13 +73,16 @@ var UpgradeTuktukHeight = abi.ChainEpoch(-28) // Tuktuk migration. along with a RampStartEpoch matching the upgrade height. var UpgradeTuktukPowerRampDurationEpochs = uint64(builtin.EpochsInYear) -const UpgradeTeepHeight abi.ChainEpoch = 50 +var UpgradeTeepHeight = abi.ChainEpoch(-29) var UpgradeTeepInitialFilReserved = InitialFilReserved // FIP-0100: no change for interop -const UpgradeTockHeight abi.ChainEpoch = 100 +var UpgradeTockHeight = abi.ChainEpoch(-30) -const UpgradeTockFixHeight abi.ChainEpoch = -29 +// This fix upgrade only ran on calibrationnet +const UpgradeTockFixHeight abi.ChainEpoch = -4 + +const UpgradeXxHeight = 50 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandQuicknet, diff --git a/build/buildconstants/params_mainnet.go b/build/buildconstants/params_mainnet.go index ca760f9b1d4..f72109cf4ab 100644 --- a/build/buildconstants/params_mainnet.go +++ b/build/buildconstants/params_mainnet.go @@ -138,6 +138,9 @@ var UpgradeTockHeight = UpgradeTeepHeight + builtin.EpochsInDay*90 // Only applied to calibnet which was already upgraded to Teep&Tock var UpgradeTockFixHeight = abi.ChainEpoch(-1) +// ?????? +var UpgradeXxHeight = abi.ChainEpoch(9999999999) + var UpgradeTeepInitialFilReserved = InitialFilReserved // FIP-0100: no change for mainnet var ConsensusMinerMinPower = abi.NewStoragePower(10 << 40) @@ -155,8 +158,8 @@ func init() { } SetAddressNetwork(addrNetwork) - if os.Getenv("LOTUS_DISABLE_TEEP") == "1" { - UpgradeTeepHeight = math.MaxInt64 - 1 + if os.Getenv("LOTUS_DISABLE_XX") == "1" { + UpgradeXxHeight = math.MaxInt64 - 1 } // NOTE: DO NOT change this unless you REALLY know what you're doing. This is not consensus critical, however, diff --git a/build/buildconstants/params_testground.go b/build/buildconstants/params_testground.go index 384b99a41af..c355e0a866e 100644 --- a/build/buildconstants/params_testground.go +++ b/build/buildconstants/params_testground.go @@ -110,6 +110,7 @@ var ( UpgradeTeepInitialFilReserved *big.Int = wholeFIL(300_000_000) UpgradeTockHeight abi.ChainEpoch = -32 UpgradeTockFixHeight abi.ChainEpoch = -33 + UpgradeXxHeight abi.ChainEpoch = -34 DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandMainnet, diff --git a/build/builtin_actors_gen.go b/build/builtin_actors_gen.go index 69fc3bc4712..219d7abfd9c 100644 --- a/build/builtin_actors_gen.go +++ b/build/builtin_actors_gen.go @@ -178,9 +178,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzacebf6qpnaem4d3kku74hyizal7rfqmxvngvnerq3gxmyqvnib4ho22"), "verifiedregistry": cid.MustParse("bafk2bzacebxppwtgpstn55klmiux64pwekibcapv6v26nbfrrateth5zzsdic"), }, +}, { + Network: "butterflynet", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzaceda5lc7qrwp2hdm6s6erppwuydsfqrhbgld7juixalk342inqimbo"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzacea4fxakv3zww2jb7aaa4v6w7usbcxho7kpc6xpho66ltny72vnzki"), + "cron": cid.MustParse("bafk2bzaceckhx3amza3xyxvw4x7xg7w7itsokvweiylys2mlcvvvi64uhyfhi"), + "datacap": cid.MustParse("bafk2bzacecx6cqocsn6e3ouq4tgumrlbazrnydp7bo2rxrtfgbd7soerqplxs"), + "eam": cid.MustParse("bafk2bzaced54tzjl37qsxbb2cml6l2hlupaplzdrdamq7kxihcikbd4goezg4"), + "ethaccount": cid.MustParse("bafk2bzacedtz6bt2fex7xdm2tmov5kwexoayesguhx5i3ohjyw23sbbwrbokg"), + "evm": cid.MustParse("bafk2bzaced2i4ez5megwfrlxxv7akcf27hu2fezj3ipiy66skvagvzc5jtxlo"), + "init": cid.MustParse("bafk2bzaced6lrgkw4dnxyc72beeyct4tgjup6syt7j2llvlwtkqi3eb5ncyzu"), + "multisig": cid.MustParse("bafk2bzacebwgwsjsglawtmvmb4fmvagmyjfjvky2mkipk3ysqt2cylrut4pna"), + "paymentchannel": cid.MustParse("bafk2bzaceakx75ascqt3cpgcgjjjo3lzj6etlit7rvy5r2rnpg35pn5lxdkho"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzaceagyezzhrgwp55i6zpj3qkyprebhdmszn725kdl73z6awpse2ek4m"), + "storagemarket": cid.MustParse("bafk2bzacebrch7gi6wmzgipnx4jiwgpq2ogul6fkgfkqefoujwxsfp7i3wsic"), + "storageminer": cid.MustParse("bafk2bzacebtzpyy56k4ehwgxbil5ryegys4qgbw6dnsnk3y7qf5y7le2hedoe"), + "storagepower": cid.MustParse("bafk2bzacecoi2bu2iipdnkx3pvjbe4d5pbmtcef4lxsdbv7hchgnbbvb6sy6k"), + "system": cid.MustParse("bafk2bzacebxmdwaw5rm2apbfqgl2yt25n4abpxhwoy3xou6j6z7aiozsvm722"), + "verifiedregistry": cid.MustParse("bafk2bzaceahaut5mk7ndk3yi3uvsalpqpv7h7cdjl7vhkyxmkcypvq6ynn2mk"), + }, }, { Network: "butterflynet", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzaceda5lc7qrwp2hdm6s6erppwuydsfqrhbgld7juixalk342inqimbo"), Actors: map[string]cid.Cid{ @@ -368,9 +390,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzacecybufhea4ah2vwtp4pqxotdfk2lnrgu6cw63jstysjzzcegio4ps"), "verifiedregistry": cid.MustParse("bafk2bzacedbvfxhxsdktslf2rto5kyiumvppoen2avbmpgh7ijsmkxjyua3s4"), }, +}, { + Network: "calibrationnet", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzacecqtwq6hjhj2zy5gwjp76a4tpcg2lt7dps5ycenvynk2ijqqyo65e"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzacecvd4xzbqbviaydq5r2h2jdgcn6bh5nklvohgvorznpstmir7l6dw"), + "cron": cid.MustParse("bafk2bzaced6fxiw4g4faqhxxsetzcxlcyyjlwtzqiuwsx5zd2krtadxbiailg"), + "datacap": cid.MustParse("bafk2bzaceabx5td6pj4btk6i7jknz5utzufcmq2n6winpxlvpl42u2fktfi66"), + "eam": cid.MustParse("bafk2bzacebeppkeq2gvro6hln34zd6z37s5vv5naa4x6j6jifkxnfsahxspak"), + "ethaccount": cid.MustParse("bafk2bzaceaxurgmyscg4oevz7nzloxra5je2omeogj5icprnopie3j64qgjii"), + "evm": cid.MustParse("bafk2bzaceaauqz2332lqb6cvprlinm4ot4ge4ugkyadgz7qsrukaeyucichlc"), + "init": cid.MustParse("bafk2bzacedsfrhdsqolmmbw2pmhe6yv57xifdu7ohcybguzhlt7xjeqpbtkak"), + "multisig": cid.MustParse("bafk2bzacedtukutyifkwelun4nq7asowfzmdyrefmycc3xphajdlauti2w7zq"), + "paymentchannel": cid.MustParse("bafk2bzaceaftvzd5t2wkmmsgs2lzndoqpb2fkhpzdafnuhxiw2abzzevdc6me"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzaceb27rdgwaxsc3byewbhyy2z5xmlatfgzhmzaynzgdovadoxspzkqm"), + "storagemarket": cid.MustParse("bafk2bzacebsn3npegbog3dytzvx6ewliykjkrzuzzrxphe3dmokbou3d4knt2"), + "storageminer": cid.MustParse("bafk2bzacedihkoywi2of6yyrsduumajikdd2gbipbbe77m4mlxgez6f2nsz26"), + "storagepower": cid.MustParse("bafk2bzacec2qeuhmhowlscnmjfystimyvgmcuj6vfv6arykw3qj53ibcgytbw"), + "system": cid.MustParse("bafk2bzacecm546a5qoxncfggdhnxx6xpzks5gvblgi6w2fntr3sq4kgal62wk"), + "verifiedregistry": cid.MustParse("bafk2bzacecz57hshtuixafiv2hwve7gidcbsp5tauc237fencal6vzie5jb6w"), + }, }, { Network: "calibrationnet", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzacecqtwq6hjhj2zy5gwjp76a4tpcg2lt7dps5ycenvynk2ijqqyo65e"), Actors: map[string]cid.Cid{ @@ -567,9 +611,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzacecwyleco2r5bjjxdj3dp26bluua3f3u4mta4wmrrslfxscb2kz37o"), "verifiedregistry": cid.MustParse("bafk2bzacec4i7zpu6ca5zqcxsowiqqofqix7z5gh3k27mndpnm3wujbzuf2bk"), }, +}, { + Network: "caterpillarnet", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzacedrq643mgak6w3nbmz3wvcgjrirdoq7y6l3xgwijgirffgaxf6yqg"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzacedza75txhwk3ztrl2m5uh7efogxbm7pj5rzqkxj2y2r3w5ixorz7i"), + "cron": cid.MustParse("bafk2bzaceddiyznwu7kejp5l7yevyt76gptqquk6dmi7w3y7dd5zrdo2lzcci"), + "datacap": cid.MustParse("bafk2bzacecooyqdimvocqtbgmqrje655orzjlk4qrp45eht54sopocisx4sxe"), + "eam": cid.MustParse("bafk2bzaceaqqtglbvo7zkxhghbe6yeukrcyh2branruehey7nxhyyksaiblxg"), + "ethaccount": cid.MustParse("bafk2bzacedrpqany3j5tvzff4a6xssndoypfodd3ldfn3yq5nbuazafbjegoc"), + "evm": cid.MustParse("bafk2bzacecctqd57nqtjvqyawpfemnp23l4gcwff7afozc3ybpppkgtqqcer2"), + "init": cid.MustParse("bafk2bzacecrruqv2aut3g32u555ufsfp37tmczoz6varsomatc3ylzydosi3m"), + "multisig": cid.MustParse("bafk2bzaceadivjkiocpidioxr2t2omeylbll3thk5obdxbcyej7l2nauziutu"), + "paymentchannel": cid.MustParse("bafk2bzacedbfec2xl6vuusd2klq5b3aljuipkn6hutaxkc4uhaj6zvzb754m6"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzacec4s34n3xym3xejjdlji6e5ejkxmvplpsswfpxklqynfzye432zdq"), + "storagemarket": cid.MustParse("bafk2bzacedgpjd6nibik27iyknog4xootrt3lpd6szdch5hbwltqja6e7dym4"), + "storageminer": cid.MustParse("bafk2bzacedvkr6p7sw57s667jv2vodzbka3whiypuvv34xh2lipe4heooywc6"), + "storagepower": cid.MustParse("bafk2bzaceb6riblkmadrqceh2wx47ecfu3ylcxxad2gb473weqkkcucpvzos6"), + "system": cid.MustParse("bafk2bzacedauxksf7i3eixxff277thsgbqqfmrkmdo3mm7mth5tguxstsxpbc"), + "verifiedregistry": cid.MustParse("bafk2bzaceatvxu6ffkq3nvhffmw5avoeixt3yymzyotlz2qkyw4sh5ffw26gg"), + }, }, { Network: "caterpillarnet", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzacedrq643mgak6w3nbmz3wvcgjrirdoq7y6l3xgwijgirffgaxf6yqg"), Actors: map[string]cid.Cid{ @@ -757,9 +823,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzacebkim7xhbjjuwyqmegclkftnfoz74735yreqdcwr2i6z2kbv767ae"), "verifiedregistry": cid.MustParse("bafk2bzacedd6hquizdv65nai6h5f2lfhkxgkrofn2zcrrwqi5cmbo2wotx6vm"), }, +}, { + Network: "devnet", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzaceclp3wfrwdjgh6c3gee5smwj3zmmrhb4fdbc4yfchfaia6rlljx5o"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzacebl27l7f5dt35gfeukr7kzkenhwisdy53r3gmbagbzzfejfa3ci6a"), + "cron": cid.MustParse("bafk2bzacedzo57rpw6debpc7aaenevimqdw44o47l5kjk27xd6qynjx7spyls"), + "datacap": cid.MustParse("bafk2bzaceddnadztnvgblxukwhwygtynyiee26itbpkncoolxpspvryspvii4"), + "eam": cid.MustParse("bafk2bzacecogdrpspcsorwamsrmtpmofocc5si7bcavo4jhtbcgpxq6rl5s5q"), + "ethaccount": cid.MustParse("bafk2bzacebxukyx7vernilg3fcz2h4ale43zj2gijpsa5lon2bcqtme32mss6"), + "evm": cid.MustParse("bafk2bzacecnukm3qvrefmtrxvazdvghclk67o47p4o42fnpzv4l6cm3etfjqc"), + "init": cid.MustParse("bafk2bzaceanl3arbn3vbx7qoxjbxbygm3g5rgibypt4ukxia3lhwniqumwmfm"), + "multisig": cid.MustParse("bafk2bzacedym2qai72hu53yggfx5czuu7cluu3ft4gyparnw7l624on2uoqqo"), + "paymentchannel": cid.MustParse("bafk2bzacedetue6b2ekilnzam7derkslpuhmy45bhsrcj36tuwpuoyi56i734"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzacebrtvcnof275odfobuw6k5chzl23p4mac75bg3amnempzauj57i6a"), + "storagemarket": cid.MustParse("bafk2bzaced2fw4smkqrhoshiskvvmdak2vzmkgxijanp24xqumkhyhwioz6bc"), + "storageminer": cid.MustParse("bafk2bzacebmdlcmrseltgqqcw36q4njwp5cjw24kqf5q5cohonhbbrhv3hxbk"), + "storagepower": cid.MustParse("bafk2bzaceattnfxccxgeickyhei4txzi2qj6jaks5h7im4uaqmaoxk2jthlri"), + "system": cid.MustParse("bafk2bzaceapx3vuukaqkj76ck4k6b46ktle452ek2nxeoy5qrtaxdktchrb6k"), + "verifiedregistry": cid.MustParse("bafk2bzaceat7zehx2y5joxtufcwbx4ium47fw4mrubdlquzpla4esqfzimkas"), + }, }, { Network: "devnet", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzaceclp3wfrwdjgh6c3gee5smwj3zmmrhb4fdbc4yfchfaia6rlljx5o"), Actors: map[string]cid.Cid{ @@ -969,9 +1057,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzacecvcqje6kcfqeayj66hezlwzfznytwqkxgw7p64xac5f5lcwjpbwe"), "verifiedregistry": cid.MustParse("bafk2bzacecudaqwbz6dukmdbfok7xuxcpjqighnizhxun4spdqvnqgftkupp2"), }, +}, { + Network: "mainnet", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzacecnepvsh4lw6pwljobvwm6zwu6mbwveatp7llhpuguvjhjiqz7o46"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzacedef4sqdsfebspu7dqnk7naj27ac4lyho4zmvjrei5qnf2wn6v64u"), + "cron": cid.MustParse("bafk2bzacedjpipmkmlmgcsmvxijivmeo62t7zul7565wy7ubfmwdlwzbl2zsg"), + "datacap": cid.MustParse("bafk2bzaceblfbzlkvtwxucr3wno7tilbri2kyagdlcsu2snntkii26gye2cmo"), + "eam": cid.MustParse("bafk2bzacec3wpa2sr5w6vfh7d2wbzt3cphoglsd6fvem7cq3h52lg357hfovu"), + "ethaccount": cid.MustParse("bafk2bzacealmhbhzgo4kkyy32qlumxirnc75nyfkpd757dbxtgwktqu2zztjy"), + "evm": cid.MustParse("bafk2bzacecrriac4r2pbxkh5wu67sgwgce2qysfl7thmg7smgmwwqjff5kq74"), + "init": cid.MustParse("bafk2bzacecfk7a3ns32wrbyoxvv4jfdoesl7cqpc34rqdsiehxvr4kz6jzc7u"), + "multisig": cid.MustParse("bafk2bzaceastb65il5j3v2q2pfxgk7brmzh6djzisjo3mfybbiplgy3w7iscm"), + "paymentchannel": cid.MustParse("bafk2bzaceanasifggzenhwl5cchnv3rro63mcodpveix6glfkzuwl3qknqn6k"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzacebm6enbbihclumyi2pfkpdganx3hhjuzdnlow5q3tazsflmgi32hq"), + "storagemarket": cid.MustParse("bafk2bzaceaqmav32yzxh4suviytyeqszvrdsvl7emf6a7vtlfwsebrvwlg7p2"), + "storageminer": cid.MustParse("bafk2bzacectp5rumce4kekelolp6abrtfbbdjwl3ydjvurmfd6nbk3tott4ks"), + "storagepower": cid.MustParse("bafk2bzaced6jncjckyzoswbbrwokiq35avufm2tlkertvoqkh76qkd2ccddls"), + "system": cid.MustParse("bafk2bzaceaar6jzusbxv5ekouldqatgiblyrcldlxuoahyypdaeozm57rmjk6"), + "verifiedregistry": cid.MustParse("bafk2bzacedxvui4lmogudblf7ir2rkglsfnjqlrzqv7hzcoa4t3dr2ni2vv26"), + }, }, { Network: "mainnet", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzacecnepvsh4lw6pwljobvwm6zwu6mbwveatp7llhpuguvjhjiqz7o46"), Actors: map[string]cid.Cid{ @@ -1159,9 +1269,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzaceb7zn7sblfs3jterbvzm2cnp4g3ys5yfd3vhatkascrjsidyw74sq"), "verifiedregistry": cid.MustParse("bafk2bzaceafcnglgibjq5c26bzoyndzu77g6wdr7s3nnr3wjwhhtvfy7pb5dw"), }, +}, { + Network: "testing", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzaceazq2v3l6w2vhch76v5y5krsif5zf65ctega6bll6yrsxavwoyrf2"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzaceaib7urgwq6pt2f77ursvsgjvad7yb6vlptf3wae5rrh5wovvmxn6"), + "cron": cid.MustParse("bafk2bzacebr6zmuxuy3rxe7733oujafqigltqd5jsi2ze4axzwglkpqah3m4s"), + "datacap": cid.MustParse("bafk2bzaceblwnw5qd3p3o743pdcnkoi47tdgtqxpfbcx4gch2nxnhcblbkpte"), + "eam": cid.MustParse("bafk2bzacebebe5i4jtsnaoa3u2qa3mxqi3cuytldwofbgurhjekikpdgtefbw"), + "ethaccount": cid.MustParse("bafk2bzacecv5ccd5thpjuhfzk3b2564ln3p2nxmz4lubqslksjwq6b2hex2ks"), + "evm": cid.MustParse("bafk2bzacedlt5pkp3yitopmxj54ajxbuurakpxomizjqvfr7ouqeit75jhd6c"), + "init": cid.MustParse("bafk2bzaceauopjjp5ayh6s7uhuwp2xdjl2hv6rdaqq77monisq66kzcwspntg"), + "multisig": cid.MustParse("bafk2bzaced4uaayjgp4pz3ovgnbnv4fdtne23jjzdgupeewk5oxjaqjlnapy4"), + "paymentchannel": cid.MustParse("bafk2bzacecx5nynsmwrv7kfmm6ymns5arubyx2as6i56nrzgwp4jezoacl3gg"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzacec3622qzank3tagb6uogxw7wnoo6qfnmkvey3ubwrbg7febsn2z5c"), + "storagemarket": cid.MustParse("bafk2bzaceb2tc4c744eoi2zzn4xjla63wb7rk2btn44azamxnempk2g3niyci"), + "storageminer": cid.MustParse("bafk2bzaceaqekep6caen5naku3wd5hcid6frupsbazrtz5zzdv2ti6wbss3tc"), + "storagepower": cid.MustParse("bafk2bzacebelnvhileuzmplwxyixjqlb56h6n24hi33odykmogmxsailnj7o4"), + "system": cid.MustParse("bafk2bzacedzgl7z6nuaqgf3mrq2dijcn4kzsb32p5brs4olyntejibxs4qqko"), + "verifiedregistry": cid.MustParse("bafk2bzacec2x4ryjqtsqblashbvv7eomx3japq73vnendog6rjjskcwyd4i7e"), + }, }, { Network: "testing", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzaceazq2v3l6w2vhch76v5y5krsif5zf65ctega6bll6yrsxavwoyrf2"), Actors: map[string]cid.Cid{ @@ -1349,9 +1481,31 @@ var EmbeddedBuiltinActorsMetadata = []*BuiltinActorsMetadata{{ "system": cid.MustParse("bafk2bzaceb7zn7sblfs3jterbvzm2cnp4g3ys5yfd3vhatkascrjsidyw74sq"), "verifiedregistry": cid.MustParse("bafk2bzaceafcnglgibjq5c26bzoyndzu77g6wdr7s3nnr3wjwhhtvfy7pb5dw"), }, +}, { + Network: "testing-fake-proofs", + Version: 16, + ManifestCid: cid.MustParse("bafy2bzaceaauqnw45yfi6lh53gzxzx47tabzh7zart6eqr3eojp72vtzgs6tg"), + Actors: map[string]cid.Cid{ + "account": cid.MustParse("bafk2bzaceaib7urgwq6pt2f77ursvsgjvad7yb6vlptf3wae5rrh5wovvmxn6"), + "cron": cid.MustParse("bafk2bzacebr6zmuxuy3rxe7733oujafqigltqd5jsi2ze4axzwglkpqah3m4s"), + "datacap": cid.MustParse("bafk2bzaceblwnw5qd3p3o743pdcnkoi47tdgtqxpfbcx4gch2nxnhcblbkpte"), + "eam": cid.MustParse("bafk2bzacebebe5i4jtsnaoa3u2qa3mxqi3cuytldwofbgurhjekikpdgtefbw"), + "ethaccount": cid.MustParse("bafk2bzacecv5ccd5thpjuhfzk3b2564ln3p2nxmz4lubqslksjwq6b2hex2ks"), + "evm": cid.MustParse("bafk2bzacedlt5pkp3yitopmxj54ajxbuurakpxomizjqvfr7ouqeit75jhd6c"), + "init": cid.MustParse("bafk2bzaceauopjjp5ayh6s7uhuwp2xdjl2hv6rdaqq77monisq66kzcwspntg"), + "multisig": cid.MustParse("bafk2bzaceaslzv237r4fh2n2p5jzno2zcqeuuqesz4bkutppblnltpvaqvjyo"), + "paymentchannel": cid.MustParse("bafk2bzacecx5nynsmwrv7kfmm6ymns5arubyx2as6i56nrzgwp4jezoacl3gg"), + "placeholder": cid.MustParse("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"), + "reward": cid.MustParse("bafk2bzacec3622qzank3tagb6uogxw7wnoo6qfnmkvey3ubwrbg7febsn2z5c"), + "storagemarket": cid.MustParse("bafk2bzaceb2tc4c744eoi2zzn4xjla63wb7rk2btn44azamxnempk2g3niyci"), + "storageminer": cid.MustParse("bafk2bzacebskehig7aknijmw5gf3n6lm7hkawumebv2rmfyhnlo6ldtvul33q"), + "storagepower": cid.MustParse("bafk2bzacebelnvhileuzmplwxyixjqlb56h6n24hi33odykmogmxsailnj7o4"), + "system": cid.MustParse("bafk2bzacedzgl7z6nuaqgf3mrq2dijcn4kzsb32p5brs4olyntejibxs4qqko"), + "verifiedregistry": cid.MustParse("bafk2bzacec2x4ryjqtsqblashbvv7eomx3japq73vnendog6rjjskcwyd4i7e"), + }, }, { Network: "testing-fake-proofs", - Version: 16, + Version: 17, BundleGitTag: "v16.0.1", ManifestCid: cid.MustParse("bafy2bzaceaauqnw45yfi6lh53gzxzx47tabzh7zart6eqr3eojp72vtzgs6tg"), Actors: map[string]cid.Cid{ diff --git a/build/openrpc/full.json b/build/openrpc/full.json index 885cc73ee1c..1e0e7eb585d 100644 --- a/build/openrpc/full.json +++ b/build/openrpc/full.json @@ -17600,7 +17600,7 @@ "title": "number", "description": "Number is a number", "examples": [ - 25 + 27 ], "type": [ "number" @@ -17652,7 +17652,7 @@ "title": "number", "description": "Number is a number", "examples": [ - 25 + 27 ], "type": [ "number" @@ -20526,7 +20526,8 @@ "UpgradeWaffleHeight": 10101, "UpgradeTuktukHeight": 10101, "UpgradeTeepHeight": 10101, - "UpgradeTockHeight": 10101 + "UpgradeTockHeight": 10101, + "UpgradeXxHeight": 10101 }, "Eip155ChainID": 123, "GenesisTimestamp": 42 @@ -20672,6 +20673,10 @@ "UpgradeWatermelonHeight": { "title": "number", "type": "number" + }, + "UpgradeXxHeight": { + "title": "number", + "type": "number" } }, "type": "object" @@ -23878,7 +23883,7 @@ "title": "number", "description": "Number is a number", "examples": [ - 25 + 27 ], "type": [ "number" diff --git a/build/openrpc/gateway.json b/build/openrpc/gateway.json index 4c90b426623..41c559c781f 100644 --- a/build/openrpc/gateway.json +++ b/build/openrpc/gateway.json @@ -9336,7 +9336,8 @@ "UpgradeWaffleHeight": 10101, "UpgradeTuktukHeight": 10101, "UpgradeTeepHeight": 10101, - "UpgradeTockHeight": 10101 + "UpgradeTockHeight": 10101, + "UpgradeXxHeight": 10101 }, "Eip155ChainID": 123, "GenesisTimestamp": 42 @@ -9482,6 +9483,10 @@ "UpgradeWatermelonHeight": { "title": "number", "type": "number" + }, + "UpgradeXxHeight": { + "title": "number", + "type": "number" } }, "type": "object" @@ -10577,7 +10582,7 @@ "title": "number", "description": "Number is a number", "examples": [ - 25 + 27 ], "type": [ "number" diff --git a/build/openrpc/miner.json b/build/openrpc/miner.json index c44425fd42a..b548e5d0f00 100644 --- a/build/openrpc/miner.json +++ b/build/openrpc/miner.json @@ -538,7 +538,7 @@ "title": "number", "description": "Number is a number", "examples": [ - 25 + 27 ], "type": [ "number" diff --git a/build/openrpc/v0/gateway.json b/build/openrpc/v0/gateway.json index 9aee0e9b99c..b0399e605ef 100644 --- a/build/openrpc/v0/gateway.json +++ b/build/openrpc/v0/gateway.json @@ -4756,7 +4756,7 @@ "title": "number", "description": "Number is a number", "examples": [ - 25 + 27 ], "type": [ "number" diff --git a/chain/actors/builtin/account/account.go b/chain/actors/builtin/account/account.go index 93dff219f16..7a4d3ffa0c3 100644 --- a/chain/actors/builtin/account/account.go +++ b/chain/actors/builtin/account/account.go @@ -6,7 +6,7 @@ import ( "github.com/filecoin-project/go-address" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -22,7 +22,7 @@ import ( "github.com/filecoin-project/lotus/chain/types" ) -var Methods = builtin16.MethodsAccount +var Methods = builtin17.MethodsAccount func Load(store adt.Store, act *types.Actor) (State, error) { if name, av, ok := actors.GetActorMetaByCode(act.Code); ok { @@ -59,6 +59,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -141,6 +144,9 @@ func MakeState(store adt.Store, av actorstypes.Version, addr address.Address) (S case actorstypes.Version16: return make16(store, addr) + case actorstypes.Version17: + return make17(store, addr) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -174,5 +180,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/account/v17.go b/chain/actors/builtin/account/v17.go new file mode 100644 index 00000000000..960ad5ed76f --- /dev/null +++ b/chain/actors/builtin/account/v17.go @@ -0,0 +1,62 @@ +package account + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-address" + actorstypes "github.com/filecoin-project/go-state-types/actors" + account17 "github.com/filecoin-project/go-state-types/builtin/v17/account" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, addr address.Address) (State, error) { + out := state17{store: store} + out.State = account17.State{Address: addr} + return &out, nil +} + +type state17 struct { + account17.State + store adt.Store +} + +func (s *state17) PubkeyAddress() (address.Address, error) { + return s.Address, nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) ActorKey() string { + return manifest.AccountKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/cron/cron.go b/chain/actors/builtin/cron/cron.go index 9648cc30531..7f35c19b280 100644 --- a/chain/actors/builtin/cron/cron.go +++ b/chain/actors/builtin/cron/cron.go @@ -5,7 +5,7 @@ import ( "golang.org/x/xerrors" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin" @@ -55,6 +55,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -137,13 +140,16 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version16: return make16(store) + case actorstypes.Version17: + return make17(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } var ( - Address = builtin16.CronActorAddr - Methods = builtin16.MethodsCron + Address = builtin17.CronActorAddr + Methods = builtin17.MethodsCron ) type State interface { @@ -172,5 +178,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/cron/v17.go b/chain/actors/builtin/cron/v17.go new file mode 100644 index 00000000000..d95a3b0c860 --- /dev/null +++ b/chain/actors/builtin/cron/v17.go @@ -0,0 +1,57 @@ +package cron + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + actorstypes "github.com/filecoin-project/go-state-types/actors" + cron17 "github.com/filecoin-project/go-state-types/builtin/v17/cron" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store) (State, error) { + out := state17{store: store} + out.State = *cron17.ConstructState(cron17.BuiltInEntries()) + return &out, nil +} + +type state17 struct { + cron17.State + store adt.Store +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) ActorKey() string { + return manifest.CronKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/datacap/datacap.go b/chain/actors/builtin/datacap/datacap.go index 916858c80ab..6661280346b 100644 --- a/chain/actors/builtin/datacap/datacap.go +++ b/chain/actors/builtin/datacap/datacap.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" @@ -17,8 +17,8 @@ import ( ) var ( - Address = builtin16.DatacapActorAddr - Methods = builtin16.MethodsDatacap + Address = builtin17.DatacapActorAddr + Methods = builtin17.MethodsDatacap ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -53,6 +53,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -86,6 +89,9 @@ func MakeState(store adt.Store, av actorstypes.Version, governor address.Address case actorstypes.Version16: return make16(store, governor, bitwidth) + case actorstypes.Version17: + return make17(store, governor, bitwidth) + default: return nil, xerrors.Errorf("datacap actor only valid for actors v9 and above, got %d", av) } @@ -114,5 +120,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/datacap/v17.go b/chain/actors/builtin/datacap/v17.go new file mode 100644 index 00000000000..7fb3fc11cbd --- /dev/null +++ b/chain/actors/builtin/datacap/v17.go @@ -0,0 +1,82 @@ +package datacap + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + datacap17 "github.com/filecoin-project/go-state-types/builtin/v17/datacap" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, governor address.Address, bitwidth uint64) (State, error) { + out := state17{store: store} + s, err := datacap17.ConstructState(store, governor, bitwidth) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state17 struct { + datacap17.State + store adt.Store +} + +func (s *state17) Governor() (address.Address, error) { + return s.State.Governor, nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error { + return forEachClient(s.store, actors.Version17, s.verifiedClients, cb) +} + +func (s *state17) verifiedClients() (adt.Map, error) { + return adt17.AsMap(s.store, s.Token.Balances, int(s.Token.HamtBitWidth)) +} + +func (s *state17) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) { + return getDataCap(s.store, actors.Version17, s.verifiedClients, addr) +} + +func (s *state17) ActorKey() string { + return manifest.DatacapKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/evm/evm.go b/chain/actors/builtin/evm/evm.go index 8c36476af25..97990f1354b 100644 --- a/chain/actors/builtin/evm/evm.go +++ b/chain/actors/builtin/evm/evm.go @@ -5,7 +5,7 @@ import ( "golang.org/x/xerrors" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/exitcode" "github.com/filecoin-project/go-state-types/manifest" @@ -15,7 +15,7 @@ import ( "github.com/filecoin-project/lotus/chain/types" ) -var Methods = builtin16.MethodsEVM +var Methods = builtin17.MethodsEVM // See https://github.com/filecoin-project/builtin-actors/blob/6e781444cee5965278c46ef4ffe1fb1970f18d7d/actors/evm/src/lib.rs#L35-L42 const ( @@ -58,6 +58,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -88,6 +91,9 @@ func MakeState(store adt.Store, av actorstypes.Version, bytecode cid.Cid) (State case actorstypes.Version16: return make16(store, bytecode) + case actorstypes.Version17: + return make17(store, bytecode) + default: return nil, xerrors.Errorf("evm actor only valid for actors v10 and above, got %d", av) } diff --git a/chain/actors/builtin/evm/v17.go b/chain/actors/builtin/evm/v17.go new file mode 100644 index 00000000000..e01ff5c72b9 --- /dev/null +++ b/chain/actors/builtin/evm/v17.go @@ -0,0 +1,72 @@ +package evm + +import ( + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-state-types/abi" + evm17 "github.com/filecoin-project/go-state-types/builtin/v17/evm" + + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, bytecode cid.Cid) (State, error) { + out := state17{store: store} + s, err := evm17.ConstructState(store, bytecode) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state17 struct { + evm17.State + store adt.Store +} + +func (s *state17) Nonce() (uint64, error) { + return s.State.Nonce, nil +} + +func (s *state17) IsAlive() (bool, error) { + return s.State.Tombstone == nil, nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) GetBytecodeCID() (cid.Cid, error) { + return s.State.Bytecode, nil +} + +func (s *state17) GetBytecodeHash() ([32]byte, error) { + return s.State.BytecodeHash, nil +} + +func (s *state17) GetBytecode() ([]byte, error) { + bc, err := s.GetBytecodeCID() + if err != nil { + return nil, err + } + + var byteCode abi.CborBytesTransparent + if err := s.store.Get(s.store.Context(), bc, &byteCode); err != nil { + return nil, err + } + + return byteCode, nil +} diff --git a/chain/actors/builtin/init/init.go b/chain/actors/builtin/init/init.go index 1512f16e685..536087b229f 100644 --- a/chain/actors/builtin/init/init.go +++ b/chain/actors/builtin/init/init.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -25,8 +25,8 @@ import ( ) var ( - Address = builtin16.InitActorAddr - Methods = builtin16.MethodsInit + Address = builtin17.InitActorAddr + Methods = builtin17.MethodsInit ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -64,6 +64,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -146,6 +149,9 @@ func MakeState(store adt.Store, av actorstypes.Version, networkName string) (Sta case actorstypes.Version16: return make16(store, networkName) + case actorstypes.Version17: + return make17(store, networkName) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -202,5 +208,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/init/v17.go b/chain/actors/builtin/init/v17.go new file mode 100644 index 00000000000..8296af1886e --- /dev/null +++ b/chain/actors/builtin/init/v17.go @@ -0,0 +1,147 @@ +package init + +import ( + "crypto/sha256" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" + "github.com/filecoin-project/lotus/node/modules/dtypes" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, networkName string) (State, error) { + out := state17{store: store} + + s, err := init17.ConstructState(store, networkName) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state17 struct { + init17.State + store adt.Store +} + +func (s *state17) ResolveAddress(address address.Address) (address.Address, bool, error) { + return s.State.ResolveAddress(s.store, address) +} + +func (s *state17) MapAddressToNewID(address address.Address) (address.Address, error) { + return s.State.MapAddressToNewID(s.store, address) +} + +func (s *state17) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error { + addrs, err := adt17.AsMap(s.store, s.State.AddressMap, builtin17.DefaultHamtBitwidth) + if err != nil { + return err + } + var actorID cbg.CborInt + return addrs.ForEach(&actorID, func(key string) error { + addr, err := address.NewFromBytes([]byte(key)) + if err != nil { + return err + } + return cb(abi.ActorID(actorID), addr) + }) +} + +func (s *state17) NetworkName() (dtypes.NetworkName, error) { + return dtypes.NetworkName(s.State.NetworkName), nil +} + +func (s *state17) SetNetworkName(name string) error { + s.State.NetworkName = name + return nil +} + +func (s *state17) SetNextID(id abi.ActorID) error { + s.State.NextID = id + return nil +} + +func (s *state17) Remove(addrs ...address.Address) (err error) { + m, err := adt17.AsMap(s.store, s.State.AddressMap, builtin17.DefaultHamtBitwidth) + if err != nil { + return err + } + for _, addr := range addrs { + if err = m.Delete(abi.AddrKey(addr)); err != nil { + return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err) + } + } + amr, err := m.Root() + if err != nil { + return xerrors.Errorf("failed to get address map root: %w", err) + } + s.State.AddressMap = amr + return nil +} + +func (s *state17) SetAddressMap(mcid cid.Cid) error { + s.State.AddressMap = mcid + return nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) AddressMap() (adt.Map, error) { + return adt17.AsMap(s.store, s.State.AddressMap, builtin17.DefaultHamtBitwidth) +} + +func (s *state17) AddressMapBitWidth() int { + return builtin17.DefaultHamtBitwidth +} + +func (s *state17) AddressMapHashFunction() func(input []byte) []byte { + return func(input []byte) []byte { + res := sha256.Sum256(input) + return res[:] + } +} + +func (s *state17) ActorKey() string { + return manifest.InitKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/market/market.go b/chain/actors/builtin/market/market.go index fb21f4c67a2..6cbc602629a 100644 --- a/chain/actors/builtin/market/market.go +++ b/chain/actors/builtin/market/market.go @@ -70,6 +70,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -152,6 +155,9 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version16: return make16(store) + case actorstypes.Version17: + return make17(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -268,6 +274,9 @@ func DecodePublishStorageDealsReturn(b []byte, nv network.Version) (PublishStora case actorstypes.Version16: return decodePublishStorageDealsReturn16(b) + case actorstypes.Version17: + return decodePublishStorageDealsReturn17(b) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -409,5 +418,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/market/v17.go b/chain/actors/builtin/market/v17.go new file mode 100644 index 00000000000..68a67d01387 --- /dev/null +++ b/chain/actors/builtin/market/v17.go @@ -0,0 +1,482 @@ +package market + +import ( + "bytes" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-bitfield" + rlepluslazy "github.com/filecoin-project/go-bitfield/rle" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + "github.com/filecoin-project/go-state-types/builtin" + market17 "github.com/filecoin-project/go-state-types/builtin/v17/market" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + markettypes "github.com/filecoin-project/go-state-types/builtin/v9/market" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" + verifregtypes "github.com/filecoin-project/lotus/chain/actors/builtin/verifreg" + "github.com/filecoin-project/lotus/chain/types" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store) (State, error) { + out := state17{store: store} + + s, err := market17.ConstructState(store) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state17 struct { + market17.State + store adt.Store +} + +func (s *state17) TotalLocked() (abi.TokenAmount, error) { + fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral) + fml = types.BigAdd(fml, s.TotalClientStorageFee) + return fml, nil +} + +func (s *state17) BalancesChanged(otherState State) (bool, error) { + otherState17, ok := otherState.(*state17) + if !ok { + // there's no way to compare different versions of the state, so let's + // just say that means the state of balances has changed + return true, nil + } + return !s.State.EscrowTable.Equals(otherState17.State.EscrowTable) || !s.State.LockedTable.Equals(otherState17.State.LockedTable), nil +} + +func (s *state17) StatesChanged(otherState State) (bool, error) { + otherState17, ok := otherState.(*state17) + if !ok { + // there's no way to compare different versions of the state, so let's + // just say that means the state of balances has changed + return true, nil + } + return !s.State.States.Equals(otherState17.State.States), nil +} + +func (s *state17) States() (DealStates, error) { + stateArray, err := adt17.AsArray(s.store, s.State.States, market17.StatesAmtBitwidth) + if err != nil { + return nil, err + } + return &dealStates17{stateArray}, nil +} + +func (s *state17) ProposalsChanged(otherState State) (bool, error) { + otherState17, ok := otherState.(*state17) + if !ok { + // there's no way to compare different versions of the state, so let's + // just say that means the state of balances has changed + return true, nil + } + return !s.State.Proposals.Equals(otherState17.State.Proposals), nil +} + +func (s *state17) Proposals() (DealProposals, error) { + proposalArray, err := adt17.AsArray(s.store, s.State.Proposals, market17.ProposalsAmtBitwidth) + if err != nil { + return nil, err + } + return &dealProposals17{proposalArray}, nil +} + +func (s *state17) PendingProposals() (PendingProposals, error) { + proposalCidSet, err := adt17.AsSet(s.store, s.State.PendingProposals, builtin.DefaultHamtBitwidth) + if err != nil { + return nil, err + } + return &pendingProposals17{proposalCidSet}, nil +} + +func (s *state17) EscrowTable() (BalanceTable, error) { + bt, err := adt17.AsBalanceTable(s.store, s.State.EscrowTable) + if err != nil { + return nil, err + } + return &balanceTable17{bt}, nil +} + +func (s *state17) LockedTable() (BalanceTable, error) { + bt, err := adt17.AsBalanceTable(s.store, s.State.LockedTable) + if err != nil { + return nil, err + } + return &balanceTable17{bt}, nil +} + +func (s *state17) VerifyDealsForActivation( + minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch, +) (verifiedWeight abi.DealWeight, err error) { + _, vw, _, err := market17.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch) + return vw, err +} + +func (s *state17) NextID() (abi.DealID, error) { + return s.State.NextID, nil +} + +type balanceTable17 struct { + *adt17.BalanceTable +} + +func (bt *balanceTable17) ForEach(cb func(address.Address, abi.TokenAmount) error) error { + asMap := (*adt17.Map)(bt.BalanceTable) + var ta abi.TokenAmount + return asMap.ForEach(&ta, func(key string) error { + a, err := address.NewFromBytes([]byte(key)) + if err != nil { + return err + } + return cb(a, ta) + }) +} + +type dealStates17 struct { + adt.Array +} + +func (s *dealStates17) Get(dealID abi.DealID) (DealState, bool, error) { + var deal17 market17.DealState + found, err := s.Array.Get(uint64(dealID), &deal17) + if err != nil { + return nil, false, err + } + if !found { + return nil, false, nil + } + deal := fromV17DealState(deal17) + return deal, true, nil +} + +func (s *dealStates17) ForEach(cb func(dealID abi.DealID, ds DealState) error) error { + var ds17 market17.DealState + return s.Array.ForEach(&ds17, func(idx int64) error { + return cb(abi.DealID(idx), fromV17DealState(ds17)) + }) +} + +func (s *dealStates17) decode(val *cbg.Deferred) (DealState, error) { + var ds17 market17.DealState + if err := ds17.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return nil, err + } + ds := fromV17DealState(ds17) + return ds, nil +} + +func (s *dealStates17) array() adt.Array { + return s.Array +} + +type dealStateV17 struct { + ds17 market17.DealState +} + +func (d dealStateV17) SectorNumber() abi.SectorNumber { + + return d.ds17.SectorNumber + +} + +func (d dealStateV17) SectorStartEpoch() abi.ChainEpoch { + return d.ds17.SectorStartEpoch +} + +func (d dealStateV17) LastUpdatedEpoch() abi.ChainEpoch { + return d.ds17.LastUpdatedEpoch +} + +func (d dealStateV17) SlashEpoch() abi.ChainEpoch { + return d.ds17.SlashEpoch +} + +func (d dealStateV17) Equals(other DealState) bool { + if ov17, ok := other.(dealStateV17); ok { + return d.ds17 == ov17.ds17 + } + + if d.SectorStartEpoch() != other.SectorStartEpoch() { + return false + } + if d.LastUpdatedEpoch() != other.LastUpdatedEpoch() { + return false + } + if d.SlashEpoch() != other.SlashEpoch() { + return false + } + + return true +} + +var _ DealState = (*dealStateV17)(nil) + +func fromV17DealState(v17 market17.DealState) DealState { + return dealStateV17{v17} +} + +type dealProposals17 struct { + adt.Array +} + +func (s *dealProposals17) Get(dealID abi.DealID) (*DealProposal, bool, error) { + var proposal17 market17.DealProposal + found, err := s.Array.Get(uint64(dealID), &proposal17) + if err != nil { + return nil, false, err + } + if !found { + return nil, false, nil + } + + proposal, err := fromV17DealProposal(proposal17) + if err != nil { + return nil, true, xerrors.Errorf("decoding proposal: %w", err) + } + + return &proposal, true, nil +} + +func (s *dealProposals17) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error { + var dp17 market17.DealProposal + return s.Array.ForEach(&dp17, func(idx int64) error { + dp, err := fromV17DealProposal(dp17) + if err != nil { + return xerrors.Errorf("decoding proposal: %w", err) + } + + return cb(abi.DealID(idx), dp) + }) +} + +func (s *dealProposals17) decode(val *cbg.Deferred) (*DealProposal, error) { + var dp17 market17.DealProposal + if err := dp17.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return nil, err + } + + dp, err := fromV17DealProposal(dp17) + if err != nil { + return nil, err + } + + return &dp, nil +} + +func (s *dealProposals17) array() adt.Array { + return s.Array +} + +type pendingProposals17 struct { + *adt17.Set +} + +func (s *pendingProposals17) Has(proposalCid cid.Cid) (bool, error) { + return s.Set.Has(abi.CidKey(proposalCid)) +} + +func fromV17DealProposal(v17 market17.DealProposal) (DealProposal, error) { + + label, err := fromV17Label(v17.Label) + + if err != nil { + return DealProposal{}, xerrors.Errorf("error setting deal label: %w", err) + } + + return DealProposal{ + PieceCID: v17.PieceCID, + PieceSize: v17.PieceSize, + VerifiedDeal: v17.VerifiedDeal, + Client: v17.Client, + Provider: v17.Provider, + + Label: label, + + StartEpoch: v17.StartEpoch, + EndEpoch: v17.EndEpoch, + StoragePricePerEpoch: v17.StoragePricePerEpoch, + + ProviderCollateral: v17.ProviderCollateral, + ClientCollateral: v17.ClientCollateral, + }, nil +} + +func fromV17Label(v17 market17.DealLabel) (DealLabel, error) { + if v17.IsString() { + str, err := v17.ToString() + if err != nil { + return markettypes.EmptyDealLabel, xerrors.Errorf("failed to convert string label to string: %w", err) + } + return markettypes.NewLabelFromString(str) + } + + bs, err := v17.ToBytes() + if err != nil { + return markettypes.EmptyDealLabel, xerrors.Errorf("failed to convert bytes label to bytes: %w", err) + } + return markettypes.NewLabelFromBytes(bs) +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +var _ PublishStorageDealsReturn = (*publishStorageDealsReturn17)(nil) + +func decodePublishStorageDealsReturn17(b []byte) (PublishStorageDealsReturn, error) { + var retval market17.PublishStorageDealsReturn + if err := retval.UnmarshalCBOR(bytes.NewReader(b)); err != nil { + return nil, xerrors.Errorf("failed to unmarshal PublishStorageDealsReturn: %w", err) + } + + return &publishStorageDealsReturn17{retval}, nil +} + +type publishStorageDealsReturn17 struct { + market17.PublishStorageDealsReturn +} + +func (r *publishStorageDealsReturn17) IsDealValid(index uint64) (bool, int, error) { + + set, err := r.ValidDeals.IsSet(index) + if err != nil || !set { + return false, -1, err + } + maskBf, err := bitfield.NewFromIter(&rlepluslazy.RunSliceIterator{ + Runs: []rlepluslazy.Run{rlepluslazy.Run{Val: true, Len: index}}}) + if err != nil { + return false, -1, err + } + before, err := bitfield.IntersectBitField(maskBf, r.ValidDeals) + if err != nil { + return false, -1, err + } + outIdx, err := before.Count() + if err != nil { + return false, -1, err + } + return set, int(outIdx), nil + +} + +func (r *publishStorageDealsReturn17) DealIDs() ([]abi.DealID, error) { + return r.IDs, nil +} + +func (s *state17) GetAllocationIdForPendingDeal(dealId abi.DealID) (verifregtypes.AllocationId, error) { + + allocations, err := adt17.AsMap(s.store, s.PendingDealAllocationIds, builtin.DefaultHamtBitwidth) + if err != nil { + return verifregtypes.NoAllocationID, xerrors.Errorf("failed to load allocation id for %d: %w", dealId, err) + } + + var allocationId cbg.CborInt + found, err := allocations.Get(abi.UIntKey(uint64(dealId)), &allocationId) + if err != nil { + return verifregtypes.NoAllocationID, xerrors.Errorf("failed to load allocation id for %d: %w", dealId, err) + } + if !found { + return verifregtypes.NoAllocationID, nil + } + + return verifregtypes.AllocationId(allocationId), nil + +} + +func (s *state17) ActorKey() string { + return manifest.MarketKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} + +func (s *state17) ProviderSectors() (ProviderSectors, error) { + + proverSectors, err := adt17.AsMap(s.store, s.State.ProviderSectors, builtin.DefaultHamtBitwidth) + if err != nil { + return nil, err + } + return &providerSectors17{proverSectors, s.store}, nil + +} + +type providerSectors17 struct { + *adt17.Map + adt17.Store +} + +type sectorDealIDs17 struct { + *adt17.Map +} + +func (s *providerSectors17) Get(actorId abi.ActorID) (SectorDealIDs, bool, error) { + var sectorDealIdsCID cbg.CborCid + if ok, err := s.Map.Get(abi.UIntKey(uint64(actorId)), §orDealIdsCID); err != nil { + return nil, false, xerrors.Errorf("failed to load sector deal ids for actor %d: %w", actorId, err) + } else if !ok { + return nil, false, nil + } + sectorDealIds, err := adt17.AsMap(s.Store, cid.Cid(sectorDealIdsCID), builtin.DefaultHamtBitwidth) + if err != nil { + return nil, false, xerrors.Errorf("failed to load sector deal ids for actor %d: %w", actorId, err) + } + return §orDealIDs17{sectorDealIds}, true, nil +} + +func (s *sectorDealIDs17) ForEach(cb func(abi.SectorNumber, []abi.DealID) error) error { + var dealIds abi.DealIDList + return s.Map.ForEach(&dealIds, func(key string) error { + uk, err := abi.ParseUIntKey(key) + if err != nil { + return xerrors.Errorf("failed to parse sector number from key %s: %w", key, err) + } + return cb(abi.SectorNumber(uk), dealIds) + }) +} + +func (s *sectorDealIDs17) Get(sectorNumber abi.SectorNumber) ([]abi.DealID, bool, error) { + var dealIds abi.DealIDList + found, err := s.Map.Get(abi.UIntKey(uint64(sectorNumber)), &dealIds) + if err != nil { + return nil, false, xerrors.Errorf("failed to load sector deal ids for sector %d: %w", sectorNumber, err) + } + if !found { + return nil, false, nil + } + return dealIds, true, nil +} diff --git a/chain/actors/builtin/miner/miner.go b/chain/actors/builtin/miner/miner.go index e652245464d..b0847f55b90 100644 --- a/chain/actors/builtin/miner/miner.go +++ b/chain/actors/builtin/miner/miner.go @@ -18,6 +18,8 @@ import ( smoothing15 "github.com/filecoin-project/go-state-types/builtin/v15/util/smoothing" minertypes16 "github.com/filecoin-project/go-state-types/builtin/v16/miner" smoothing16 "github.com/filecoin-project/go-state-types/builtin/v16/util/smoothing" + minertypes17 "github.com/filecoin-project/go-state-types/builtin/v17/miner" + smoothing17 "github.com/filecoin-project/go-state-types/builtin/v17/util/smoothing" minertypes "github.com/filecoin-project/go-state-types/builtin/v9/miner" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/dline" @@ -75,6 +77,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -157,6 +162,9 @@ func MakeState(store adt.Store, av actors.Version) (State, error) { case actors.Version16: return make16(store) + case actors.Version17: + return make17(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -250,7 +258,7 @@ type Partition interface { UnprovenSectors() (bitfield.BitField, error) } -type SectorOnChainInfo = minertypes16.SectorOnChainInfo +type SectorOnChainInfo = minertypes17.SectorOnChainInfo func PreferredSealProofTypeFromWindowPoStType(nver network.Version, proof abi.RegisteredPoStProof, configWantSynthetic bool) (abi.RegisteredSealProof, error) { // We added support for the new proofs in network version 7, and removed support for the old @@ -347,16 +355,16 @@ type SectorClaim = minertypes.SectorClaim type ExpirationExtension2 = minertypes.ExpirationExtension2 type CompactPartitionsParams = minertypes.CompactPartitionsParams type WithdrawBalanceParams = minertypes.WithdrawBalanceParams -type MaxTerminationFeeParams = minertypes16.MaxTerminationFeeParams -type MaxTerminationFeeReturn = minertypes16.MaxTerminationFeeReturn -type InitialPledgeReturn = minertypes16.InitialPledgeReturn +type MaxTerminationFeeParams = minertypes17.MaxTerminationFeeParams +type MaxTerminationFeeReturn = minertypes17.MaxTerminationFeeReturn +type InitialPledgeReturn = minertypes17.InitialPledgeReturn type PieceActivationManifest = minertypes13.PieceActivationManifest type ProveCommitSectors3Params = minertypes13.ProveCommitSectors3Params type SectorActivationManifest = minertypes13.SectorActivationManifest type ProveReplicaUpdates3Params = minertypes13.ProveReplicaUpdates3Params type SectorUpdateManifest = minertypes13.SectorUpdateManifest -type SectorOnChainInfoFlags = minertypes16.SectorOnChainInfoFlags +type SectorOnChainInfoFlags = minertypes17.SectorOnChainInfoFlags type VerifiedAllocationKey = minertypes13.VerifiedAllocationKey var QAPowerMax = minertypes.QAPowerMax @@ -372,8 +380,8 @@ const FaultDeclarationCutoff = minertypes.FaultDeclarationCutoff const MinAggregatedSectors = minertypes.MinAggregatedSectors const MinSectorExpiration = minertypes.MinSectorExpiration -var TermFeePledgeMultiple = minertypes16.TermFeePledgeMultiple -var TermFeeMaxFaultFeeMultiple = minertypes16.TermFeeMaxFaultFeeMultiple +var TermFeePledgeMultiple = minertypes17.TermFeePledgeMultiple +var TermFeeMaxFaultFeeMultiple = minertypes17.TermFeeMaxFaultFeeMultiple type SectorExpiration struct { OnTime abi.ChainEpoch @@ -432,6 +440,7 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } @@ -461,6 +470,18 @@ func PledgePenaltyForContinuedFault( } switch v { + case actorstypes.Version17: + return minertypes17.PledgePenaltyForContinuedFault( + smoothing17.FilterEstimate{ + PositionEstimate: rewardEstimate.PositionEstimate, + VelocityEstimate: rewardEstimate.VelocityEstimate, + }, + smoothing17.FilterEstimate{ + PositionEstimate: networkQaPowerEstimate.PositionEstimate, + VelocityEstimate: networkQaPowerEstimate.VelocityEstimate, + }, + qaSectorPower, + ), nil default: return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer) } @@ -480,6 +501,8 @@ func PledgePenaltyForTermination( switch v { case actorstypes.Version16: return minertypes16.PledgePenaltyForTermination(initialPledge, sectorAge, faultFee), nil + case actorstypes.Version17: + return minertypes17.PledgePenaltyForTermination(initialPledge, sectorAge, faultFee), nil default: return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer) } @@ -549,6 +572,19 @@ func ExpectedRewardForPower( qaSectorPower, projectionDuration, ), nil + case actorstypes.Version17: + return minertypes17.ExpectedRewardForPower( + smoothing17.FilterEstimate{ + PositionEstimate: rewardEstimate.PositionEstimate, + VelocityEstimate: rewardEstimate.VelocityEstimate, + }, + smoothing17.FilterEstimate{ + PositionEstimate: networkQAPowerEstimate.PositionEstimate, + VelocityEstimate: networkQAPowerEstimate.VelocityEstimate, + }, + qaSectorPower, + projectionDuration, + ), nil default: return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer) } diff --git a/chain/actors/builtin/miner/v17.go b/chain/actors/builtin/miner/v17.go new file mode 100644 index 00000000000..ee98ddc850a --- /dev/null +++ b/chain/actors/builtin/miner/v17.go @@ -0,0 +1,606 @@ +package miner + +import ( + "bytes" + "errors" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-bitfield" + rle "github.com/filecoin-project/go-bitfield/rle" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + "github.com/filecoin-project/go-state-types/big" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + miner17 "github.com/filecoin-project/go-state-types/builtin/v17/miner" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + "github.com/filecoin-project/go-state-types/dline" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store) (State, error) { + out := state17{store: store} + out.State = miner17.State{} + return &out, nil +} + +type state17 struct { + miner17.State + store adt.Store +} + +type deadline17 struct { + miner17.Deadline + store adt.Store +} + +type partition17 struct { + miner17.Partition + store adt.Store +} + +func (s *state17) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmount, err error) { + defer func() { + if r := recover(); r != nil { + err = xerrors.Errorf("failed to get available balance: %w", r) + available = abi.NewTokenAmount(0) + } + }() + // this panics if the miner doesn't have enough funds to cover their locked pledge + available, err = s.GetAvailableBalance(bal) + return available, err +} + +func (s *state17) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) { + return s.CheckVestedFunds(s.store, epoch) +} + +func (s *state17) LockedFunds() (LockedFunds, error) { + return LockedFunds{ + VestingFunds: s.State.LockedFunds, + InitialPledgeRequirement: s.State.InitialPledge, + PreCommitDeposits: s.State.PreCommitDeposits, + }, nil +} + +func (s *state17) FeeDebt() (abi.TokenAmount, error) { + return s.State.FeeDebt, nil +} + +func (s *state17) InitialPledge() (abi.TokenAmount, error) { + return s.State.InitialPledge, nil +} + +func (s *state17) PreCommitDeposits() (abi.TokenAmount, error) { + return s.State.PreCommitDeposits, nil +} + +// Returns nil, nil if sector is not found +func (s *state17) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) { + info, ok, err := s.State.GetSector(s.store, num) + if !ok || err != nil { + return nil, err + } + + ret := fromV17SectorOnChainInfo(*info) + return &ret, nil +} + +func (s *state17) FindSector(num abi.SectorNumber) (*SectorLocation, error) { + dlIdx, partIdx, err := s.State.FindSector(s.store, num) + if err != nil { + return nil, err + } + return &SectorLocation{ + Deadline: dlIdx, + Partition: partIdx, + }, nil +} + +func (s *state17) NumLiveSectors() (uint64, error) { + dls, err := s.State.LoadDeadlines(s.store) + if err != nil { + return 0, err + } + var total uint64 + if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner17.Deadline) error { + total += dl.LiveSectors + return nil + }); err != nil { + return 0, err + } + return total, nil +} + +// GetSectorExpiration returns the effective expiration of the given sector. +// +// If the sector does not expire early, the Early expiration field is 0. +func (s *state17) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) { + dls, err := s.State.LoadDeadlines(s.store) + if err != nil { + return nil, err + } + // NOTE: this can be optimized significantly. + // 1. If the sector is non-faulty, it will expire on-time (can be + // learned from the sector info). + // 2. If it's faulty, it will expire early within the first 42 entries + // of the expiration queue. + + stopErr := errors.New("stop") + out := SectorExpiration{} + err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner17.Deadline) error { + partitions, err := dl.PartitionsArray(s.store) + if err != nil { + return err + } + quant := s.State.QuantSpecForDeadline(dlIdx) + var part miner17.Partition + return partitions.ForEach(&part, func(partIdx int64) error { + if found, err := part.Sectors.IsSet(uint64(num)); err != nil { + return err + } else if !found { + return nil + } + if found, err := part.Terminated.IsSet(uint64(num)); err != nil { + return err + } else if found { + // already terminated + return stopErr + } + + q, err := miner17.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant, miner17.PartitionExpirationAmtBitwidth) + if err != nil { + return err + } + var exp miner17.ExpirationSet + return q.ForEach(&exp, func(epoch int64) error { + if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil { + return err + } else if early { + out.Early = abi.ChainEpoch(epoch) + return nil + } + if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil { + return err + } else if onTime { + out.OnTime = abi.ChainEpoch(epoch) + return stopErr + } + return nil + }) + }) + }) + if err == stopErr { + err = nil + } + if err != nil { + return nil, err + } + if out.Early == 0 && out.OnTime == 0 { + return nil, xerrors.Errorf("failed to find sector %d", num) + } + return &out, nil +} + +func (s *state17) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) { + info, ok, err := s.State.GetPrecommittedSector(s.store, num) + if !ok || err != nil { + return nil, err + } + + ret := fromV17SectorPreCommitOnChainInfo(*info) + + return &ret, nil +} + +func (s *state17) ForEachPrecommittedSector(cb func(SectorPreCommitOnChainInfo) error) error { + precommitted, err := adt17.AsMap(s.store, s.State.PreCommittedSectors, builtin17.DefaultHamtBitwidth) + if err != nil { + return err + } + + var info miner17.SectorPreCommitOnChainInfo + if err := precommitted.ForEach(&info, func(_ string) error { + return cb(fromV17SectorPreCommitOnChainInfo(info)) + }); err != nil { + return err + } + + return nil +} + +func (s *state17) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) { + sectors, err := miner17.LoadSectors(s.store, s.State.Sectors) + if err != nil { + return nil, err + } + + // If no sector numbers are specified, load all. + if snos == nil { + infos := make([]*SectorOnChainInfo, 0, sectors.Length()) + var info17 miner17.SectorOnChainInfo + if err := sectors.ForEach(&info17, func(_ int64) error { + info := fromV17SectorOnChainInfo(info17) + infos = append(infos, &info) + return nil + }); err != nil { + return nil, err + } + return infos, nil + } + + // Otherwise, load selected. + infos17, err := sectors.Load(*snos) + if err != nil { + return nil, err + } + infos := make([]*SectorOnChainInfo, len(infos17)) + for i, info17 := range infos17 { + info := fromV17SectorOnChainInfo(*info17) + infos[i] = &info + } + return infos, nil +} + +func (s *state17) loadAllocatedSectorNumbers() (bitfield.BitField, error) { + var allocatedSectors bitfield.BitField + err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors) + return allocatedSectors, err +} + +func (s *state17) IsAllocated(num abi.SectorNumber) (bool, error) { + allocatedSectors, err := s.loadAllocatedSectorNumbers() + if err != nil { + return false, err + } + + return allocatedSectors.IsSet(uint64(num)) +} + +func (s *state17) GetProvingPeriodStart() (abi.ChainEpoch, error) { + return s.State.ProvingPeriodStart, nil +} + +func (s *state17) UnallocatedSectorNumbers(count int) ([]abi.SectorNumber, error) { + allocatedSectors, err := s.loadAllocatedSectorNumbers() + if err != nil { + return nil, err + } + + allocatedRuns, err := allocatedSectors.RunIterator() + if err != nil { + return nil, err + } + + unallocatedRuns, err := rle.Subtract( + &rle.RunSliceIterator{Runs: []rle.Run{{Val: true, Len: abi.MaxSectorNumber}}}, + allocatedRuns, + ) + if err != nil { + return nil, err + } + + iter, err := rle.BitsFromRuns(unallocatedRuns) + if err != nil { + return nil, err + } + + sectors := make([]abi.SectorNumber, 0, count) + for iter.HasNext() && len(sectors) < count { + nextNo, err := iter.Next() + if err != nil { + return nil, err + } + sectors = append(sectors, abi.SectorNumber(nextNo)) + } + + return sectors, nil +} + +func (s *state17) GetAllocatedSectors() (*bitfield.BitField, error) { + var allocatedSectors bitfield.BitField + if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil { + return nil, err + } + + return &allocatedSectors, nil +} + +func (s *state17) LoadDeadline(idx uint64) (Deadline, error) { + dls, err := s.State.LoadDeadlines(s.store) + if err != nil { + return nil, err + } + dl, err := dls.LoadDeadline(s.store, idx) + if err != nil { + return nil, err + } + return &deadline17{*dl, s.store}, nil +} + +func (s *state17) ForEachDeadline(cb func(uint64, Deadline) error) error { + dls, err := s.State.LoadDeadlines(s.store) + if err != nil { + return err + } + return dls.ForEach(s.store, func(i uint64, dl *miner17.Deadline) error { + return cb(i, &deadline17{*dl, s.store}) + }) +} + +func (s *state17) NumDeadlines() (uint64, error) { + return miner17.WPoStPeriodDeadlines, nil +} + +func (s *state17) DeadlinesChanged(other State) (bool, error) { + other17, ok := other.(*state17) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + + return !s.State.Deadlines.Equals(other17.Deadlines), nil +} + +func (s *state17) MinerInfoChanged(other State) (bool, error) { + other0, ok := other.(*state17) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.Info.Equals(other0.State.Info), nil +} + +func (s *state17) Info() (MinerInfo, error) { + info, err := s.State.GetInfo(s.store) + if err != nil { + return MinerInfo{}, err + } + + mi := MinerInfo{ + Owner: info.Owner, + Worker: info.Worker, + ControlAddresses: info.ControlAddresses, + + PendingWorkerKey: (*WorkerKeyChange)(info.PendingWorkerKey), + + PeerId: info.PeerId, + Multiaddrs: info.Multiaddrs, + WindowPoStProofType: info.WindowPoStProofType, + SectorSize: info.SectorSize, + WindowPoStPartitionSectors: info.WindowPoStPartitionSectors, + ConsensusFaultElapsed: info.ConsensusFaultElapsed, + + Beneficiary: info.Beneficiary, + BeneficiaryTerm: BeneficiaryTerm(info.BeneficiaryTerm), + PendingBeneficiaryTerm: (*PendingBeneficiaryChange)(info.PendingBeneficiaryTerm), + } + + return mi, nil +} + +func (s *state17) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) { + return s.State.RecordedDeadlineInfo(epoch), nil +} + +func (s *state17) DeadlineCronActive() (bool, error) { + return s.State.DeadlineCronActive, nil +} + +func (s *state17) sectors() (adt.Array, error) { + return adt17.AsArray(s.store, s.Sectors, miner17.SectorsAmtBitwidth) +} + +func (s *state17) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) { + var si miner17.SectorOnChainInfo + err := si.UnmarshalCBOR(bytes.NewReader(val.Raw)) + if err != nil { + return SectorOnChainInfo{}, err + } + + return fromV17SectorOnChainInfo(si), nil +} + +func (s *state17) precommits() (adt.Map, error) { + return adt17.AsMap(s.store, s.PreCommittedSectors, builtin17.DefaultHamtBitwidth) +} + +func (s *state17) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) { + var sp miner17.SectorPreCommitOnChainInfo + err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw)) + if err != nil { + return SectorPreCommitOnChainInfo{}, err + } + + return fromV17SectorPreCommitOnChainInfo(sp), nil +} + +func (s *state17) EraseAllUnproven() error { + + dls, err := s.State.LoadDeadlines(s.store) + if err != nil { + return err + } + + err = dls.ForEach(s.store, func(dindx uint64, dl *miner17.Deadline) error { + ps, err := dl.PartitionsArray(s.store) + if err != nil { + return err + } + + var part miner17.Partition + err = ps.ForEach(&part, func(pindx int64) error { + _ = part.ActivateUnproven() + err = ps.Set(uint64(pindx), &part) + return nil + }) + + if err != nil { + return err + } + + dl.Partitions, err = ps.Root() + if err != nil { + return err + } + + return dls.UpdateDeadline(s.store, dindx, dl) + }) + if err != nil { + return err + } + + return s.State.SaveDeadlines(s.store, dls) + +} + +func (d *deadline17) LoadPartition(idx uint64) (Partition, error) { + p, err := d.Deadline.LoadPartition(d.store, idx) + if err != nil { + return nil, err + } + return &partition17{*p, d.store}, nil +} + +func (d *deadline17) ForEachPartition(cb func(uint64, Partition) error) error { + ps, err := d.Deadline.PartitionsArray(d.store) + if err != nil { + return err + } + var part miner17.Partition + return ps.ForEach(&part, func(i int64) error { + return cb(uint64(i), &partition17{part, d.store}) + }) +} + +func (d *deadline17) PartitionsChanged(other Deadline) (bool, error) { + other17, ok := other.(*deadline17) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + + return !d.Deadline.Partitions.Equals(other17.Deadline.Partitions), nil +} + +func (d *deadline17) PartitionsPoSted() (bitfield.BitField, error) { + return d.Deadline.PartitionsPoSted, nil +} + +func (d *deadline17) DisputableProofCount() (uint64, error) { + + ops, err := d.OptimisticProofsSnapshotArray(d.store) + if err != nil { + return 0, err + } + + return ops.Length(), nil + +} + +func (d *deadline17) DailyFee() (abi.TokenAmount, error) { + if d.Deadline.DailyFee.Int != nil { + return d.Deadline.DailyFee, nil + } + return big.Zero(), nil +} + +func (p *partition17) AllSectors() (bitfield.BitField, error) { + return p.Partition.Sectors, nil +} + +func (p *partition17) FaultySectors() (bitfield.BitField, error) { + return p.Partition.Faults, nil +} + +func (p *partition17) RecoveringSectors() (bitfield.BitField, error) { + return p.Partition.Recoveries, nil +} + +func (p *partition17) UnprovenSectors() (bitfield.BitField, error) { + return p.Partition.Unproven, nil +} + +func fromV17SectorOnChainInfo(v17 miner17.SectorOnChainInfo) SectorOnChainInfo { + dailyFee := v17.DailyFee + if dailyFee.Int == nil { + dailyFee = big.Zero() + } + info := SectorOnChainInfo{ + SectorNumber: v17.SectorNumber, + SealProof: v17.SealProof, + SealedCID: v17.SealedCID, + DeprecatedDealIDs: v17.DeprecatedDealIDs, + Activation: v17.Activation, + Expiration: v17.Expiration, + DealWeight: v17.DealWeight, + VerifiedDealWeight: v17.VerifiedDealWeight, + InitialPledge: v17.InitialPledge, + ExpectedDayReward: v17.ExpectedDayReward, + ExpectedStoragePledge: v17.ExpectedStoragePledge, + SectorKeyCID: v17.SectorKeyCID, + PowerBaseEpoch: v17.PowerBaseEpoch, + ReplacedDayReward: v17.ReplacedDayReward, + Flags: SectorOnChainInfoFlags(v17.Flags), + DailyFee: dailyFee, + } + return info +} + +func fromV17SectorPreCommitOnChainInfo(v17 miner17.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo { + ret := SectorPreCommitOnChainInfo{ + Info: SectorPreCommitInfo{ + SealProof: v17.Info.SealProof, + SectorNumber: v17.Info.SectorNumber, + SealedCID: v17.Info.SealedCID, + SealRandEpoch: v17.Info.SealRandEpoch, + DealIDs: v17.Info.DealIDs, + Expiration: v17.Info.Expiration, + UnsealedCid: nil, + }, + PreCommitDeposit: v17.PreCommitDeposit, + PreCommitEpoch: v17.PreCommitEpoch, + } + + ret.Info.UnsealedCid = v17.Info.UnsealedCid + + return ret +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) ActorKey() string { + return manifest.MinerKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/multisig/message10.go b/chain/actors/builtin/multisig/message10.go index ba52a9ffb0d..094b68a68e6 100644 --- a/chain/actors/builtin/multisig/message10.go +++ b/chain/actors/builtin/multisig/message10.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message10) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message11.go b/chain/actors/builtin/multisig/message11.go index ec5f47f3136..10d3760a871 100644 --- a/chain/actors/builtin/multisig/message11.go +++ b/chain/actors/builtin/multisig/message11.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message11) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message12.go b/chain/actors/builtin/multisig/message12.go index 831c9ec569a..3d40b730905 100644 --- a/chain/actors/builtin/multisig/message12.go +++ b/chain/actors/builtin/multisig/message12.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig12 "github.com/filecoin-project/go-state-types/builtin/v12/multisig" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message12) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message13.go b/chain/actors/builtin/multisig/message13.go index fed7562909f..c6ece002278 100644 --- a/chain/actors/builtin/multisig/message13.go +++ b/chain/actors/builtin/multisig/message13.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig13 "github.com/filecoin-project/go-state-types/builtin/v13/multisig" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message13) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message14.go b/chain/actors/builtin/multisig/message14.go index 25a1a8452bf..72e1be36e40 100644 --- a/chain/actors/builtin/multisig/message14.go +++ b/chain/actors/builtin/multisig/message14.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig14 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message14) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message15.go b/chain/actors/builtin/multisig/message15.go index 8ec70b9a3f7..acf29ef2062 100644 --- a/chain/actors/builtin/multisig/message15.go +++ b/chain/actors/builtin/multisig/message15.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message15) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message16.go b/chain/actors/builtin/multisig/message16.go index f16ca09293c..85383c3df01 100644 --- a/chain/actors/builtin/multisig/message16.go +++ b/chain/actors/builtin/multisig/message16.go @@ -7,8 +7,8 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" multisig16 "github.com/filecoin-project/go-state-types/builtin/v16/multisig" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message16) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message17.go b/chain/actors/builtin/multisig/message17.go new file mode 100644 index 00000000000..f7087406004 --- /dev/null +++ b/chain/actors/builtin/multisig/message17.go @@ -0,0 +1,77 @@ +package multisig + +import ( + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtintypes "github.com/filecoin-project/go-state-types/builtin" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" + multisig17 "github.com/filecoin-project/go-state-types/builtin/v17/multisig" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init" + "github.com/filecoin-project/lotus/chain/types" +) + +type message17 struct{ message0 } + +func (m message17) Create( + signers []address.Address, threshold uint64, + unlockStart, unlockDuration abi.ChainEpoch, + initialAmount abi.TokenAmount, +) (*types.Message, error) { + + lenAddrs := uint64(len(signers)) + + if lenAddrs < threshold { + return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig") + } + + if threshold == 0 { + threshold = lenAddrs + } + + if m.from == address.Undef { + return nil, xerrors.Errorf("must provide source address") + } + + // Set up constructor parameters for multisig + msigParams := &multisig17.ConstructorParams{ + Signers: signers, + NumApprovalsThreshold: threshold, + UnlockDuration: unlockDuration, + StartEpoch: unlockStart, + } + + enc, actErr := actors.SerializeParams(msigParams) + if actErr != nil { + return nil, actErr + } + + code, ok := actors.GetActorCodeID(actorstypes.Version17, manifest.MultisigKey) + if !ok { + return nil, xerrors.Errorf("failed to get multisig code ID") + } + + // new actors are created by invoking 'exec' on the init actor with the constructor params + execParams := &init17.ExecParams{ + CodeCID: code, + ConstructorParams: enc, + } + + enc, actErr = actors.SerializeParams(execParams) + if actErr != nil { + return nil, actErr + } + + return &types.Message{ + To: init_.Address, + From: m.from, + Method: builtintypes.MethodsInit.Exec, + Params: enc, + Value: initialAmount, + }, nil +} diff --git a/chain/actors/builtin/multisig/message8.go b/chain/actors/builtin/multisig/message8.go index add2b2df7d3..933b8a13e68 100644 --- a/chain/actors/builtin/multisig/message8.go +++ b/chain/actors/builtin/multisig/message8.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" multisig8 "github.com/filecoin-project/go-state-types/builtin/v8/multisig" "github.com/filecoin-project/go-state-types/manifest" @@ -57,7 +57,7 @@ func (m message8) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message9.go b/chain/actors/builtin/multisig/message9.go index 6500d4fed20..270305a7c4c 100644 --- a/chain/actors/builtin/multisig/message9.go +++ b/chain/actors/builtin/multisig/message9.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - init16 "github.com/filecoin-project/go-state-types/builtin/v16/init" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" multisig9 "github.com/filecoin-project/go-state-types/builtin/v9/multisig" "github.com/filecoin-project/go-state-types/manifest" @@ -57,7 +57,7 @@ func (m message9) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init16.ExecParams{ + execParams := &init17.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/multisig.go b/chain/actors/builtin/multisig/multisig.go index 7650fa7926e..40991f30be7 100644 --- a/chain/actors/builtin/multisig/multisig.go +++ b/chain/actors/builtin/multisig/multisig.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - msig16 "github.com/filecoin-project/go-state-types/builtin/v16/multisig" + msig17 "github.com/filecoin-project/go-state-types/builtin/v17/multisig" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -62,6 +62,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -144,6 +147,9 @@ func MakeState(store adt.Store, av actorstypes.Version, signers []address.Addres case actorstypes.Version16: return make16(store, signers, threshold, startEpoch, unlockDuration, initialBalance) + case actorstypes.Version17: + return make17(store, signers, threshold, startEpoch, unlockDuration, initialBalance) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -170,7 +176,7 @@ type State interface { GetState() interface{} } -type Transaction = msig16.Transaction +type Transaction = msig17.Transaction var Methods = builtintypes.MethodsMultisig @@ -224,6 +230,9 @@ func Message(version actorstypes.Version, from address.Address) MessageBuilder { case actorstypes.Version16: return message16{message0{from}} + + case actorstypes.Version17: + return message17{message0{from}} default: panic(fmt.Sprintf("unsupported actors version: %d", version)) } @@ -247,10 +256,10 @@ type MessageBuilder interface { } // this type is the same between v0 and v2 -type ProposalHashData = msig16.ProposalHashData -type ProposeReturn = msig16.ProposeReturn -type ProposeParams = msig16.ProposeParams -type ApproveReturn = msig16.ApproveReturn +type ProposalHashData = msig17.ProposalHashData +type ProposeReturn = msig17.ProposeReturn +type ProposeParams = msig17.ProposeParams +type ApproveReturn = msig17.ApproveReturn func AllCodes() []cid.Cid { return []cid.Cid{ @@ -270,5 +279,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/multisig/v17.go b/chain/actors/builtin/multisig/v17.go new file mode 100644 index 00000000000..5384731343f --- /dev/null +++ b/chain/actors/builtin/multisig/v17.go @@ -0,0 +1,138 @@ +package multisig + +import ( + "bytes" + "encoding/binary" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + msig17 "github.com/filecoin-project/go-state-types/builtin/v17/multisig" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) { + out := state17{store: store} + out.State = msig17.State{} + out.State.Signers = signers + out.State.NumApprovalsThreshold = threshold + out.State.StartEpoch = startEpoch + out.State.UnlockDuration = unlockDuration + out.State.InitialBalance = initialBalance + + em, err := adt17.StoreEmptyMap(store, builtin17.DefaultHamtBitwidth) + if err != nil { + return nil, err + } + + out.State.PendingTxns = em + + return &out, nil +} + +type state17 struct { + msig17.State + store adt.Store +} + +func (s *state17) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) { + return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil +} + +func (s *state17) StartEpoch() (abi.ChainEpoch, error) { + return s.State.StartEpoch, nil +} + +func (s *state17) UnlockDuration() (abi.ChainEpoch, error) { + return s.State.UnlockDuration, nil +} + +func (s *state17) InitialBalance() (abi.TokenAmount, error) { + return s.State.InitialBalance, nil +} + +func (s *state17) Threshold() (uint64, error) { + return s.State.NumApprovalsThreshold, nil +} + +func (s *state17) Signers() ([]address.Address, error) { + return s.State.Signers, nil +} + +func (s *state17) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error { + arr, err := adt17.AsMap(s.store, s.State.PendingTxns, builtin17.DefaultHamtBitwidth) + if err != nil { + return err + } + var out msig17.Transaction + return arr.ForEach(&out, func(key string) error { + txid, n := binary.Varint([]byte(key)) + if n <= 0 { + return xerrors.Errorf("invalid pending transaction key: %v", key) + } + return cb(txid, (Transaction)(out)) //nolint:unconvert + }) +} + +func (s *state17) PendingTxnChanged(other State) (bool, error) { + other17, ok := other.(*state17) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.PendingTxns.Equals(other17.PendingTxns), nil +} + +func (s *state17) transactions() (adt.Map, error) { + return adt17.AsMap(s.store, s.PendingTxns, builtin17.DefaultHamtBitwidth) +} + +func (s *state17) decodeTransaction(val *cbg.Deferred) (Transaction, error) { + var tx msig17.Transaction + if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return Transaction{}, err + } + return Transaction(tx), nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) ActorKey() string { + return manifest.MultisigKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/paych/message17.go b/chain/actors/builtin/paych/message17.go new file mode 100644 index 00000000000..92e0f900740 --- /dev/null +++ b/chain/actors/builtin/paych/message17.go @@ -0,0 +1,109 @@ +package paych + +import ( + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" + paych17 "github.com/filecoin-project/go-state-types/builtin/v17/paych" + paychtypes "github.com/filecoin-project/go-state-types/builtin/v8/paych" + + "github.com/filecoin-project/lotus/chain/actors" + init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init" + "github.com/filecoin-project/lotus/chain/types" +) + +type message17 struct{ from address.Address } + +func (m message17) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) { + + actorCodeID, ok := actors.GetActorCodeID(actorstypes.Version17, "paymentchannel") + if !ok { + return nil, xerrors.Errorf("error getting actor paymentchannel code id for actor version %d", 17) + } + + params, aerr := actors.SerializeParams(&paych17.ConstructorParams{From: m.from, To: to}) + if aerr != nil { + return nil, aerr + } + enc, aerr := actors.SerializeParams(&init17.ExecParams{ + CodeCID: actorCodeID, + ConstructorParams: params, + }) + if aerr != nil { + return nil, aerr + } + + return &types.Message{ + To: init_.Address, + From: m.from, + Value: initialAmount, + Method: builtin17.MethodsInit.Exec, + Params: enc, + }, nil +} + +func (m message17) Update(paych address.Address, sv *paychtypes.SignedVoucher, secret []byte) (*types.Message, error) { + params, aerr := actors.SerializeParams(&paych17.UpdateChannelStateParams{ + + Sv: toV17SignedVoucher(*sv), + + Secret: secret, + }) + if aerr != nil { + return nil, aerr + } + + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin17.MethodsPaych.UpdateChannelState, + Params: params, + }, nil +} + +func toV17SignedVoucher(sv paychtypes.SignedVoucher) paych17.SignedVoucher { + merges := make([]paych17.Merge, len(sv.Merges)) + for i := range sv.Merges { + merges[i] = paych17.Merge{ + Lane: sv.Merges[i].Lane, + Nonce: sv.Merges[i].Nonce, + } + } + + return paych17.SignedVoucher{ + ChannelAddr: sv.ChannelAddr, + TimeLockMin: sv.TimeLockMin, + TimeLockMax: sv.TimeLockMax, + SecretHash: sv.SecretHash, + Extra: (*paych17.ModVerifyParams)(sv.Extra), + Lane: sv.Lane, + Nonce: sv.Nonce, + Amount: sv.Amount, + MinSettleHeight: sv.MinSettleHeight, + Merges: merges, + Signature: sv.Signature, + } +} + +func (m message17) Settle(paych address.Address) (*types.Message, error) { + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin17.MethodsPaych.Settle, + }, nil +} + +func (m message17) Collect(paych address.Address) (*types.Message, error) { + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin17.MethodsPaych.Collect, + }, nil +} diff --git a/chain/actors/builtin/paych/paych.go b/chain/actors/builtin/paych/paych.go index 32b53aa7403..11dfd23f763 100644 --- a/chain/actors/builtin/paych/paych.go +++ b/chain/actors/builtin/paych/paych.go @@ -65,6 +65,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -197,6 +200,9 @@ func Message(version actorstypes.Version, from address.Address) MessageBuilder { case actorstypes.Version16: return message16{from} + case actorstypes.Version17: + return message17{from} + default: panic(fmt.Sprintf("unsupported actors version: %d", version)) } @@ -243,5 +249,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/paych/v17.go b/chain/actors/builtin/paych/v17.go new file mode 100644 index 00000000000..35927301650 --- /dev/null +++ b/chain/actors/builtin/paych/v17.go @@ -0,0 +1,135 @@ +package paych + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + "github.com/filecoin-project/go-state-types/big" + paych17 "github.com/filecoin-project/go-state-types/builtin/v17/paych" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store) (State, error) { + out := state17{store: store} + out.State = paych17.State{} + return &out, nil +} + +type state17 struct { + paych17.State + store adt.Store + lsAmt *adt17.Array +} + +// Channel owner, who has funded the actor +func (s *state17) From() (address.Address, error) { + return s.State.From, nil +} + +// Recipient of payouts from channel +func (s *state17) To() (address.Address, error) { + return s.State.To, nil +} + +// Height at which the channel can be `Collected` +func (s *state17) SettlingAt() (abi.ChainEpoch, error) { + return s.State.SettlingAt, nil +} + +// Amount successfully redeemed through the payment channel, paid out on `Collect()` +func (s *state17) ToSend() (abi.TokenAmount, error) { + return s.State.ToSend, nil +} + +func (s *state17) getOrLoadLsAmt() (*adt17.Array, error) { + if s.lsAmt != nil { + return s.lsAmt, nil + } + + // Get the lane state from the chain + lsamt, err := adt17.AsArray(s.store, s.State.LaneStates, paych17.LaneStatesAmtBitwidth) + if err != nil { + return nil, err + } + + s.lsAmt = lsamt + return lsamt, nil +} + +// Get total number of lanes +func (s *state17) LaneCount() (uint64, error) { + lsamt, err := s.getOrLoadLsAmt() + if err != nil { + return 0, err + } + return lsamt.Length(), nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +// Iterate lane states +func (s *state17) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error { + // Get the lane state from the chain + lsamt, err := s.getOrLoadLsAmt() + if err != nil { + return err + } + + // Note: we use a map instead of an array to store laneStates because the + // client sets the lane ID (the index) and potentially they could use a + // very large index. + var ls paych17.LaneState + return lsamt.ForEach(&ls, func(i int64) error { + return cb(uint64(i), &laneState17{ls}) + }) +} + +type laneState17 struct { + paych17.LaneState +} + +func (ls *laneState17) Redeemed() (big.Int, error) { + return ls.LaneState.Redeemed, nil +} + +func (ls *laneState17) Nonce() (uint64, error) { + return ls.LaneState.Nonce, nil +} + +func (s *state17) ActorKey() string { + return manifest.PaychKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/power/power.go b/chain/actors/builtin/power/power.go index 8184d2aa092..ff77c32aff8 100644 --- a/chain/actors/builtin/power/power.go +++ b/chain/actors/builtin/power/power.go @@ -9,8 +9,8 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" "github.com/filecoin-project/go-state-types/big" - builtin16 "github.com/filecoin-project/go-state-types/builtin" - powertypes16 "github.com/filecoin-project/go-state-types/builtin/v16/power" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + powertypes17 "github.com/filecoin-project/go-state-types/builtin/v17/power" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -28,8 +28,8 @@ import ( ) var ( - Address = builtin16.StoragePowerActorAddr - Methods = builtin16.MethodsPower + Address = builtin17.StoragePowerActorAddr + Methods = builtin17.MethodsPower ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -67,6 +67,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -149,6 +152,9 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version16: return make16(store) + case actorstypes.Version17: + return make17(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -189,7 +195,7 @@ type State interface { // before returning the actor. ForEachClaim(cb func(miner address.Address, claim Claim) error, onlyEligible bool) error ClaimsChanged(State) (bool, error) - CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) + CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) // Testing or genesis setup only SetTotalQualityAdjPower(abi.StoragePower) error @@ -235,10 +241,11 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } type ( - MinerPowerParams = powertypes16.MinerPowerParams - MinerPowerReturn = powertypes16.MinerPowerReturn + MinerPowerParams = powertypes17.MinerPowerParams + MinerPowerReturn = powertypes17.MinerPowerReturn ) diff --git a/chain/actors/builtin/power/v0.go b/chain/actors/builtin/power/v0.go index 95fce8bf918..b09a875d191 100644 --- a/chain/actors/builtin/power/v0.go +++ b/chain/actors/builtin/power/v0.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt" @@ -131,11 +131,11 @@ func (s *state0) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state0) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state0) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v10.go b/chain/actors/builtin/power/v10.go index e6fe6bd268b..46acbf726bf 100644 --- a/chain/actors/builtin/power/v10.go +++ b/chain/actors/builtin/power/v10.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin10 "github.com/filecoin-project/go-state-types/builtin" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power10 "github.com/filecoin-project/go-state-types/builtin/v10/power" adt10 "github.com/filecoin-project/go-state-types/builtin/v10/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -127,11 +127,11 @@ func (s *state10) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state10) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state10) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v11.go b/chain/actors/builtin/power/v11.go index dcd655bf81a..2fb53ced7c1 100644 --- a/chain/actors/builtin/power/v11.go +++ b/chain/actors/builtin/power/v11.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin11 "github.com/filecoin-project/go-state-types/builtin" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power11 "github.com/filecoin-project/go-state-types/builtin/v11/power" adt11 "github.com/filecoin-project/go-state-types/builtin/v11/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -127,11 +127,11 @@ func (s *state11) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state11) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state11) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v12.go b/chain/actors/builtin/power/v12.go index 35198534b5d..aef22d15499 100644 --- a/chain/actors/builtin/power/v12.go +++ b/chain/actors/builtin/power/v12.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin12 "github.com/filecoin-project/go-state-types/builtin" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power12 "github.com/filecoin-project/go-state-types/builtin/v12/power" adt12 "github.com/filecoin-project/go-state-types/builtin/v12/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -127,11 +127,11 @@ func (s *state12) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state12) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state12) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v13.go b/chain/actors/builtin/power/v13.go index 6ec3a4fcf31..e27b52ffcae 100644 --- a/chain/actors/builtin/power/v13.go +++ b/chain/actors/builtin/power/v13.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin13 "github.com/filecoin-project/go-state-types/builtin" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power13 "github.com/filecoin-project/go-state-types/builtin/v13/power" adt13 "github.com/filecoin-project/go-state-types/builtin/v13/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -127,11 +127,11 @@ func (s *state13) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state13) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state13) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v14.go b/chain/actors/builtin/power/v14.go index bcdbd1fdcc7..f19bd752276 100644 --- a/chain/actors/builtin/power/v14.go +++ b/chain/actors/builtin/power/v14.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin14 "github.com/filecoin-project/go-state-types/builtin" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power14 "github.com/filecoin-project/go-state-types/builtin/v14/power" adt14 "github.com/filecoin-project/go-state-types/builtin/v14/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -127,11 +127,11 @@ func (s *state14) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state14) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state14) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v15.go b/chain/actors/builtin/power/v15.go index 48158010105..1c09ce93207 100644 --- a/chain/actors/builtin/power/v15.go +++ b/chain/actors/builtin/power/v15.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin15 "github.com/filecoin-project/go-state-types/builtin" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power15 "github.com/filecoin-project/go-state-types/builtin/v15/power" adt15 "github.com/filecoin-project/go-state-types/builtin/v15/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -127,11 +127,11 @@ func (s *state15) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state15) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state15) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v16.go b/chain/actors/builtin/power/v16.go index 8e048642618..2c2fbf08769 100644 --- a/chain/actors/builtin/power/v16.go +++ b/chain/actors/builtin/power/v16.go @@ -11,6 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" power16 "github.com/filecoin-project/go-state-types/builtin/v16/power" adt16 "github.com/filecoin-project/go-state-types/builtin/v16/util/adt" "github.com/filecoin-project/go-state-types/manifest" @@ -126,7 +127,7 @@ func (s *state16) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state16) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state16) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { return s.State.CollectEligibleClaims(s.store, cacheInOut) diff --git a/chain/actors/builtin/power/v17.go b/chain/actors/builtin/power/v17.go new file mode 100644 index 00000000000..0cd68e4cadf --- /dev/null +++ b/chain/actors/builtin/power/v17.go @@ -0,0 +1,236 @@ +package power + +import ( + "bytes" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + power17 "github.com/filecoin-project/go-state-types/builtin/v17/power" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" + "github.com/filecoin-project/lotus/chain/actors/builtin" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store) (State, error) { + out := state17{store: store} + + s, err := power17.ConstructState(store) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state17 struct { + power17.State + store adt.Store +} + +func (s *state17) TotalLocked() (abi.TokenAmount, error) { + return s.TotalPledgeCollateral, nil +} + +func (s *state17) TotalPower() (Claim, error) { + return Claim{ + RawBytePower: s.TotalRawBytePower, + QualityAdjPower: s.TotalQualityAdjPower, + }, nil +} + +// Committed power to the network. Includes miners below the minimum threshold. +func (s *state17) TotalCommitted() (Claim, error) { + return Claim{ + RawBytePower: s.TotalBytesCommitted, + QualityAdjPower: s.TotalQABytesCommitted, + }, nil +} + +func (s *state17) MinerPower(addr address.Address) (Claim, bool, error) { + claims, err := s.claims() + if err != nil { + return Claim{}, false, err + } + var claim power17.Claim + ok, err := claims.Get(abi.AddrKey(addr), &claim) + if err != nil { + return Claim{}, false, err + } + return Claim{ + RawBytePower: claim.RawBytePower, + QualityAdjPower: claim.QualityAdjPower, + }, ok, nil +} + +func (s *state17) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) { + return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a) +} + +func (s *state17) TotalPowerSmoothed() (builtin.FilterEstimate, error) { + return builtin.FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil +} + +func (s *state17) MinerCounts() (uint64, uint64, error) { + return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil +} + +func (s *state17) RampStartEpoch() int64 { + return s.State.RampStartEpoch +} + +func (s *state17) RampDurationEpochs() uint64 { + return s.State.RampDurationEpochs +} + +func (s *state17) ListAllMiners() ([]address.Address, error) { + claims, err := s.claims() + if err != nil { + return nil, err + } + + var miners []address.Address + err = claims.ForEach(nil, func(k string) error { + a, err := address.NewFromBytes([]byte(k)) + if err != nil { + return err + } + miners = append(miners, a) + return nil + }) + if err != nil { + return nil, err + } + + return miners, nil +} + +func (s *state17) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { + + return s.State.CollectEligibleClaims(s.store, cacheInOut) + +} + +func (s *state17) ForEachClaim(cb func(miner address.Address, claim Claim) error, onlyEligible bool) error { + claims, err := s.claims() + if err != nil { + return err + } + + var claim power17.Claim + return claims.ForEach(&claim, func(k string) error { + a, err := address.NewFromBytes([]byte(k)) + if err != nil { + return err + } + if !onlyEligible { + return cb(a, Claim{ + RawBytePower: claim.RawBytePower, + QualityAdjPower: claim.QualityAdjPower, + }) + } + + eligible, err := s.State.ClaimMeetsConsensusMinimums(&claim) + + if err != nil { + return fmt.Errorf("checking consensus minimums: %w", err) + } + if eligible { + return cb(a, Claim{ + RawBytePower: claim.RawBytePower, + QualityAdjPower: claim.QualityAdjPower, + }) + } + return nil + }) +} + +func (s *state17) ClaimsChanged(other State) (bool, error) { + other17, ok := other.(*state17) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.Claims.Equals(other17.State.Claims), nil +} + +func (s *state17) SetTotalQualityAdjPower(p abi.StoragePower) error { + s.State.TotalQualityAdjPower = p + return nil +} + +func (s *state17) SetTotalRawBytePower(p abi.StoragePower) error { + s.State.TotalRawBytePower = p + return nil +} + +func (s *state17) SetThisEpochQualityAdjPower(p abi.StoragePower) error { + s.State.ThisEpochQualityAdjPower = p + return nil +} + +func (s *state17) SetThisEpochRawBytePower(p abi.StoragePower) error { + s.State.ThisEpochRawBytePower = p + return nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) claims() (adt.Map, error) { + return adt17.AsMap(s.store, s.Claims, builtin17.DefaultHamtBitwidth) +} + +func (s *state17) decodeClaim(val *cbg.Deferred) (Claim, error) { + var ci power17.Claim + if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return Claim{}, err + } + return fromV17Claim(ci), nil +} + +func fromV17Claim(v17 power17.Claim) Claim { + return Claim{ + RawBytePower: v17.RawBytePower, + QualityAdjPower: v17.QualityAdjPower, + } +} + +func (s *state17) ActorKey() string { + return manifest.PowerKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/power/v2.go b/chain/actors/builtin/power/v2.go index a7c4438f618..891b0fbe90f 100644 --- a/chain/actors/builtin/power/v2.go +++ b/chain/actors/builtin/power/v2.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power" adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt" @@ -131,11 +131,11 @@ func (s *state2) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state2) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state2) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v3.go b/chain/actors/builtin/power/v3.go index 7587de74e08..1d9effdff17 100644 --- a/chain/actors/builtin/power/v3.go +++ b/chain/actors/builtin/power/v3.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin" power3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/power" @@ -127,11 +127,11 @@ func (s *state3) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state3) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state3) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v4.go b/chain/actors/builtin/power/v4.go index e6a3b616f63..916dfbc2560 100644 --- a/chain/actors/builtin/power/v4.go +++ b/chain/actors/builtin/power/v4.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin" power4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/power" @@ -127,11 +127,11 @@ func (s *state4) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state4) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state4) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v5.go b/chain/actors/builtin/power/v5.go index 91184fc302f..52b20a86128 100644 --- a/chain/actors/builtin/power/v5.go +++ b/chain/actors/builtin/power/v5.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin" power5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/power" @@ -127,11 +127,11 @@ func (s *state5) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state5) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state5) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v6.go b/chain/actors/builtin/power/v6.go index 04dbc631cd9..839c29d9ca6 100644 --- a/chain/actors/builtin/power/v6.go +++ b/chain/actors/builtin/power/v6.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin6 "github.com/filecoin-project/specs-actors/v6/actors/builtin" power6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/power" @@ -127,11 +127,11 @@ func (s *state6) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state6) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state6) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v7.go b/chain/actors/builtin/power/v7.go index 8750d452bd6..73309180ea1 100644 --- a/chain/actors/builtin/power/v7.go +++ b/chain/actors/builtin/power/v7.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin7 "github.com/filecoin-project/specs-actors/v7/actors/builtin" power7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/power" @@ -127,11 +127,11 @@ func (s *state7) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state7) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state7) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v8.go b/chain/actors/builtin/power/v8.go index 2a171e90185..20aa45c9805 100644 --- a/chain/actors/builtin/power/v8.go +++ b/chain/actors/builtin/power/v8.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" builtin8 "github.com/filecoin-project/go-state-types/builtin" power8 "github.com/filecoin-project/go-state-types/builtin/v8/power" adt8 "github.com/filecoin-project/go-state-types/builtin/v8/util/adt" @@ -127,11 +127,11 @@ func (s *state8) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state8) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state8) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/power/v9.go b/chain/actors/builtin/power/v9.go index 65070369b50..1c2c2ed7590 100644 --- a/chain/actors/builtin/power/v9.go +++ b/chain/actors/builtin/power/v9.go @@ -10,7 +10,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" builtin9 "github.com/filecoin-project/go-state-types/builtin" power9 "github.com/filecoin-project/go-state-types/builtin/v9/power" adt9 "github.com/filecoin-project/go-state-types/builtin/v9/util/adt" @@ -127,11 +127,11 @@ func (s *state9) ListAllMiners() ([]address.Address, error) { return miners, nil } -func (s *state9) CollectEligibleClaims(cacheInOut *builtin16.MapReduceCache) ([]builtin16.OwnedClaim, error) { +func (s *state9) CollectEligibleClaims(cacheInOut *builtin17.MapReduceCache) ([]builtin17.OwnedClaim, error) { - var res []builtin16.OwnedClaim + var res []builtin17.OwnedClaim err := s.ForEachClaim(func(miner address.Address, claim Claim) error { - res = append(res, builtin16.OwnedClaim{ + res = append(res, builtin17.OwnedClaim{ Address: miner, RawBytePower: claim.RawBytePower, QualityAdjPower: claim.QualityAdjPower, diff --git a/chain/actors/builtin/registry.go b/chain/actors/builtin/registry.go index f4a1276e385..68cc0995774 100644 --- a/chain/actors/builtin/registry.go +++ b/chain/actors/builtin/registry.go @@ -122,6 +122,22 @@ import ( reward16 "github.com/filecoin-project/go-state-types/builtin/v16/reward" system16 "github.com/filecoin-project/go-state-types/builtin/v16/system" verifreg16 "github.com/filecoin-project/go-state-types/builtin/v16/verifreg" + account17 "github.com/filecoin-project/go-state-types/builtin/v17/account" + cron17 "github.com/filecoin-project/go-state-types/builtin/v17/cron" + datacap17 "github.com/filecoin-project/go-state-types/builtin/v17/datacap" + eam17 "github.com/filecoin-project/go-state-types/builtin/v17/eam" + ethaccount17 "github.com/filecoin-project/go-state-types/builtin/v17/ethaccount" + evm17 "github.com/filecoin-project/go-state-types/builtin/v17/evm" + _init17 "github.com/filecoin-project/go-state-types/builtin/v17/init" + market17 "github.com/filecoin-project/go-state-types/builtin/v17/market" + miner17 "github.com/filecoin-project/go-state-types/builtin/v17/miner" + multisig17 "github.com/filecoin-project/go-state-types/builtin/v17/multisig" + paych17 "github.com/filecoin-project/go-state-types/builtin/v17/paych" + placeholder17 "github.com/filecoin-project/go-state-types/builtin/v17/placeholder" + power17 "github.com/filecoin-project/go-state-types/builtin/v17/power" + reward17 "github.com/filecoin-project/go-state-types/builtin/v17/reward" + system17 "github.com/filecoin-project/go-state-types/builtin/v17/system" + verifreg17 "github.com/filecoin-project/go-state-types/builtin/v17/verifreg" account8 "github.com/filecoin-project/go-state-types/builtin/v8/account" cron8 "github.com/filecoin-project/go-state-types/builtin/v8/cron" _init8 "github.com/filecoin-project/go-state-types/builtin/v8/init" @@ -1097,6 +1113,110 @@ func MakeRegistry(av actorstypes.Version) []RegistryEntry { } } + case actorstypes.Version17: + for key, codeID := range codeIDs { + switch key { + case manifest.AccountKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: account17.Methods, + state: new(account17.State), + }) + case manifest.CronKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: cron17.Methods, + state: new(cron17.State), + }) + case manifest.InitKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: _init17.Methods, + state: new(_init17.State), + }) + case manifest.MarketKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: market17.Methods, + state: new(market17.State), + }) + case manifest.MinerKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: miner17.Methods, + state: new(miner17.State), + }) + case manifest.MultisigKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: multisig17.Methods, + state: new(multisig17.State), + }) + case manifest.PaychKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: paych17.Methods, + state: new(paych17.State), + }) + case manifest.PowerKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: power17.Methods, + state: new(power17.State), + }) + case manifest.RewardKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: reward17.Methods, + state: new(reward17.State), + }) + case manifest.SystemKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: system17.Methods, + state: new(system17.State), + }) + case manifest.VerifregKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: verifreg17.Methods, + state: new(verifreg17.State), + }) + case manifest.DatacapKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: datacap17.Methods, + state: new(datacap17.State), + }) + + case manifest.EvmKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: evm17.Methods, + state: new(evm17.State), + }) + case manifest.EamKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: eam17.Methods, + state: nil, + }) + case manifest.PlaceholderKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: placeholder17.Methods, + state: nil, + }) + case manifest.EthAccountKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: ethaccount17.Methods, + state: nil, + }) + + } + } + default: panic("expected version v8 and up only, use specs-actors for v0-7") } diff --git a/chain/actors/builtin/reward/reward.go b/chain/actors/builtin/reward/reward.go index 4b176285c79..f2802f82872 100644 --- a/chain/actors/builtin/reward/reward.go +++ b/chain/actors/builtin/reward/reward.go @@ -6,7 +6,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -25,8 +25,8 @@ import ( ) var ( - Address = builtin16.RewardActorAddr - Methods = builtin16.MethodsReward + Address = builtin17.RewardActorAddr + Methods = builtin17.MethodsReward ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -64,6 +64,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -146,6 +149,9 @@ func MakeState(store adt.Store, av actorstypes.Version, currRealizedPower abi.St case actorstypes.Version16: return make16(store, currRealizedPower) + case actorstypes.Version17: + return make17(store, currRealizedPower) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -201,5 +207,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/reward/v17.go b/chain/actors/builtin/reward/v17.go new file mode 100644 index 00000000000..e8f85d192da --- /dev/null +++ b/chain/actors/builtin/reward/v17.go @@ -0,0 +1,122 @@ +package reward + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + miner17 "github.com/filecoin-project/go-state-types/builtin/v17/miner" + reward17 "github.com/filecoin-project/go-state-types/builtin/v17/reward" + smoothing17 "github.com/filecoin-project/go-state-types/builtin/v17/util/smoothing" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" + "github.com/filecoin-project/lotus/chain/actors/builtin" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, currRealizedPower abi.StoragePower) (State, error) { + out := state17{store: store} + out.State = *reward17.ConstructState(currRealizedPower) + return &out, nil +} + +type state17 struct { + reward17.State + store adt.Store +} + +func (s *state17) ThisEpochReward() (abi.TokenAmount, error) { + return s.State.ThisEpochReward, nil +} + +func (s *state17) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) { + + return builtin.FilterEstimate{ + PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate, + VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate, + }, nil + +} + +func (s *state17) ThisEpochBaselinePower() (abi.StoragePower, error) { + return s.State.ThisEpochBaselinePower, nil +} + +func (s *state17) TotalStoragePowerReward() (abi.TokenAmount, error) { + return s.State.TotalStoragePowerReward, nil +} + +func (s *state17) EffectiveBaselinePower() (abi.StoragePower, error) { + return s.State.EffectiveBaselinePower, nil +} + +func (s *state17) EffectiveNetworkTime() (abi.ChainEpoch, error) { + return s.State.EffectiveNetworkTime, nil +} + +func (s *state17) CumsumBaseline() (reward17.Spacetime, error) { + return s.State.CumsumBaseline, nil +} + +func (s *state17) CumsumRealized() (reward17.Spacetime, error) { + return s.State.CumsumRealized, nil +} + +func (s *state17) InitialPledgeForPower(qaPower abi.StoragePower, _ abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount, epochsSinceRampStart int64, rampDurationEpochs uint64) (abi.TokenAmount, error) { + return miner17.InitialPledgeForPower( + qaPower, + s.State.ThisEpochBaselinePower, + s.State.ThisEpochRewardSmoothed, + smoothing17.FilterEstimate{ + PositionEstimate: networkQAPower.PositionEstimate, + VelocityEstimate: networkQAPower.VelocityEstimate, + }, + circSupply, + epochsSinceRampStart, + rampDurationEpochs, + ), nil +} + +func (s *state17) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) { + return miner17.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed, + smoothing17.FilterEstimate{ + PositionEstimate: networkQAPower.PositionEstimate, + VelocityEstimate: networkQAPower.VelocityEstimate, + }, + sectorWeight), nil +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) ActorKey() string { + return manifest.RewardKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/system/system.go b/chain/actors/builtin/system/system.go index c677e3df573..3f54669eeac 100644 --- a/chain/actors/builtin/system/system.go +++ b/chain/actors/builtin/system/system.go @@ -5,7 +5,7 @@ import ( "golang.org/x/xerrors" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin" @@ -21,7 +21,7 @@ import ( ) var ( - Address = builtin16.SystemActorAddr + Address = builtin17.SystemActorAddr ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -59,6 +59,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -141,6 +144,9 @@ func MakeState(store adt.Store, av actorstypes.Version, builtinActors cid.Cid) ( case actorstypes.Version16: return make16(store, builtinActors) + case actorstypes.Version17: + return make17(store, builtinActors) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -173,5 +179,6 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/builtin/system/v17.go b/chain/actors/builtin/system/v17.go new file mode 100644 index 00000000000..c686860bf58 --- /dev/null +++ b/chain/actors/builtin/system/v17.go @@ -0,0 +1,72 @@ +package system + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + actorstypes "github.com/filecoin-project/go-state-types/actors" + system17 "github.com/filecoin-project/go-state-types/builtin/v17/system" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, builtinActors cid.Cid) (State, error) { + out := state17{store: store} + out.State = system17.State{ + BuiltinActors: builtinActors, + } + return &out, nil +} + +type state17 struct { + system17.State + store adt.Store +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) GetBuiltinActors() cid.Cid { + + return s.State.BuiltinActors + +} + +func (s *state17) SetBuiltinActors(c cid.Cid) error { + + s.State.BuiltinActors = c + return nil + +} + +func (s *state17) ActorKey() string { + return manifest.SystemKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/verifreg/v17.go b/chain/actors/builtin/verifreg/v17.go new file mode 100644 index 00000000000..e0816568c23 --- /dev/null +++ b/chain/actors/builtin/verifreg/v17.go @@ -0,0 +1,196 @@ +package verifreg + +import ( + "fmt" + + "github.com/ipfs/go-cid" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + "github.com/filecoin-project/go-state-types/big" + builtin17 "github.com/filecoin-project/go-state-types/builtin" + adt17 "github.com/filecoin-project/go-state-types/builtin/v17/util/adt" + verifreg17 "github.com/filecoin-project/go-state-types/builtin/v17/verifreg" + verifreg9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state17)(nil) + +func load17(store adt.Store, root cid.Cid) (State, error) { + out := state17{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make17(store adt.Store, rootKeyAddress address.Address) (State, error) { + out := state17{store: store} + + s, err := verifreg17.ConstructState(store, rootKeyAddress) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state17 struct { + verifreg17.State + store adt.Store +} + +func (s *state17) RootKey() (address.Address, error) { + return s.State.RootKey, nil +} + +func (s *state17) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) { + + return false, big.Zero(), xerrors.Errorf("unsupported in actors v17") + +} + +func (s *state17) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) { + return getDataCap(s.store, actors.Version17, s.verifiers, addr) +} + +func (s *state17) RemoveDataCapProposalID(verifier address.Address, client address.Address) (bool, uint64, error) { + return getRemoveDataCapProposalID(s.store, actors.Version17, s.removeDataCapProposalIDs, verifier, client) +} + +func (s *state17) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error { + return forEachCap(s.store, actors.Version17, s.verifiers, cb) +} + +func (s *state17) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error { + + return xerrors.Errorf("unsupported in actors v17") + +} + +func (s *state17) verifiedClients() (adt.Map, error) { + + return nil, xerrors.Errorf("unsupported in actors v17") + +} + +func (s *state17) verifiers() (adt.Map, error) { + return adt17.AsMap(s.store, s.Verifiers, builtin17.DefaultHamtBitwidth) +} + +func (s *state17) removeDataCapProposalIDs() (adt.Map, error) { + return adt17.AsMap(s.store, s.RemoveDataCapProposalIDs, builtin17.DefaultHamtBitwidth) +} + +func (s *state17) GetState() interface{} { + return &s.State +} + +func (s *state17) GetAllocation(clientIdAddr address.Address, allocationId verifreg9.AllocationId) (*Allocation, bool, error) { + + alloc, ok, err := s.FindAllocation(s.store, clientIdAddr, verifreg17.AllocationId(allocationId)) + return (*Allocation)(alloc), ok, err +} + +func (s *state17) GetAllocations(clientIdAddr address.Address) (map[AllocationId]Allocation, error) { + + v17Map, err := s.LoadAllocationsToMap(s.store, clientIdAddr) + + retMap := make(map[AllocationId]Allocation, len(v17Map)) + for k, v := range v17Map { + retMap[AllocationId(k)] = Allocation(v) + } + + return retMap, err + +} + +func (s *state17) GetAllAllocations() (map[AllocationId]Allocation, error) { + + v17Map, err := s.State.GetAllAllocations(s.store) + + retMap := make(map[AllocationId]Allocation, len(v17Map)) + for k, v := range v17Map { + retMap[AllocationId(k)] = Allocation(v) + } + + return retMap, err + +} + +func (s *state17) GetClaim(providerIdAddr address.Address, claimId verifreg9.ClaimId) (*Claim, bool, error) { + + claim, ok, err := s.FindClaim(s.store, providerIdAddr, verifreg17.ClaimId(claimId)) + return (*Claim)(claim), ok, err + +} + +func (s *state17) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, error) { + + v17Map, err := s.LoadClaimsToMap(s.store, providerIdAddr) + + retMap := make(map[ClaimId]Claim, len(v17Map)) + for k, v := range v17Map { + retMap[ClaimId(k)] = Claim(v) + } + + return retMap, err + +} + +func (s *state17) GetAllClaims() (map[ClaimId]Claim, error) { + + v17Map, err := s.State.GetAllClaims(s.store) + + retMap := make(map[ClaimId]Claim, len(v17Map)) + for k, v := range v17Map { + retMap[ClaimId(k)] = Claim(v) + } + + return retMap, err + +} + +func (s *state17) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) { + + v17Map, err := s.LoadClaimsToMap(s.store, providerIdAddr) + + retMap := make(map[abi.SectorNumber][]ClaimId) + for k, v := range v17Map { + claims, ok := retMap[v.Sector] + if !ok { + retMap[v.Sector] = []ClaimId{ClaimId(k)} + } else { + retMap[v.Sector] = append(claims, ClaimId(k)) + } + } + + return retMap, err + +} + +func (s *state17) ActorKey() string { + return manifest.VerifregKey +} + +func (s *state17) ActorVersion() actorstypes.Version { + return actorstypes.Version17 +} + +func (s *state17) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/verifreg/verifreg.go b/chain/actors/builtin/verifreg/verifreg.go index 779c1bd292f..c5a238556ad 100644 --- a/chain/actors/builtin/verifreg/verifreg.go +++ b/chain/actors/builtin/verifreg/verifreg.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" verifregtypes12 "github.com/filecoin-project/go-state-types/builtin/v12/verifreg" verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" "github.com/filecoin-project/go-state-types/cbor" @@ -26,8 +26,8 @@ import ( ) var ( - Address = builtin16.VerifiedRegistryActorAddr - Methods = builtin16.MethodsVerifiedRegistry + Address = builtin17.VerifiedRegistryActorAddr + Methods = builtin17.MethodsVerifiedRegistry ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -65,6 +65,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version16: return load16(store, act.Head) + case actorstypes.Version17: + return load17(store, act.Head) + } } @@ -147,6 +150,9 @@ func MakeState(store adt.Store, av actorstypes.Version, rootKeyAddress address.A case actorstypes.Version16: return make16(store, rootKeyAddress) + case actorstypes.Version17: + return make17(store, rootKeyAddress) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -192,6 +198,7 @@ func AllCodes() []cid.Cid { (&state14{}).Code(), (&state15{}).Code(), (&state16{}).Code(), + (&state17{}).Code(), } } diff --git a/chain/actors/policy/policy.go b/chain/actors/policy/policy.go index b072cbcdf1e..3eb74dae3df 100644 --- a/chain/actors/policy/policy.go +++ b/chain/actors/policy/policy.go @@ -13,6 +13,7 @@ import ( builtin14 "github.com/filecoin-project/go-state-types/builtin" builtin15 "github.com/filecoin-project/go-state-types/builtin" builtin16 "github.com/filecoin-project/go-state-types/builtin" + builtin17 "github.com/filecoin-project/go-state-types/builtin" builtin8 "github.com/filecoin-project/go-state-types/builtin" builtin9 "github.com/filecoin-project/go-state-types/builtin" market10 "github.com/filecoin-project/go-state-types/builtin/v10/market" @@ -35,8 +36,11 @@ import ( verifreg15 "github.com/filecoin-project/go-state-types/builtin/v15/verifreg" market16 "github.com/filecoin-project/go-state-types/builtin/v16/market" miner16 "github.com/filecoin-project/go-state-types/builtin/v16/miner" - paych16 "github.com/filecoin-project/go-state-types/builtin/v16/paych" verifreg16 "github.com/filecoin-project/go-state-types/builtin/v16/verifreg" + market17 "github.com/filecoin-project/go-state-types/builtin/v17/market" + miner17 "github.com/filecoin-project/go-state-types/builtin/v17/miner" + paych17 "github.com/filecoin-project/go-state-types/builtin/v17/paych" + verifreg17 "github.com/filecoin-project/go-state-types/builtin/v17/verifreg" market8 "github.com/filecoin-project/go-state-types/builtin/v8/market" miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" verifreg8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg" @@ -75,15 +79,15 @@ import ( ) const ( - ChainFinality = miner16.ChainFinality + ChainFinality = miner17.ChainFinality SealRandomnessLookback = ChainFinality - PaychSettleDelay = paych16.SettleDelay - MaxPreCommitRandomnessLookback = builtin16.EpochsInDay + SealRandomnessLookback + PaychSettleDelay = paych17.SettleDelay + MaxPreCommitRandomnessLookback = builtin17.EpochsInDay + SealRandomnessLookback DeclarationsMax = 3000 ) var ( - MarketDefaultAllocationTermBuffer = market16.MarketDefaultAllocationTermBuffer + MarketDefaultAllocationTermBuffer = market17.MarketDefaultAllocationTermBuffer ) // SetSupportedProofTypes sets supported proof types, across all actor versions. @@ -206,11 +210,13 @@ func SetPreCommitChallengeDelay(delay abi.ChainEpoch) { miner16.PreCommitChallengeDelay = delay + miner17.PreCommitChallengeDelay = delay + } func GetPreCommitChallengeDelay() abi.ChainEpoch { // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay. - return miner16.PreCommitChallengeDelay + return miner17.PreCommitChallengeDelay } // SetConsensusMinerMinPower sets the minimum power of an individual miner must @@ -280,6 +286,10 @@ func SetConsensusMinerMinPower(p abi.StoragePower) { policy.ConsensusMinerMinPower = p } + for _, policy := range builtin17.PoStProofPolicies { + policy.ConsensusMinerMinPower = p + } + } // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should @@ -318,6 +328,8 @@ func SetMinVerifiedDealSize(size abi.StoragePower) { verifreg16.MinVerifiedDealSize = size + verifreg17.MinVerifiedDealSize = size + } func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProof) (abi.ChainEpoch, error) { @@ -387,6 +399,10 @@ func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProo return miner16.MaxProveCommitDuration[t], nil + case actorstypes.Version17: + + return miner17.MaxProveCommitDuration[t], nil + default: return 0, xerrors.Errorf("unsupported actors version") } @@ -472,6 +488,11 @@ func SetProviderCollateralSupplyTarget(num, denom big.Int) { Denominator: denom, } + market17.ProviderCollateralSupplyTarget = builtin17.BigFrac{ + Numerator: num, + Denominator: denom, + } + } func DealProviderCollateralBounds( @@ -565,13 +586,18 @@ func DealProviderCollateralBounds( min, max := market16.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) return min, max, nil + case actorstypes.Version17: + + min, max := market17.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + return min, max, nil + default: return big.Zero(), big.Zero(), xerrors.Errorf("unsupported actors version") } } func DealDurationBounds(pieceSize abi.PaddedPieceSize) (min, max abi.ChainEpoch) { - return market16.DealDurationBounds(pieceSize) + return market17.DealDurationBounds(pieceSize) } // SetWPoStChallengeWindow sets the challenge window and scales the proving period to match (such @@ -682,6 +708,13 @@ func SetWPoStChallengeWindow(period abi.ChainEpoch) { // scale it if we're scaling the challenge period. miner16.WPoStDisputeWindow = period * 30 + miner17.WPoStChallengeWindow = period + miner17.WPoStProvingPeriod = period * abi.ChainEpoch(miner17.WPoStPeriodDeadlines) + + // by default, this is 2x finality which is 30 periods. + // scale it if we're scaling the challenge period. + miner17.WPoStDisputeWindow = period * 30 + } func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch { @@ -748,6 +781,9 @@ func GetMaxSectorExpirationExtension(nv network.Version) (abi.ChainEpoch, error) case actorstypes.Version16: return miner16.MaxSectorExpirationExtension, nil + case actorstypes.Version17: + return miner17.MaxSectorExpirationExtension, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -755,11 +791,11 @@ func GetMaxSectorExpirationExtension(nv network.Version) (abi.ChainEpoch, error) } func GetMinSectorExpiration() abi.ChainEpoch { - return miner16.MinSectorExpiration + return miner17.MinSectorExpiration } func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, error) { - sectorsPerPart, err := builtin16.PoStProofWindowPoStPartitionSectors(p) + sectorsPerPart, err := builtin17.PoStProofWindowPoStPartitionSectors(p) if err != nil { return 0, err } @@ -768,7 +804,7 @@ func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, e return 0, err } - return min(miner16.PoStedPartitionsMax, int(uint64(maxSectors)/sectorsPerPart)), nil + return min(miner17.PoStedPartitionsMax, int(uint64(maxSectors)/sectorsPerPart)), nil } func GetDefaultAggregationProof() abi.RegisteredAggregationProof { @@ -780,7 +816,7 @@ func GetSectorMaxLifetime(proof abi.RegisteredSealProof, nwVer network.Version) return builtin4.SealProofPoliciesV0[proof].SectorMaxLifetime } - return builtin16.SealProofPoliciesV11[proof].SectorMaxLifetime + return builtin17.SealProofPoliciesV11[proof].SectorMaxLifetime } func GetAddressedSectorsMax(nwVer network.Version) (int, error) { @@ -838,6 +874,9 @@ func GetAddressedSectorsMax(nwVer network.Version) (int, error) { case actorstypes.Version16: return miner16.AddressedSectorsMax, nil + case actorstypes.Version17: + return miner17.AddressedSectorsMax, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -881,6 +920,8 @@ func AggregatePreCommitNetworkFee(nwVer network.Version, aggregateSize int, base return miner15.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil case actorstypes.Version16: return big.Zero(), nil + case actorstypes.Version17: + return big.Zero(), nil default: return big.Zero(), xerrors.Errorf("unsupported network version") } diff --git a/chain/actors/version.go b/chain/actors/version.go index d1cb9ac3d46..3e9265275c5 100644 --- a/chain/actors/version.go +++ b/chain/actors/version.go @@ -14,9 +14,9 @@ const ({{range .actorVersions}} /* inline-gen start */ -var LatestVersion = 16 +var LatestVersion = 17 -var Versions = []int{0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} +var Versions = []int{0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17} const ( Version0 Version = 0 @@ -35,6 +35,7 @@ const ( Version14 Version = 14 Version15 Version = 15 Version16 Version = 16 + Version17 Version = 17 ) /* inline-gen end */ diff --git a/chain/consensus/compute_state.go b/chain/consensus/compute_state.go index bb52b4b3671..f79976c136d 100644 --- a/chain/consensus/compute_state.go +++ b/chain/consensus/compute_state.go @@ -57,6 +57,7 @@ func NewActorRegistry() *vm.ActorRegistry { inv.Register(actorstypes.Version14, vm.ActorsVersionPredicate(actorstypes.Version14), builtin.MakeRegistry(actorstypes.Version14)) inv.Register(actorstypes.Version15, vm.ActorsVersionPredicate(actorstypes.Version15), builtin.MakeRegistry(actorstypes.Version15)) inv.Register(actorstypes.Version16, vm.ActorsVersionPredicate(actorstypes.Version16), builtin.MakeRegistry(actorstypes.Version16)) + inv.Register(actorstypes.Version17, vm.ActorsVersionPredicate(actorstypes.Version17), builtin.MakeRegistry(actorstypes.Version17)) return inv } diff --git a/chain/consensus/filcns/upgrades.go b/chain/consensus/filcns/upgrades.go index 9971b8f38af..256359982e6 100644 --- a/chain/consensus/filcns/upgrades.go +++ b/chain/consensus/filcns/upgrades.go @@ -32,6 +32,7 @@ import ( nv23 "github.com/filecoin-project/go-state-types/builtin/v14/migration" nv24 "github.com/filecoin-project/go-state-types/builtin/v15/migration" nv25 "github.com/filecoin-project/go-state-types/builtin/v16/migration" + nv27 "github.com/filecoin-project/go-state-types/builtin/v17/migration" nv17 "github.com/filecoin-project/go-state-types/builtin/v9/migration" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/go-state-types/migration" @@ -349,6 +350,17 @@ func DefaultUpgradeSchedule() stmgr.UpgradeSchedule { Height: buildconstants.UpgradeTockFixHeight, Network: network.Version26, Migration: UpgradeActorsV16Fix, + }, { + Height: buildconstants.UpgradeXxHeight, + Network: network.Version27, + Migration: UpgradeActorsV17, + PreMigrations: []stmgr.PreMigration{{ + PreMigration: PreUpgradeActorsV17, + StartWithin: 120, + DontStartWithin: 15, + StopWithin: 10, + }}, + Expensive: true, }, } @@ -3058,17 +3070,28 @@ func UpgradeActorsV16Fix( return xerrors.Errorf("mismatched head for actor %s", a) } - // Check that the actor code has changed to the new expected value; work backward by getting the - // actor name from the new code CID. - if actorName, version, ok := actors.GetActorMetaByCode(outActor.Code); !ok { - return xerrors.Errorf("failed to get actor meta for code %s", outActor.Code) - } else if version != actorstypes.Version16 { - return xerrors.Errorf("unexpected actor version for %s: %d", actorName, version) - } else if oldCode, ok := v1600metadata.Actors[actorName]; !ok { - return xerrors.Errorf("missing actor %s in v16.0.0 metadata", actorName) - } else if oldCode != inActor.Code { - return xerrors.Errorf("unexpected actor code for %s: %s != %s", actorName, oldCode, outActor.Code) - } + /* + TODO: This code block was skipped while preparing the nv27 network skeleton: + https://github.com/filecoin-project/lotus/pull/13125 + The problem encountered here is that the initial v17 actors bundle for the nv27 skeleton was + identical to the v16 bundle (a normal part of skeleton setup), so calls to + actors.GetActorMetaByCode for v16 CIDs would return 17 as the version, and the second + assertion below here fails. This ought to be solved when a new actors bundle is introduced and + this block can be re-enabled. However, this is also not critical code, and was only used on + calibnet, so 🤷. + + // Check that the actor code has changed to the new expected value; work backward by getting the + // actor name from the new code CID. + if actorName, version, ok := actors.GetActorMetaByCode(outActor.Code); !ok { + return xerrors.Errorf("failed to get actor meta for code %s", outActor.Code) + } else if version != actorstypes.Version16 { + return xerrors.Errorf("unexpected actor version for %s: %d", actorName, version) + } else if oldCode, ok := v1600metadata.Actors[actorName]; !ok { + return xerrors.Errorf("missing actor %s in v16.0.0 metadata", actorName) + } else if oldCode != inActor.Code { + return xerrors.Errorf("unexpected actor code for %s: %s != %s", actorName, oldCode, outActor.Code) + } + */ return nil }) @@ -3085,6 +3108,119 @@ func UpgradeActorsV16Fix( return newRoot, nil } +func PreUpgradeActorsV17(ctx context.Context, sm *stmgr.StateManager, cache stmgr.MigrationCache, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) error { + // Use half the CPUs for pre-migration, but leave at least 3. + workerCount := MigrationMaxWorkerCount + if workerCount <= 4 { + workerCount = 1 + } else { + workerCount /= 2 + } + + lbts, lbRoot, err := stmgr.GetLookbackTipSetForRound(ctx, sm, ts, epoch) + if err != nil { + return xerrors.Errorf("error getting lookback ts for premigration: %w", err) + } + + logPeriod, err := getMigrationProgressLogPeriod() + if err != nil { + return xerrors.Errorf("error getting progress log period: %w", err) + } + + config := migration.Config{ + MaxWorkers: uint(workerCount), + ProgressLogPeriod: logPeriod, + } + + _, err = upgradeActorsV17Common(ctx, sm, cache, lbRoot, epoch, lbts, config) + return err +} + +func UpgradeActorsV17(ctx context.Context, sm *stmgr.StateManager, cache stmgr.MigrationCache, cb stmgr.ExecMonitor, + root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) { + // Use all the CPUs except 2. + workerCount := MigrationMaxWorkerCount - 3 + if workerCount <= 0 { + workerCount = 1 + } + + logPeriod, err := getMigrationProgressLogPeriod() + if err != nil { + return cid.Undef, xerrors.Errorf("error getting progress log period: %w", err) + } + + config := migration.Config{ + MaxWorkers: uint(workerCount), + JobQueueSize: 1000, + ResultQueueSize: 100, + ProgressLogPeriod: logPeriod, + } + newRoot, err := upgradeActorsV17Common(ctx, sm, cache, root, epoch, ts, config) + if err != nil { + return cid.Undef, xerrors.Errorf("migrating actors v17 state: %w", err) + } + return newRoot, nil +} + +func upgradeActorsV17Common( + ctx context.Context, sm *stmgr.StateManager, cache stmgr.MigrationCache, + root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet, + config migration.Config, +) (cid.Cid, error) { + writeStore := blockstore.NewAutobatch(ctx, sm.ChainStore().StateBlockstore(), units.GiB/4) + adtStore := store.ActorStore(ctx, writeStore) + // ensure that the manifest is loaded in the blockstore + if err := bundle.LoadBundles(ctx, writeStore, actorstypes.Version17); err != nil { + return cid.Undef, xerrors.Errorf("failed to load manifest bundle: %w", err) + } + + // Load the state root. + var stateRoot types.StateRoot + if err := adtStore.Get(ctx, root, &stateRoot); err != nil { + return cid.Undef, xerrors.Errorf("failed to decode state root: %w", err) + } + + if stateRoot.Version != types.StateTreeVersion5 { + return cid.Undef, xerrors.Errorf( + "expected state root version 5 for actors v17 upgrade, got %d", + stateRoot.Version, + ) + } + + manifest, ok := actors.GetManifest(actorstypes.Version17) + if !ok { + return cid.Undef, xerrors.Errorf("no manifest CID for v17 upgrade") + } + + // Perform the migration + newHamtRoot, err := nv27.MigrateStateTree(ctx, adtStore, manifest, stateRoot.Actors, epoch, config, + migrationLogger{}, cache) + if err != nil { + return cid.Undef, xerrors.Errorf("upgrading to actors v17: %w", err) + } + + // Persist the result. + newRoot, err := adtStore.Put(ctx, &types.StateRoot{ + Version: types.StateTreeVersion5, + Actors: newHamtRoot, + Info: stateRoot.Info, + }) + if err != nil { + return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err) + } + + // Persists the new tree and shuts down the flush worker + if err := writeStore.Flush(ctx); err != nil { + return cid.Undef, xerrors.Errorf("writeStore flush failed: %w", err) + } + + if err := writeStore.Shutdown(ctx); err != nil { + return cid.Undef, xerrors.Errorf("writeStore shutdown failed: %w", err) + } + + return newRoot, nil +} + //////////////////// // Example upgrade function if upgrade requires only code changes diff --git a/chain/state/statetree.go b/chain/state/statetree.go index ec289dd13ab..85f02a495ac 100644 --- a/chain/state/statetree.go +++ b/chain/state/statetree.go @@ -157,7 +157,7 @@ func VersionForNetwork(ver network.Version) (types.StateTreeVersion, error) { case network.Version13, network.Version14, network.Version15, network.Version16, network.Version17: return types.StateTreeVersion4, nil - case network.Version18, network.Version19, network.Version20, network.Version21, network.Version22, network.Version23, network.Version24, network.Version25: + case network.Version18, network.Version19, network.Version20, network.Version21, network.Version22, network.Version23, network.Version24, network.Version25, network.Version26, network.Version27: return types.StateTreeVersion5, nil default: diff --git a/cmd/lotus-shed/invariants.go b/cmd/lotus-shed/invariants.go index bc994bbe633..0678c9c44b9 100644 --- a/cmd/lotus-shed/invariants.go +++ b/cmd/lotus-shed/invariants.go @@ -22,6 +22,7 @@ import ( v14 "github.com/filecoin-project/go-state-types/builtin/v14" v15 "github.com/filecoin-project/go-state-types/builtin/v15" v16 "github.com/filecoin-project/go-state-types/builtin/v16" + v17 "github.com/filecoin-project/go-state-types/builtin/v17" v8 "github.com/filecoin-project/go-state-types/builtin/v8" v9 "github.com/filecoin-project/go-state-types/builtin/v9" @@ -209,6 +210,11 @@ var invariantsCmd = &cli.Command{ if err != nil { return xerrors.Errorf("checking state invariants: %w", err) } + case actorstypes.Version17: + messages, err = v17.CheckStateInvariants(actorTree, abi.ChainEpoch(epoch), actorCodeCids) + if err != nil { + return xerrors.Errorf("checking state invariants: %w", err) + } default: return xerrors.Errorf("unsupported actor version: %v", av) } diff --git a/cmd/lotus-shed/migrations.go b/cmd/lotus-shed/migrations.go index 3ad7298fd4a..015eef5902e 100644 --- a/cmd/lotus-shed/migrations.go +++ b/cmd/lotus-shed/migrations.go @@ -39,6 +39,7 @@ import ( v14 "github.com/filecoin-project/go-state-types/builtin/v14" v15 "github.com/filecoin-project/go-state-types/builtin/v15" v16 "github.com/filecoin-project/go-state-types/builtin/v16" + v17 "github.com/filecoin-project/go-state-types/builtin/v17" market8 "github.com/filecoin-project/go-state-types/builtin/v8/market" adt8 "github.com/filecoin-project/go-state-types/builtin/v8/util/adt" v9 "github.com/filecoin-project/go-state-types/builtin/v9" @@ -313,6 +314,8 @@ func getMigrationFuncsForNetwork(nv network.Version) (UpgradeActorsFunc, PreUpgr return filcns.UpgradeActorsV15, filcns.PreUpgradeActorsV15, checkNv24Invariants, nil case network.Version25: return filcns.UpgradeActorsV16, filcns.PreUpgradeActorsV16, checkNv25Invariants, nil + case network.Version27: + return filcns.UpgradeActorsV17, filcns.PreUpgradeActorsV17, checkNv27Invariants, nil default: return nil, nil, nil, xerrors.Errorf("migration not implemented for nv%d", nv) } @@ -650,6 +653,39 @@ func printMarketActorDiff(ctx context.Context, cst *cbornode.BasicIpldStore, nv return nil } +func checkNv27Invariants(ctx context.Context, oldStateRootCid cid.Cid, newStateRootCid cid.Cid, bs blockstore.Blockstore, epoch abi.ChainEpoch) error { + + actorStore := store.ActorStore(ctx, bs) + startTime := time.Now() + + // Load the new state root. + var newStateRoot types.StateRoot + if err := actorStore.Get(ctx, newStateRootCid, &newStateRoot); err != nil { + return xerrors.Errorf("failed to decode state root: %w", err) + } + + actorCodeCids, err := actors.GetActorCodeIDs(actorstypes.Version17) + if err != nil { + return err + } + newActorTree, err := builtin.LoadTree(actorStore, newStateRoot.Actors) + if err != nil { + return err + } + messages, err := v17.CheckStateInvariants(newActorTree, epoch, actorCodeCids) + if err != nil { + return xerrors.Errorf("checking state invariants: %w", err) + } + + for _, message := range messages.Messages() { + fmt.Println("got the following error: ", message) + } + + fmt.Println("completed invariant checks, took ", time.Since(startTime)) + + return nil +} + func checkNv25Invariants(ctx context.Context, oldStateRootCid cid.Cid, newStateRootCid cid.Cid, bs blockstore.Blockstore, epoch abi.ChainEpoch) error { actorStore := store.ActorStore(ctx, bs) diff --git a/documentation/en/api-v0-methods-miner.md b/documentation/en/api-v0-methods-miner.md index 70ded7b0076..4cf4dedc105 100644 --- a/documentation/en/api-v0-methods-miner.md +++ b/documentation/en/api-v0-methods-miner.md @@ -401,7 +401,7 @@ Inputs: ], "Bw==", 10101, - 25 + 27 ] ``` diff --git a/documentation/en/api-v0-methods.md b/documentation/en/api-v0-methods.md index 618ac80c2bc..5db8374ac8c 100644 --- a/documentation/en/api-v0-methods.md +++ b/documentation/en/api-v0-methods.md @@ -4040,7 +4040,7 @@ Perms: read Inputs: ```json [ - 25 + 27 ] ``` @@ -4055,7 +4055,7 @@ Perms: read Inputs: ```json [ - 25 + 27 ] ``` @@ -4916,7 +4916,8 @@ Response: "UpgradeWaffleHeight": 10101, "UpgradeTuktukHeight": 10101, "UpgradeTeepHeight": 10101, - "UpgradeTockHeight": 10101 + "UpgradeTockHeight": 10101, + "UpgradeXxHeight": 10101 }, "Eip155ChainID": 123, "GenesisTimestamp": 42 @@ -5840,7 +5841,7 @@ Inputs: ] ``` -Response: `25` +Response: `27` ### StateReadState StateReadState returns the indicated actor's state. diff --git a/documentation/en/api-v1-unstable-methods.md b/documentation/en/api-v1-unstable-methods.md index 05737400a3a..a39b39bca17 100644 --- a/documentation/en/api-v1-unstable-methods.md +++ b/documentation/en/api-v1-unstable-methods.md @@ -6381,7 +6381,7 @@ Perms: read Inputs: ```json [ - 25 + 27 ] ``` @@ -6396,7 +6396,7 @@ Perms: read Inputs: ```json [ - 25 + 27 ] ``` @@ -7358,7 +7358,8 @@ Response: "UpgradeWaffleHeight": 10101, "UpgradeTuktukHeight": 10101, "UpgradeTeepHeight": 10101, - "UpgradeTockHeight": 10101 + "UpgradeTockHeight": 10101, + "UpgradeXxHeight": 10101 }, "Eip155ChainID": 123, "GenesisTimestamp": 42 @@ -8406,7 +8407,7 @@ Inputs: ] ``` -Response: `25` +Response: `27` ### StateReadState StateReadState returns the indicated actor's state. diff --git a/gen/inlinegen-data.json b/gen/inlinegen-data.json index e6224bcfbd4..badd32198d0 100644 --- a/gen/inlinegen-data.json +++ b/gen/inlinegen-data.json @@ -1,7 +1,7 @@ { - "actorVersions": [0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], - "latestActorsVersion": 16, + "actorVersions": [0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], + "latestActorsVersion": 17, - "networkVersions": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], - "latestNetworkVersion": 25 + "networkVersions": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], + "latestNetworkVersion": 27 } diff --git a/go.mod b/go.mod index 4cb0e45b011..8a4fb6f45b6 100644 --- a/go.mod +++ b/go.mod @@ -38,7 +38,7 @@ require ( github.com/elastic/gosigar v0.14.3 github.com/etclabscore/go-openrpc-reflect v0.0.36 github.com/fatih/color v1.18.0 - github.com/filecoin-project/filecoin-ffi v1.32.0 + github.com/filecoin-project/filecoin-ffi v1.33.1-dev // dependency-check-ignore: nv27 skeleton github.com/filecoin-project/go-address v1.2.0 github.com/filecoin-project/go-amt-ipld/v4 v4.4.0 github.com/filecoin-project/go-bitfield v0.2.4 diff --git a/itests/kit/ensemble_opts_nv.go b/itests/kit/ensemble_opts_nv.go index 8cdf1a635c6..ab77218bacb 100644 --- a/itests/kit/ensemble_opts_nv.go +++ b/itests/kit/ensemble_opts_nv.go @@ -35,12 +35,12 @@ func LatestActorsAt(upgradeHeight abi.ChainEpoch) EnsembleOpt { }) /* inline-gen start */ return UpgradeSchedule(stmgr.Upgrade{ - Network: network.Version24, + Network: network.Version26, Height: -1, }, stmgr.Upgrade{ - Network: network.Version25, + Network: network.Version27, Height: upgradeHeight, - Migration: filcns.UpgradeActorsV16, + Migration: filcns.UpgradeActorsV17, }) /* inline-gen end */ } diff --git a/node/impl/full/state.go b/node/impl/full/state.go index f3f0df63d2a..b1bb4f2e77f 100644 --- a/node/impl/full/state.go +++ b/node/impl/full/state.go @@ -2094,6 +2094,7 @@ func (a *StateAPI) StateGetNetworkParams(ctx context.Context) (*api.NetworkParam UpgradeTuktukHeight: buildconstants.UpgradeTuktukHeight, UpgradeTeepHeight: buildconstants.UpgradeTeepHeight, UpgradeTockHeight: buildconstants.UpgradeTockHeight, + UpgradeXxHeight: buildconstants.UpgradeXxHeight, }, }, nil } diff --git a/storage/pipeline/mocks/mocks.go b/storage/pipeline/mocks/mocks.go index c24b9ff4e30..dbb889855c0 100644 --- a/storage/pipeline/mocks/mocks.go +++ b/storage/pipeline/mocks/mocks.go @@ -16,7 +16,7 @@ import ( bitfield "github.com/filecoin-project/go-bitfield" abi "github.com/filecoin-project/go-state-types/abi" big "github.com/filecoin-project/go-state-types/big" - miner "github.com/filecoin-project/go-state-types/builtin/v16/miner" + miner "github.com/filecoin-project/go-state-types/builtin/v17/miner" miner0 "github.com/filecoin-project/go-state-types/builtin/v9/miner" verifreg "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" crypto "github.com/filecoin-project/go-state-types/crypto"