diff --git a/.circleci/config.yml b/.circleci/config.yml index d3c160cd5..b2b4720ca 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -800,6 +800,11 @@ workflows: suite: itest-migration_nv18 target: "./itests/migration_nv18_test.go" + - test: + name: test-itest-migration_nv19 + suite: itest-migration_nv19 + target: "./itests/migration_nv19_test.go" + - test: name: test-itest-mpool_msg_uuid suite: itest-mpool_msg_uuid diff --git a/build/actors/v11.tar.zst b/build/actors/v11.tar.zst new file mode 100644 index 000000000..1dc1de99b Binary files /dev/null and b/build/actors/v11.tar.zst differ diff --git a/build/builtin_actors_gen.go b/build/builtin_actors_gen.go index 3ae845c16..c230eea7b 100644 --- a/build/builtin_actors_gen.go +++ b/build/builtin_actors_gen.go @@ -72,6 +72,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzacebe6j2ius6clbbr7dypsg54jzmn5xablzunph7ebedw6yhwla4cj2"), "verifiedregistry": MustParseCid("bafk2bzacebu4joy25gneu2qv3qfm3ktakzalndjrbhekeqrqk3zhotv6nyy2g"), }, +}, { + Network: "butterflynet", + Version: 11, + ManifestCid: MustParseCid("bafy2bzaceba5qgs4z3imhlxwds5vamahngatvuuglbv5yl3ftfiosj6ud5chs"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzacebd5zetyjtragjwrv2nqktct6u2pmsi4eifbanovxohx3a7lszjxi"), + "cron": MustParseCid("bafk2bzacecrszortqkc7har77ssgajglymv6ftrqvmdko5h2yqqh5k2qospl2"), + "datacap": MustParseCid("bafk2bzacecapjnxnyw4talwqv5ajbtbkzmzqiosztj5cb3sortyp73ndjl76e"), + "eam": MustParseCid("bafk2bzacecflry2dyjqj6fhpovkbcbei377zabectznuxsf6bxggsve7bsxga"), + "ethaccount": MustParseCid("bafk2bzacedl4pmkfxkzoqajs6im3ranmopozsmxjcxsnk3kwvd3vv7mfwwrf4"), + "evm": MustParseCid("bafk2bzacebgzvmvwv7rsnnhp3zhqbiqkumvyrc7pazfovpptgpgtqkalrli74"), + "init": MustParseCid("bafk2bzacecbxp66q3ytjkg37nyv4rmzezbfaigvx4i5yhvqbm5gg4amjeaias"), + "multisig": MustParseCid("bafk2bzacecjltag3mn75dsnmrmopjow27buxqhabissowayqlmavrcfetqswc"), + "paymentchannel": MustParseCid("bafk2bzacednzxg263eqbl2imwz3uhujov63tjkffieyl4hl3dhrgxyhwep6hc"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacectp23cxsbbdrr3uggnw7f263qll5wkkfzqhn5yq37ae2ehdjdzri"), + "storagemarket": MustParseCid("bafk2bzacea45ko3ezkpeujsniovncwnizc4wsxd7kyckskhs7gvzwthzb2mqe"), + "storageminer": MustParseCid("bafk2bzaced74qthwrl3gahcf7o3vrdrodbcqhlplh6fykbgy5sd2iyouhq44c"), + "storagepower": MustParseCid("bafk2bzaceduksv6wqthr5fgp7mx5prv6gzul2oozf3svrjbuggc4bgokdxgfy"), + "system": MustParseCid("bafk2bzacebe6j2ius6clbbr7dypsg54jzmn5xablzunph7ebedw6yhwla4cj2"), + "verifiedregistry": MustParseCid("bafk2bzacebu4joy25gneu2qv3qfm3ktakzalndjrbhekeqrqk3zhotv6nyy2g"), + }, }, { Network: "calibrationnet", Version: 8, @@ -129,6 +151,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzacednnhpk5kno67bkomiohweglryqvgnqz4cbks6eomidai677fat5w"), "verifiedregistry": MustParseCid("bafk2bzaceawecz24xbz7robn7ck7k2mprkewvup6q346whbfiybcrvy63qcsa"), }, +}, { + Network: "calibrationnet", + Version: 11, + ManifestCid: MustParseCid("bafy2bzacedaj2jtodzct5b2ijrqkg4vabnhp6d5rmbscmpl5273b6uxrynn3w"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzacea7zmrdz2rjbzlbmrmx3ko6pm3cbyqxxgogiqldsccbqffuok7m6s"), + "cron": MustParseCid("bafk2bzacec7bxugi7ouh75nglycy7qwdq7e2hnku3w6yafq4fwdwvvq2mtrl2"), + "datacap": MustParseCid("bafk2bzacedii4stmlo3ccdff7eevcolmgnuxy5ftkzbzwtkqa4iinlfzq4mei"), + "eam": MustParseCid("bafk2bzacedqvcmlki7exa3dw4oxdaecuekthl4i2hxrr2lzi5eiiev7udmpuk"), + "ethaccount": MustParseCid("bafk2bzacecgbcbh3uk7olcfdqo44no5nxxayeqnycdznrlekqigbifor2revm"), + "evm": MustParseCid("bafk2bzaceanxhvz5czs6xfunhbysbttmim5e7poftibsu53uqn4by5nqmdaj6"), + "init": MustParseCid("bafk2bzacea7lxnvgxupwwgoxlmwtrca75w73qabe324wnwx43qranbgf5zdqo"), + "multisig": MustParseCid("bafk2bzacear5eu5gpbjlroqkmsgpqerzc4aemp2uqcaeq7s2h4ur4ucgpzesg"), + "paymentchannel": MustParseCid("bafk2bzacecwxuruxawcru7xfcx3rmt4hmhlfh4hi6jvfumerazz6jpvfmxxcw"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacebk4syfvyk7kbxelk7ajo4vuxcc24k5ry52mvi3qtadlucy2vqlay"), + "storagemarket": MustParseCid("bafk2bzaced2rfzwup3jlwovblx2y7q64w6mshbtn2nmampi4zfd3b4oplkp5c"), + "storageminer": MustParseCid("bafk2bzacecden66gfmmgylmr47myn4murqmbt3ycyxqayn54yzhcsda32rp3m"), + "storagepower": MustParseCid("bafk2bzacebxvco3shuhdnzjmmme3olbffdgpab7j3onfncksi762k3agjhzaa"), + "system": MustParseCid("bafk2bzacednnhpk5kno67bkomiohweglryqvgnqz4cbks6eomidai677fat5w"), + "verifiedregistry": MustParseCid("bafk2bzaceawecz24xbz7robn7ck7k2mprkewvup6q346whbfiybcrvy63qcsa"), + }, }, { Network: "caterpillarnet", Version: 8, @@ -195,6 +239,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzacecl7gizbe52xj6sfm5glubkhrdblmzuwlid6lxrwr5zhcmv4dl2ew"), "verifiedregistry": MustParseCid("bafk2bzacebzndvdqtdck2y35smcxezldgh6nm6rbkj3g3fmiknsgg2uah235y"), }, +}, { + Network: "caterpillarnet", + Version: 11, + ManifestCid: MustParseCid("bafy2bzacebsdvrxmdajiyxq2mxxxppvg2zwvqjzz3pgbsxwh6pvdcjofpmnxw"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzacedfms6w3ghqtljpgsfuiqa6ztjx7kcuin6myjezj6rypj3zjbqms6"), + "cron": MustParseCid("bafk2bzaceaganmlpozvy4jywigs46pfrtdmhjjey6uyhpurplqbasojsislba"), + "datacap": MustParseCid("bafk2bzacebafqqe3wv5ytkfwmqzbmchgem66pw6yq6rl7w6vlhqsbkxnisswq"), + "eam": MustParseCid("bafk2bzaceaeayeksiivw4y3gdqtigbgfntyvwc3q7v2ivb5kx7u55pn4q5lt6"), + "ethaccount": MustParseCid("bafk2bzaceburkmtd63nmzxpux5rcxsbqr6x5didl2ce7al32g4tqrvo4pjz2i"), + "evm": MustParseCid("bafk2bzacea7tp4lop7ivhay3ozitkmxxurk74v4zse42ant47rh2uw5z3tq5e"), + "init": MustParseCid("bafk2bzaced23r54kwuebl7t6mdantbby5qpfduxwxfryeliof2enyqzhokix6"), + "multisig": MustParseCid("bafk2bzacebcn3rib6j6jvclys7dkf62hco45ssgamczkrtzt6xyewd6gt3mtu"), + "paymentchannel": MustParseCid("bafk2bzacecvas4leo44pqdguj22nnwqoqdgwajzrpm5d6ltkehc37ni6p6doq"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacebiizh4ohvv6p4uxjusoygex4wxcgvudqmdl2fsh6ft6s2zt4tz6q"), + "storagemarket": MustParseCid("bafk2bzacedhkidshm7w2sqlw7izvaieyhkvmyhfsem6t6qfnkh7dnwqe56po2"), + "storageminer": MustParseCid("bafk2bzacedcmsibwfwhkp3sabmbyjmhqibyhjf3wwst7u5bkb2k6xpun3xevg"), + "storagepower": MustParseCid("bafk2bzacecrgnpypxnxzgglhlitaallfee3dl4ejy3y63knl7llnwba4ycf7i"), + "system": MustParseCid("bafk2bzacecl7gizbe52xj6sfm5glubkhrdblmzuwlid6lxrwr5zhcmv4dl2ew"), + "verifiedregistry": MustParseCid("bafk2bzacebzndvdqtdck2y35smcxezldgh6nm6rbkj3g3fmiknsgg2uah235y"), + }, }, { Network: "devnet", Version: 8, @@ -252,6 +318,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzacebp4ysxqv4cy633pgdxjlbwkwqkokc2fgez77y73abpt5hkthczn6"), "verifiedregistry": MustParseCid("bafk2bzaceb7odugx7meltvt2gra4vogn2g6avbgysivvdccldylusjcfsnfhy"), }, +}, { + Network: "devnet", + Version: 11, + ManifestCid: MustParseCid("bafy2bzaceanq4logp5zjb2dyrjwupmgiyy2s6tagdodcoqc5nc4b2g5m54zzk"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzacebb5txxkfexeaxa2th3rckxsxchzyss3ijgqbicf265h7rre2rvhm"), + "cron": MustParseCid("bafk2bzacecotn4gwluhamoqwnzgbg7ogehv26o5xnhjzltnzfv6utrlyanzek"), + "datacap": MustParseCid("bafk2bzacea4hket2srrtbewkf3tip6ellwpxdfbrzt5u47y57i2k6iojqqgba"), + "eam": MustParseCid("bafk2bzacebx32wmbhhgdhsguvopmucvnvitq4h424kkyvtok5hhkdgsoiwrvq"), + "ethaccount": MustParseCid("bafk2bzacedh4y3zvtgft3i6ift4rpptgr2dx67pvenowvq7yaspuf25gqgcdc"), + "evm": MustParseCid("bafk2bzacecrjgqoozymyoplrmtpi7bmkmggiqgpbgwkzooy2a67fjivuedm6a"), + "init": MustParseCid("bafk2bzacedof2ckc6w2qboxzxv4w67njcug4ut4cq3nnlrfybzsvlgnp4kt24"), + "multisig": MustParseCid("bafk2bzacec4eqajjqhl53tnkbs7glu7njlbtlditi7lxhvw33ezmxk6jae46y"), + "paymentchannel": MustParseCid("bafk2bzacec6nvdprqja7dy3qp5islebbbh2ifiyg2p7arbe6pocjhfe6xwkfy"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacecqaoqksjotl4wwsqt2wf6kqv6s372afi3r5on4bqj3u3a44px2rm"), + "storagemarket": MustParseCid("bafk2bzaceb7yefqlzyoxkgoug5k4kizy63izrg5udartw5l4d6j53xjwdxbg4"), + "storageminer": MustParseCid("bafk2bzaceagmuxcgdj65yuvtfrcup5viwkhhhlzslpdd4j6v6qxmhxtcssc6u"), + "storagepower": MustParseCid("bafk2bzacedt2qu6ykj3bjsfhchg2gxvc6asfb7c4tmranl76n4ojut5d6sgqm"), + "system": MustParseCid("bafk2bzacebp4ysxqv4cy633pgdxjlbwkwqkokc2fgez77y73abpt5hkthczn6"), + "verifiedregistry": MustParseCid("bafk2bzaceb7odugx7meltvt2gra4vogn2g6avbgysivvdccldylusjcfsnfhy"), + }, }, { Network: "hyperspace", Version: 8, @@ -318,6 +406,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzacedo2hfopt6gy52goj7fot5qwzhtnysmgo7h25crq4clpugkerjabk"), "verifiedregistry": MustParseCid("bafk2bzacea7rfkjrixaidksnmjehglmavyt56nyeu3sfxu2e3dcpf62oab6tw"), }, +}, { + Network: "hyperspace", + Version: 11, + ManifestCid: MustParseCid("bafy2bzacedvffumcvf72f2btjqvece3kpcdorxq5tq76iwcmqbzvsiu526cqm"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzacecim7uybic2qprbkjhowg7qkniv4zywj5h5g4u4ss72urco2akzuo"), + "cron": MustParseCid("bafk2bzaceahgq64awp4f7li3hdgimc4upqvdvltpmeywckvens33umcxt424a"), + "datacap": MustParseCid("bafk2bzacebkxn52ttooaslkwncijk3bgd3tm2zw7vijdhwvg2cxnxbrzmmq5e"), + "eam": MustParseCid("bafk2bzaceczhgub5anrnaf7ol65mu54gsgwcj6c6m3yhet7rhxm2l6kz4s4ru"), + "ethaccount": MustParseCid("bafk2bzacealn5enbxyxbfs7gbsjbyma2zk3bcr7okvflxhpr753d4eh6ixooa"), + "evm": MustParseCid("bafk2bzacedljkrmazyewawpnddrkzrt55556374dw2pm2hokgkompgzw4vx5y"), + "init": MustParseCid("bafk2bzacec55gyyaqjrw7zughywocgwcjvv6k5fijjpjw4xgckuqz6pjtff5a"), + "multisig": MustParseCid("bafk2bzaceblozbdzybdivvjdiid4jwm2jc6x5a66sunh2vvwsqba6wzqmr7i6"), + "paymentchannel": MustParseCid("bafk2bzacealcyke5a6n24efs6qe4iikynpk2twqssyugy7jcyf6p6shgw2iwa"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacebafzaqhwsm3nmsfwcd6ngvx6ev6zlcpyfljqh4kb77vok6opban6"), + "storagemarket": MustParseCid("bafk2bzacecrjfg4p7fxznsdkoobs4po2ve3ywixrirrk6netgxh63qqaefamg"), + "storageminer": MustParseCid("bafk2bzaceb3ctd4atxwhdkmlg4i63zxo5aopknlj7l5kaiqr22xpcmico6vg4"), + "storagepower": MustParseCid("bafk2bzacecvcix3ugopvby2vah5wwiu5cqjedwzwkanmr34kdoc4f3o6p7nsq"), + "system": MustParseCid("bafk2bzacedo2hfopt6gy52goj7fot5qwzhtnysmgo7h25crq4clpugkerjabk"), + "verifiedregistry": MustParseCid("bafk2bzacea7rfkjrixaidksnmjehglmavyt56nyeu3sfxu2e3dcpf62oab6tw"), + }, }, { Network: "mainnet", Version: 8, @@ -375,6 +485,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzacedlt3zcsbw2vucbydptbcfudw5y5pkhhxe26m7pjod6rkxkuzn52w"), "verifiedregistry": MustParseCid("bafk2bzacea2eehyf7h3m6ydh46piu2gtr4fawpqzh3brtmybgi2tyxf5nwj6m"), }, +}, { + Network: "mainnet", + Version: 11, + ManifestCid: MustParseCid("bafy2bzacedm3l5pxuwd5eem6k2ndvix26ftky45oca3shg7l3lxd2drykjmwo"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzacedsn6i2flkpk6sb4iuejo7gfl5n6fhsdawggtbsihlrrjtvs7oepu"), + "cron": MustParseCid("bafk2bzacecw4guere7ba2canyi2622lw52b5qbn7iubckcp5cwlmx2kw7qqwy"), + "datacap": MustParseCid("bafk2bzaceat2ncckd2jjjqcovd3ib4sylwff7jk7rlk6gr5d2gmrrc7isrmu2"), + "eam": MustParseCid("bafk2bzaceddhqhwduaw6x54w27s346267izwttnjdyol3hv4toe7mkt47y2gy"), + "ethaccount": MustParseCid("bafk2bzacedmwzkbytxfn7exmxxosomvix4mpyxrmupeqw45aofqmdq5q7mgqe"), + "evm": MustParseCid("bafk2bzacecrrwixyqwphxaybhy5zxuawkhncq5tgtuz2ind4bl22oivzjidoq"), + "init": MustParseCid("bafk2bzacec6276d7ls3hhuqibqorn3yp45mv7hroczf3bgb6jkhmbb2zqt3bw"), + "multisig": MustParseCid("bafk2bzaceahggxrnjj3w3cgtko54srssqyhcs4x6y55ytego6jf2owg5piw3y"), + "paymentchannel": MustParseCid("bafk2bzaceaobaqjamso57bkjv3n4ilv7lfropgrncnnej666w3tegmr4cfgve"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacecqet4s7abe4owznq2wtdefe2z2w5isbde2gj7u3hwgf54di4r7hy"), + "storagemarket": MustParseCid("bafk2bzacebgk2q2ktrqauzop6ha4pcq5gpf6g24hprxnp6wdmlzf724e5sx7i"), + "storageminer": MustParseCid("bafk2bzacecqrm4tlmzci7vilmcchr4lq2e6yyrlhy6ofbuecjna2phmbq4h2a"), + "storagepower": MustParseCid("bafk2bzaceco674a5e5lpv5leui65bljxzgyc2ypdquaow55iuckmq5rvsghr6"), + "system": MustParseCid("bafk2bzacedlt3zcsbw2vucbydptbcfudw5y5pkhhxe26m7pjod6rkxkuzn52w"), + "verifiedregistry": MustParseCid("bafk2bzacea2eehyf7h3m6ydh46piu2gtr4fawpqzh3brtmybgi2tyxf5nwj6m"), + }, }, { Network: "testing", Version: 8, @@ -432,6 +564,28 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzaceaafqf7lwaiqx5po6b3l4dfg4xsr5qhfk3bjgoi7qke2mfy3shla4"), "verifiedregistry": MustParseCid("bafk2bzacec2ouguts4z335vetmdeifpk5fkqthcmrwshk7yxbw2uohddfu5lo"), }, +}, { + Network: "testing", + Version: 11, + ManifestCid: MustParseCid("bafy2bzaceaxrrais4643j7j2cjkk2gdlwzt32gvy4hjdsmmmk47g4qfnzuipm"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzaceds3iy5qjgr3stoywxt4uxvhybca23q7d2kxhitedgudrkhxaxa6o"), + "cron": MustParseCid("bafk2bzacebxp4whb4ocqxnbvqlz3kckarabtyvhjbhqvrdwhejuffwactyiss"), + "datacap": MustParseCid("bafk2bzacedepm3zas6vqryruwiz7d3axkneo7v66q65gf2dlpfd53pjlycrg4"), + "eam": MustParseCid("bafk2bzaceappxiqxvpwiwfaqobhbbzrb6nuedaryj7nakyhwyy353coxj3jdc"), + "ethaccount": MustParseCid("bafk2bzacecbhz4ipg773lsovgpjysm6fxl2i7y2wuxadqnt4s4vm3nd2qodb4"), + "evm": MustParseCid("bafk2bzaced5efc2bi7ulqsep4ej74hxwbjap2qi7lojiqzfsowxr4kylkwzk6"), + "init": MustParseCid("bafk2bzacebqym5i5eciyyyzsimu73z6bkffpm5hzjpx3gwcm64pm2fh7okrja"), + "multisig": MustParseCid("bafk2bzacecmlyngek7qvj5ezaaitadrycapup3mbty4ijlzun6g23tcoysxle"), + "paymentchannel": MustParseCid("bafk2bzacedspin4hxpgnxkjen3hsxpcc52oc5q4ypukl4qq6vaytcgmmi7hl4"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacecmumnnqkqnoa23hhsfgwccwvmksr2q65tznbves6x2a6fhwvtm7a"), + "storagemarket": MustParseCid("bafk2bzacea2re4nxba7mtlrwdxabu2i3l2fwbuw2veb4p7qbvrsaocgablqvi"), + "storageminer": MustParseCid("bafk2bzacecixm7d7d5ltsp6mubzw5s3fv335cjuwwy7oqovujn3xlyk6twivs"), + "storagepower": MustParseCid("bafk2bzaced5lqpftacjsflcgfwlm32gzckpi3ndj3kd3prtqqi2lfj3uhl2je"), + "system": MustParseCid("bafk2bzaceaafqf7lwaiqx5po6b3l4dfg4xsr5qhfk3bjgoi7qke2mfy3shla4"), + "verifiedregistry": MustParseCid("bafk2bzacec2ouguts4z335vetmdeifpk5fkqthcmrwshk7yxbw2uohddfu5lo"), + }, }, { Network: "testing-fake-proofs", Version: 8, @@ -489,4 +643,26 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet "system": MustParseCid("bafk2bzaceaafqf7lwaiqx5po6b3l4dfg4xsr5qhfk3bjgoi7qke2mfy3shla4"), "verifiedregistry": MustParseCid("bafk2bzacec2ouguts4z335vetmdeifpk5fkqthcmrwshk7yxbw2uohddfu5lo"), }, +}, { + Network: "testing-fake-proofs", + Version: 11, + ManifestCid: MustParseCid("bafy2bzacedkxrjyboullp5vqdilbkclfzz2siniidh2lfcb7uustm3ffn4zw2"), + Actors: map[string]cid.Cid{ + "account": MustParseCid("bafk2bzaceds3iy5qjgr3stoywxt4uxvhybca23q7d2kxhitedgudrkhxaxa6o"), + "cron": MustParseCid("bafk2bzacebxp4whb4ocqxnbvqlz3kckarabtyvhjbhqvrdwhejuffwactyiss"), + "datacap": MustParseCid("bafk2bzacedepm3zas6vqryruwiz7d3axkneo7v66q65gf2dlpfd53pjlycrg4"), + "eam": MustParseCid("bafk2bzaceappxiqxvpwiwfaqobhbbzrb6nuedaryj7nakyhwyy353coxj3jdc"), + "ethaccount": MustParseCid("bafk2bzacecbhz4ipg773lsovgpjysm6fxl2i7y2wuxadqnt4s4vm3nd2qodb4"), + "evm": MustParseCid("bafk2bzaced5efc2bi7ulqsep4ej74hxwbjap2qi7lojiqzfsowxr4kylkwzk6"), + "init": MustParseCid("bafk2bzacebqym5i5eciyyyzsimu73z6bkffpm5hzjpx3gwcm64pm2fh7okrja"), + "multisig": MustParseCid("bafk2bzacecmlyngek7qvj5ezaaitadrycapup3mbty4ijlzun6g23tcoysxle"), + "paymentchannel": MustParseCid("bafk2bzacedspin4hxpgnxkjen3hsxpcc52oc5q4ypukl4qq6vaytcgmmi7hl4"), + "placeholder": MustParseCid("bafk2bzaceaamp2a35vpfml4skap4dffklzae2urcm34mtwwce2lvhaons3a5y"), + "reward": MustParseCid("bafk2bzacecmumnnqkqnoa23hhsfgwccwvmksr2q65tznbves6x2a6fhwvtm7a"), + "storagemarket": MustParseCid("bafk2bzacea2re4nxba7mtlrwdxabu2i3l2fwbuw2veb4p7qbvrsaocgablqvi"), + "storageminer": MustParseCid("bafk2bzacedz4mmupganqbwe6mz4636zepooh5ipxb36tybsrf6ynewrfdihl6"), + "storagepower": MustParseCid("bafk2bzacedcqv6k2fszpfb7zpw6q6c6fe2u7g2zefabcntp46xgv3owosgymy"), + "system": MustParseCid("bafk2bzaceaafqf7lwaiqx5po6b3l4dfg4xsr5qhfk3bjgoi7qke2mfy3shla4"), + "verifiedregistry": MustParseCid("bafk2bzacec2ouguts4z335vetmdeifpk5fkqthcmrwshk7yxbw2uohddfu5lo"), + }, }} diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz index 6b4fc7b4f..48e026caf 100644 Binary files a/build/openrpc/full.json.gz and b/build/openrpc/full.json.gz differ diff --git a/build/openrpc/gateway.json.gz b/build/openrpc/gateway.json.gz index cc3870a49..96dfa7b13 100644 Binary files a/build/openrpc/gateway.json.gz and b/build/openrpc/gateway.json.gz differ diff --git a/build/openrpc/miner.json.gz b/build/openrpc/miner.json.gz index 4f67b5393..dfd6fb55b 100644 Binary files a/build/openrpc/miner.json.gz and b/build/openrpc/miner.json.gz differ diff --git a/build/params_2k.go b/build/params_2k.go index 081007dd1..f12620a87 100644 --- a/build/params_2k.go +++ b/build/params_2k.go @@ -61,6 +61,8 @@ var UpgradeSharkHeight = abi.ChainEpoch(-20) var UpgradeHyggeHeight = abi.ChainEpoch(-21) +var UpgradeNV19Height = abi.ChainEpoch(10) + var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandMainnet, } @@ -114,6 +116,7 @@ func init() { UpgradeSkyrHeight = getUpgradeHeight("LOTUS_SKYR_HEIGHT", UpgradeSkyrHeight) UpgradeSharkHeight = getUpgradeHeight("LOTUS_SHARK_HEIGHT", UpgradeSharkHeight) UpgradeHyggeHeight = getUpgradeHeight("LOTUS_HYGGE_HEIGHT", UpgradeHyggeHeight) + UpgradeNV19Height = getUpgradeHeight("LOTUS_NV19_HEIGHT", UpgradeNV19Height) BuildType |= Build2k diff --git a/build/params_butterfly.go b/build/params_butterfly.go index 7cd02bce9..0d383aa03 100644 --- a/build/params_butterfly.go +++ b/build/params_butterfly.go @@ -53,6 +53,8 @@ const UpgradeSkyrHeight = -19 const UpgradeSharkHeight = abi.ChainEpoch(-20) const UpgradeHyggeHeight = abi.ChainEpoch(600) +var UpgradeNV19Height = abi.ChainEpoch(99999999999999) + var SupportedProofTypes = []abi.RegisteredSealProof{ abi.RegisteredSealProof_StackedDrg512MiBV1, abi.RegisteredSealProof_StackedDrg32GiBV1, diff --git a/build/params_calibnet.go b/build/params_calibnet.go index 0661bb839..834a8fae3 100644 --- a/build/params_calibnet.go +++ b/build/params_calibnet.go @@ -73,6 +73,8 @@ const UpgradeSharkHeight = 16800 // 6 days after genesis const UpgradeHyggeHeight = math.MaxInt64 +var UpgradeNV19Height = abi.ChainEpoch(99999999999999) + var SupportedProofTypes = []abi.RegisteredSealProof{ abi.RegisteredSealProof_StackedDrg32GiBV1, abi.RegisteredSealProof_StackedDrg64GiBV1, diff --git a/build/params_hyperspace.go b/build/params_hyperspace.go index 1e75c6bfa..2b0dda0aa 100644 --- a/build/params_hyperspace.go +++ b/build/params_hyperspace.go @@ -55,6 +55,8 @@ var UpgradeSkyrHeight = abi.ChainEpoch(-19) var UpgradeSharkHeight = abi.ChainEpoch(-20) var UpgradeHyggeHeight = abi.ChainEpoch(-21) +var UpgradeNV19Height = abi.ChainEpoch(99999999999999) + var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandMainnet, } diff --git a/build/params_interop.go b/build/params_interop.go index 4d94de049..f12de183e 100644 --- a/build/params_interop.go +++ b/build/params_interop.go @@ -54,6 +54,8 @@ const UpgradeSharkHeight = abi.ChainEpoch(-20) const UpgradeHyggeHeight = abi.ChainEpoch(99999999999999) +var UpgradeNV19Height = abi.ChainEpoch(99999999999999) + var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandMainnet, } diff --git a/build/params_mainnet.go b/build/params_mainnet.go index f95525dbc..432c80e8e 100644 --- a/build/params_mainnet.go +++ b/build/params_mainnet.go @@ -87,7 +87,10 @@ const UpgradeSkyrHeight = 1960320 const UpgradeSharkHeight = 2383680 // ?????????????? -var UpgradeHyggeHeight = abi.ChainEpoch(math.MaxInt64) +var UpgradeHyggeHeight = abi.ChainEpoch(math.MaxInt64 - 1) + +// ?????????????? +var UpgradeNV19Height = abi.ChainEpoch(math.MaxInt64) var SupportedProofTypes = []abi.RegisteredSealProof{ abi.RegisteredSealProof_StackedDrg32GiBV1, diff --git a/build/params_shared_vals.go b/build/params_shared_vals.go index be6640d6f..6d9c2279f 100644 --- a/build/params_shared_vals.go +++ b/build/params_shared_vals.go @@ -33,7 +33,7 @@ const TestNetworkVersion = network.Version{{.latestNetworkVersion}} /* inline-gen start */ -const TestNetworkVersion = network.Version18 +const TestNetworkVersion = network.Version19 /* inline-gen end */ diff --git a/build/params_wallaby.go b/build/params_wallaby.go index c5279bfd0..37283d9db 100644 --- a/build/params_wallaby.go +++ b/build/params_wallaby.go @@ -55,6 +55,8 @@ var UpgradeSkyrHeight = abi.ChainEpoch(-19) var UpgradeSharkHeight = abi.ChainEpoch(-20) var UpgradeHyggeHeight = abi.ChainEpoch(-21) +var UpgradeNV19Height = abi.ChainEpoch(99999999999999) + var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ 0: DrandMainnet, } diff --git a/chain/actors/builtin/account/account.go b/chain/actors/builtin/account/account.go index 4542ad767..a29248d56 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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 = builtin10.MethodsAccount +var Methods = builtin11.MethodsAccount func Load(store adt.Store, act *types.Actor) (State, error) { if name, av, ok := actors.GetActorMetaByCode(act.Code); ok { @@ -41,6 +41,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -105,6 +108,9 @@ func MakeState(store adt.Store, av actorstypes.Version, addr address.Address) (S case actorstypes.Version10: return make10(store, addr) + case actorstypes.Version11: + return make11(store, addr) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -132,5 +138,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/account/v11.go b/chain/actors/builtin/account/v11.go new file mode 100644 index 000000000..7a0c5f556 --- /dev/null +++ b/chain/actors/builtin/account/v11.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" + account11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, addr address.Address) (State, error) { + out := state11{store: store} + out.State = account11.State{Address: addr} + return &out, nil +} + +type state11 struct { + account11.State + store adt.Store +} + +func (s *state11) PubkeyAddress() (address.Address, error) { + return s.Address, nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) ActorKey() string { + return manifest.AccountKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 43b8c0eaa..c2f758698 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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" @@ -37,6 +37,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -101,13 +104,16 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version10: return make10(store) + case actorstypes.Version11: + return make11(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } var ( - Address = builtin10.CronActorAddr - Methods = builtin10.MethodsCron + Address = builtin11.CronActorAddr + Methods = builtin11.MethodsCron ) type State interface { @@ -130,5 +136,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/cron/v11.go b/chain/actors/builtin/cron/v11.go new file mode 100644 index 000000000..5c489cede --- /dev/null +++ b/chain/actors/builtin/cron/v11.go @@ -0,0 +1,57 @@ +package cron + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + actorstypes "github.com/filecoin-project/go-state-types/actors" + cron11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store) (State, error) { + out := state11{store: store} + out.State = *cron11.ConstructState(cron11.BuiltInEntries()) + return &out, nil +} + +type state11 struct { + cron11.State + store adt.Store +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) ActorKey() string { + return manifest.CronKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 c12c77230..3cf557e6c 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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 = builtin10.DatacapActorAddr - Methods = builtin10.MethodsDatacap + Address = builtin11.DatacapActorAddr + Methods = builtin11.MethodsDatacap ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -35,6 +35,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -50,6 +53,9 @@ func MakeState(store adt.Store, av actorstypes.Version, governor address.Address case actorstypes.Version10: return make10(store, governor, bitwidth) + case actorstypes.Version11: + return make11(store, governor, bitwidth) + default: return nil, xerrors.Errorf("datacap actor only valid for actors v9 and above, got %d", av) } @@ -72,5 +78,6 @@ func AllCodes() []cid.Cid { return []cid.Cid{ (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/datacap/v11.go b/chain/actors/builtin/datacap/v11.go new file mode 100644 index 000000000..0c302b5e1 --- /dev/null +++ b/chain/actors/builtin/datacap/v11.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" + datacap11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, governor address.Address, bitwidth uint64) (State, error) { + out := state11{store: store} + s, err := datacap11.ConstructState(store, governor, bitwidth) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state11 struct { + datacap11.State + store adt.Store +} + +func (s *state11) Governor() (address.Address, error) { + return s.State.Governor, nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error { + return forEachClient(s.store, actors.Version11, s.verifiedClients, cb) +} + +func (s *state11) verifiedClients() (adt.Map, error) { + return adt11.AsMap(s.store, s.Token.Balances, int(s.Token.HamtBitWidth)) +} + +func (s *state11) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) { + return getDataCap(s.store, actors.Version11, s.verifiedClients, addr) +} + +func (s *state11) ActorKey() string { + return manifest.DatacapKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 120ca66f8..fb5e1412b 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" @@ -14,7 +14,7 @@ import ( "github.com/filecoin-project/lotus/chain/types" ) -var Methods = builtin10.MethodsEVM +var Methods = builtin11.MethodsEVM func Load(store adt.Store, act *types.Actor) (State, error) { if name, av, ok := actors.GetActorMetaByCode(act.Code); ok { @@ -27,6 +27,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -39,6 +42,9 @@ func MakeState(store adt.Store, av actorstypes.Version, bytecode cid.Cid) (State case actorstypes.Version10: return make10(store, bytecode) + case actorstypes.Version11: + return make11(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/v11.go b/chain/actors/builtin/evm/v11.go new file mode 100644 index 000000000..16238b0da --- /dev/null +++ b/chain/actors/builtin/evm/v11.go @@ -0,0 +1,45 @@ +package evm + +import ( + "github.com/ipfs/go-cid" + + evm11 "github.com/filecoin-project/go-state-types/builtin/v11/evm" + + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, bytecode cid.Cid) (State, error) { + out := state11{store: store} + s, err := evm11.ConstructState(store, bytecode) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state11 struct { + evm11.State + store adt.Store +} + +func (s *state11) Nonce() (uint64, error) { + return s.State.Nonce, nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} diff --git a/chain/actors/builtin/init/init.go b/chain/actors/builtin/init/init.go index c38629d2d..2d9e41275 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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 = builtin10.InitActorAddr - Methods = builtin10.MethodsInit + Address = builtin11.InitActorAddr + Methods = builtin11.MethodsInit ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -46,6 +46,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -110,6 +113,9 @@ func MakeState(store adt.Store, av actorstypes.Version, networkName string) (Sta case actorstypes.Version10: return make10(store, networkName) + case actorstypes.Version11: + return make11(store, networkName) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -160,5 +166,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/init/v11.go b/chain/actors/builtin/init/v11.go new file mode 100644 index 000000000..3d8d72e49 --- /dev/null +++ b/chain/actors/builtin/init/v11.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" + builtin11 "github.com/filecoin-project/go-state-types/builtin" + init11 "github.com/filecoin-project/go-state-types/builtin/v11/init" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, networkName string) (State, error) { + out := state11{store: store} + + s, err := init11.ConstructState(store, networkName) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state11 struct { + init11.State + store adt.Store +} + +func (s *state11) ResolveAddress(address address.Address) (address.Address, bool, error) { + return s.State.ResolveAddress(s.store, address) +} + +func (s *state11) MapAddressToNewID(address address.Address) (address.Address, error) { + return s.State.MapAddressToNewID(s.store, address) +} + +func (s *state11) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error { + addrs, err := adt11.AsMap(s.store, s.State.AddressMap, builtin11.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 *state11) NetworkName() (dtypes.NetworkName, error) { + return dtypes.NetworkName(s.State.NetworkName), nil +} + +func (s *state11) SetNetworkName(name string) error { + s.State.NetworkName = name + return nil +} + +func (s *state11) SetNextID(id abi.ActorID) error { + s.State.NextID = id + return nil +} + +func (s *state11) Remove(addrs ...address.Address) (err error) { + m, err := adt11.AsMap(s.store, s.State.AddressMap, builtin11.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 *state11) SetAddressMap(mcid cid.Cid) error { + s.State.AddressMap = mcid + return nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) AddressMap() (adt.Map, error) { + return adt11.AsMap(s.store, s.State.AddressMap, builtin11.DefaultHamtBitwidth) +} + +func (s *state11) AddressMapBitWidth() int { + return builtin11.DefaultHamtBitwidth +} + +func (s *state11) AddressMapHashFunction() func(input []byte) []byte { + return func(input []byte) []byte { + res := sha256.Sum256(input) + return res[:] + } +} + +func (s *state11) ActorKey() string { + return manifest.InitKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 fc057549d..36936e787 100644 --- a/chain/actors/builtin/market/market.go +++ b/chain/actors/builtin/market/market.go @@ -52,6 +52,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -116,6 +119,9 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version10: return make10(store) + case actorstypes.Version11: + return make11(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -208,6 +214,9 @@ func DecodePublishStorageDealsReturn(b []byte, nv network.Version) (PublishStora case actorstypes.Version10: return decodePublishStorageDealsReturn10(b) + case actorstypes.Version11: + return decodePublishStorageDealsReturn11(b) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -293,5 +302,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/market/v11.go b/chain/actors/builtin/market/v11.go new file mode 100644 index 000000000..a816e3409 --- /dev/null +++ b/chain/actors/builtin/market/v11.go @@ -0,0 +1,377 @@ +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" + market11 "github.com/filecoin-project/go-state-types/builtin/v11/market" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/util/adt" + markettypes "github.com/filecoin-project/go-state-types/builtin/v9/market" + verifregtypes "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" + "github.com/filecoin-project/lotus/chain/types" +) + +var _ State = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store) (State, error) { + out := state11{store: store} + + s, err := market11.ConstructState(store) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state11 struct { + market11.State + store adt.Store +} + +func (s *state11) TotalLocked() (abi.TokenAmount, error) { + fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral) + fml = types.BigAdd(fml, s.TotalClientStorageFee) + return fml, nil +} + +func (s *state11) BalancesChanged(otherState State) (bool, error) { + otherState11, ok := otherState.(*state11) + 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(otherState11.State.EscrowTable) || !s.State.LockedTable.Equals(otherState11.State.LockedTable), nil +} + +func (s *state11) StatesChanged(otherState State) (bool, error) { + otherState11, ok := otherState.(*state11) + 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(otherState11.State.States), nil +} + +func (s *state11) States() (DealStates, error) { + stateArray, err := adt11.AsArray(s.store, s.State.States, market11.StatesAmtBitwidth) + if err != nil { + return nil, err + } + return &dealStates11{stateArray}, nil +} + +func (s *state11) ProposalsChanged(otherState State) (bool, error) { + otherState11, ok := otherState.(*state11) + 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(otherState11.State.Proposals), nil +} + +func (s *state11) Proposals() (DealProposals, error) { + proposalArray, err := adt11.AsArray(s.store, s.State.Proposals, market11.ProposalsAmtBitwidth) + if err != nil { + return nil, err + } + return &dealProposals11{proposalArray}, nil +} + +func (s *state11) EscrowTable() (BalanceTable, error) { + bt, err := adt11.AsBalanceTable(s.store, s.State.EscrowTable) + if err != nil { + return nil, err + } + return &balanceTable11{bt}, nil +} + +func (s *state11) LockedTable() (BalanceTable, error) { + bt, err := adt11.AsBalanceTable(s.store, s.State.LockedTable) + if err != nil { + return nil, err + } + return &balanceTable11{bt}, nil +} + +func (s *state11) VerifyDealsForActivation( + minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch, +) (weight, verifiedWeight abi.DealWeight, err error) { + w, vw, _, err := market11.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch) + return w, vw, err +} + +func (s *state11) NextID() (abi.DealID, error) { + return s.State.NextID, nil +} + +type balanceTable11 struct { + *adt11.BalanceTable +} + +func (bt *balanceTable11) ForEach(cb func(address.Address, abi.TokenAmount) error) error { + asMap := (*adt11.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 dealStates11 struct { + adt.Array +} + +func (s *dealStates11) Get(dealID abi.DealID) (*DealState, bool, error) { + var deal11 market11.DealState + found, err := s.Array.Get(uint64(dealID), &deal11) + if err != nil { + return nil, false, err + } + if !found { + return nil, false, nil + } + deal := fromV11DealState(deal11) + return &deal, true, nil +} + +func (s *dealStates11) ForEach(cb func(dealID abi.DealID, ds DealState) error) error { + var ds11 market11.DealState + return s.Array.ForEach(&ds11, func(idx int64) error { + return cb(abi.DealID(idx), fromV11DealState(ds11)) + }) +} + +func (s *dealStates11) decode(val *cbg.Deferred) (*DealState, error) { + var ds11 market11.DealState + if err := ds11.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return nil, err + } + ds := fromV11DealState(ds11) + return &ds, nil +} + +func (s *dealStates11) array() adt.Array { + return s.Array +} + +func fromV11DealState(v11 market11.DealState) DealState { + ret := DealState{ + SectorStartEpoch: v11.SectorStartEpoch, + LastUpdatedEpoch: v11.LastUpdatedEpoch, + SlashEpoch: v11.SlashEpoch, + VerifiedClaim: 0, + } + + ret.VerifiedClaim = verifregtypes.AllocationId(v11.VerifiedClaim) + + return ret +} + +type dealProposals11 struct { + adt.Array +} + +func (s *dealProposals11) Get(dealID abi.DealID) (*DealProposal, bool, error) { + var proposal11 market11.DealProposal + found, err := s.Array.Get(uint64(dealID), &proposal11) + if err != nil { + return nil, false, err + } + if !found { + return nil, false, nil + } + + proposal, err := fromV11DealProposal(proposal11) + if err != nil { + return nil, true, xerrors.Errorf("decoding proposal: %w", err) + } + + return &proposal, true, nil +} + +func (s *dealProposals11) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error { + var dp11 market11.DealProposal + return s.Array.ForEach(&dp11, func(idx int64) error { + dp, err := fromV11DealProposal(dp11) + if err != nil { + return xerrors.Errorf("decoding proposal: %w", err) + } + + return cb(abi.DealID(idx), dp) + }) +} + +func (s *dealProposals11) decode(val *cbg.Deferred) (*DealProposal, error) { + var dp11 market11.DealProposal + if err := dp11.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return nil, err + } + + dp, err := fromV11DealProposal(dp11) + if err != nil { + return nil, err + } + + return &dp, nil +} + +func (s *dealProposals11) array() adt.Array { + return s.Array +} + +func fromV11DealProposal(v11 market11.DealProposal) (DealProposal, error) { + + label, err := fromV11Label(v11.Label) + + if err != nil { + return DealProposal{}, xerrors.Errorf("error setting deal label: %w", err) + } + + return DealProposal{ + PieceCID: v11.PieceCID, + PieceSize: v11.PieceSize, + VerifiedDeal: v11.VerifiedDeal, + Client: v11.Client, + Provider: v11.Provider, + + Label: label, + + StartEpoch: v11.StartEpoch, + EndEpoch: v11.EndEpoch, + StoragePricePerEpoch: v11.StoragePricePerEpoch, + + ProviderCollateral: v11.ProviderCollateral, + ClientCollateral: v11.ClientCollateral, + }, nil +} + +func fromV11Label(v11 market11.DealLabel) (DealLabel, error) { + if v11.IsString() { + str, err := v11.ToString() + if err != nil { + return markettypes.EmptyDealLabel, xerrors.Errorf("failed to convert string label to string: %w", err) + } + return markettypes.NewLabelFromString(str) + } + + bs, err := v11.ToBytes() + if err != nil { + return markettypes.EmptyDealLabel, xerrors.Errorf("failed to convert bytes label to bytes: %w", err) + } + return markettypes.NewLabelFromBytes(bs) +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +var _ PublishStorageDealsReturn = (*publishStorageDealsReturn11)(nil) + +func decodePublishStorageDealsReturn11(b []byte) (PublishStorageDealsReturn, error) { + var retval market11.PublishStorageDealsReturn + if err := retval.UnmarshalCBOR(bytes.NewReader(b)); err != nil { + return nil, xerrors.Errorf("failed to unmarshal PublishStorageDealsReturn: %w", err) + } + + return &publishStorageDealsReturn11{retval}, nil +} + +type publishStorageDealsReturn11 struct { + market11.PublishStorageDealsReturn +} + +func (r *publishStorageDealsReturn11) 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 *publishStorageDealsReturn11) DealIDs() ([]abi.DealID, error) { + return r.IDs, nil +} + +func (s *state11) GetAllocationIdForPendingDeal(dealId abi.DealID) (verifregtypes.AllocationId, error) { + + allocations, err := adt11.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 *state11) ActorKey() string { + return manifest.MarketKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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/miner/miner.go b/chain/actors/builtin/miner/miner.go index 1931af3d3..3421f2c8d 100644 --- a/chain/actors/builtin/miner/miner.go +++ b/chain/actors/builtin/miner/miner.go @@ -45,6 +45,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -109,6 +112,9 @@ func MakeState(store adt.Store, av actors.Version) (State, error) { case actors.Version10: return make10(store) + case actors.Version11: + return make11(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -314,5 +320,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/miner/v11.go b/chain/actors/builtin/miner/v11.go new file mode 100644 index 000000000..a3ffd606f --- /dev/null +++ b/chain/actors/builtin/miner/v11.go @@ -0,0 +1,591 @@ +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" + builtin11 "github.com/filecoin-project/go-state-types/builtin" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store) (State, error) { + out := state11{store: store} + out.State = miner11.State{} + return &out, nil +} + +type state11 struct { + miner11.State + store adt.Store +} + +type deadline11 struct { + miner11.Deadline + store adt.Store +} + +type partition11 struct { + miner11.Partition + store adt.Store +} + +func (s *state11) 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 doesnt have enough funds to cover their locked pledge + available, err = s.GetAvailableBalance(bal) + return available, err +} + +func (s *state11) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) { + return s.CheckVestedFunds(s.store, epoch) +} + +func (s *state11) LockedFunds() (LockedFunds, error) { + return LockedFunds{ + VestingFunds: s.State.LockedFunds, + InitialPledgeRequirement: s.State.InitialPledge, + PreCommitDeposits: s.State.PreCommitDeposits, + }, nil +} + +func (s *state11) FeeDebt() (abi.TokenAmount, error) { + return s.State.FeeDebt, nil +} + +func (s *state11) InitialPledge() (abi.TokenAmount, error) { + return s.State.InitialPledge, nil +} + +func (s *state11) PreCommitDeposits() (abi.TokenAmount, error) { + return s.State.PreCommitDeposits, nil +} + +// Returns nil, nil if sector is not found +func (s *state11) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) { + info, ok, err := s.State.GetSector(s.store, num) + if !ok || err != nil { + return nil, err + } + + ret := fromV11SectorOnChainInfo(*info) + return &ret, nil +} + +func (s *state11) 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 *state11) 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 *miner11.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 *state11) 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 *miner11.Deadline) error { + partitions, err := dl.PartitionsArray(s.store) + if err != nil { + return err + } + quant := s.State.QuantSpecForDeadline(dlIdx) + var part miner11.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 := miner11.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant, miner11.PartitionExpirationAmtBitwidth) + if err != nil { + return err + } + var exp miner11.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 *state11) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) { + info, ok, err := s.State.GetPrecommittedSector(s.store, num) + if !ok || err != nil { + return nil, err + } + + ret := fromV11SectorPreCommitOnChainInfo(*info) + + return &ret, nil +} + +func (s *state11) ForEachPrecommittedSector(cb func(SectorPreCommitOnChainInfo) error) error { + precommitted, err := adt11.AsMap(s.store, s.State.PreCommittedSectors, builtin11.DefaultHamtBitwidth) + if err != nil { + return err + } + + var info miner11.SectorPreCommitOnChainInfo + if err := precommitted.ForEach(&info, func(_ string) error { + return cb(fromV11SectorPreCommitOnChainInfo(info)) + }); err != nil { + return err + } + + return nil +} + +func (s *state11) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) { + sectors, err := miner11.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 info11 miner11.SectorOnChainInfo + if err := sectors.ForEach(&info11, func(_ int64) error { + info := fromV11SectorOnChainInfo(info11) + infos = append(infos, &info) + return nil + }); err != nil { + return nil, err + } + return infos, nil + } + + // Otherwise, load selected. + infos11, err := sectors.Load(*snos) + if err != nil { + return nil, err + } + infos := make([]*SectorOnChainInfo, len(infos11)) + for i, info11 := range infos11 { + info := fromV11SectorOnChainInfo(*info11) + infos[i] = &info + } + return infos, nil +} + +func (s *state11) loadAllocatedSectorNumbers() (bitfield.BitField, error) { + var allocatedSectors bitfield.BitField + err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors) + return allocatedSectors, err +} + +func (s *state11) IsAllocated(num abi.SectorNumber) (bool, error) { + allocatedSectors, err := s.loadAllocatedSectorNumbers() + if err != nil { + return false, err + } + + return allocatedSectors.IsSet(uint64(num)) +} + +func (s *state11) GetProvingPeriodStart() (abi.ChainEpoch, error) { + return s.State.ProvingPeriodStart, nil +} + +func (s *state11) 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 *state11) 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 *state11) 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 &deadline11{*dl, s.store}, nil +} + +func (s *state11) 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 *miner11.Deadline) error { + return cb(i, &deadline11{*dl, s.store}) + }) +} + +func (s *state11) NumDeadlines() (uint64, error) { + return miner11.WPoStPeriodDeadlines, nil +} + +func (s *state11) DeadlinesChanged(other State) (bool, error) { + other11, ok := other.(*state11) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + + return !s.State.Deadlines.Equals(other11.Deadlines), nil +} + +func (s *state11) MinerInfoChanged(other State) (bool, error) { + other0, ok := other.(*state11) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.Info.Equals(other0.State.Info), nil +} + +func (s *state11) 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 *state11) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) { + return s.State.RecordedDeadlineInfo(epoch), nil +} + +func (s *state11) DeadlineCronActive() (bool, error) { + return s.State.DeadlineCronActive, nil +} + +func (s *state11) sectors() (adt.Array, error) { + return adt11.AsArray(s.store, s.Sectors, miner11.SectorsAmtBitwidth) +} + +func (s *state11) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) { + var si miner11.SectorOnChainInfo + err := si.UnmarshalCBOR(bytes.NewReader(val.Raw)) + if err != nil { + return SectorOnChainInfo{}, err + } + + return fromV11SectorOnChainInfo(si), nil +} + +func (s *state11) precommits() (adt.Map, error) { + return adt11.AsMap(s.store, s.PreCommittedSectors, builtin11.DefaultHamtBitwidth) +} + +func (s *state11) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) { + var sp miner11.SectorPreCommitOnChainInfo + err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw)) + if err != nil { + return SectorPreCommitOnChainInfo{}, err + } + + return fromV11SectorPreCommitOnChainInfo(sp), nil +} + +func (s *state11) EraseAllUnproven() error { + + dls, err := s.State.LoadDeadlines(s.store) + if err != nil { + return err + } + + err = dls.ForEach(s.store, func(dindx uint64, dl *miner11.Deadline) error { + ps, err := dl.PartitionsArray(s.store) + if err != nil { + return err + } + + var part miner11.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 *deadline11) LoadPartition(idx uint64) (Partition, error) { + p, err := d.Deadline.LoadPartition(d.store, idx) + if err != nil { + return nil, err + } + return &partition11{*p, d.store}, nil +} + +func (d *deadline11) ForEachPartition(cb func(uint64, Partition) error) error { + ps, err := d.Deadline.PartitionsArray(d.store) + if err != nil { + return err + } + var part miner11.Partition + return ps.ForEach(&part, func(i int64) error { + return cb(uint64(i), &partition11{part, d.store}) + }) +} + +func (d *deadline11) PartitionsChanged(other Deadline) (bool, error) { + other11, ok := other.(*deadline11) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + + return !d.Deadline.Partitions.Equals(other11.Deadline.Partitions), nil +} + +func (d *deadline11) PartitionsPoSted() (bitfield.BitField, error) { + return d.Deadline.PartitionsPoSted, nil +} + +func (d *deadline11) DisputableProofCount() (uint64, error) { + + ops, err := d.OptimisticProofsSnapshotArray(d.store) + if err != nil { + return 0, err + } + + return ops.Length(), nil + +} + +func (p *partition11) AllSectors() (bitfield.BitField, error) { + return p.Partition.Sectors, nil +} + +func (p *partition11) FaultySectors() (bitfield.BitField, error) { + return p.Partition.Faults, nil +} + +func (p *partition11) RecoveringSectors() (bitfield.BitField, error) { + return p.Partition.Recoveries, nil +} + +func (p *partition11) UnprovenSectors() (bitfield.BitField, error) { + return p.Partition.Unproven, nil +} + +func fromV11SectorOnChainInfo(v11 miner11.SectorOnChainInfo) SectorOnChainInfo { + info := SectorOnChainInfo{ + SectorNumber: v11.SectorNumber, + SealProof: v11.SealProof, + SealedCID: v11.SealedCID, + DealIDs: v11.DealIDs, + Activation: v11.Activation, + Expiration: v11.Expiration, + DealWeight: v11.DealWeight, + VerifiedDealWeight: v11.VerifiedDealWeight, + InitialPledge: v11.InitialPledge, + ExpectedDayReward: v11.ExpectedDayReward, + ExpectedStoragePledge: v11.ExpectedStoragePledge, + + SectorKeyCID: v11.SectorKeyCID, + } + return info +} + +func fromV11SectorPreCommitOnChainInfo(v11 miner11.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo { + ret := SectorPreCommitOnChainInfo{ + Info: SectorPreCommitInfo{ + SealProof: v11.Info.SealProof, + SectorNumber: v11.Info.SectorNumber, + SealedCID: v11.Info.SealedCID, + SealRandEpoch: v11.Info.SealRandEpoch, + DealIDs: v11.Info.DealIDs, + Expiration: v11.Info.Expiration, + UnsealedCid: nil, + }, + PreCommitDeposit: v11.PreCommitDeposit, + PreCommitEpoch: v11.PreCommitEpoch, + } + + ret.Info.UnsealedCid = v11.Info.UnsealedCid + + return ret +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) ActorKey() string { + return manifest.MinerKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 87ee759bd..5f70ea3c1 100644 --- a/chain/actors/builtin/multisig/message10.go +++ b/chain/actors/builtin/multisig/message10.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" - init10 "github.com/filecoin-project/go-state-types/builtin/v10/init" multisig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" + init11 "github.com/filecoin-project/go-state-types/builtin/v11/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 := &init10.ExecParams{ + execParams := &init11.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message11.go b/chain/actors/builtin/multisig/message11.go new file mode 100644 index 000000000..a2c086614 --- /dev/null +++ b/chain/actors/builtin/multisig/message11.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" + init11 "github.com/filecoin-project/go-state-types/builtin/v11/init" + multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/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 message11 struct{ message0 } + +func (m message11) 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 := &multisig11.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.Version11, 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 := &init11.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 4131a1b76..817d66726 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" - init10 "github.com/filecoin-project/go-state-types/builtin/v10/init" + init11 "github.com/filecoin-project/go-state-types/builtin/v11/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 := &init10.ExecParams{ + execParams := &init11.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message9.go b/chain/actors/builtin/multisig/message9.go index f9c8c3103..1472c4e66 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" - init10 "github.com/filecoin-project/go-state-types/builtin/v10/init" + init11 "github.com/filecoin-project/go-state-types/builtin/v11/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 := &init10.ExecParams{ + execParams := &init11.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/multisig.go b/chain/actors/builtin/multisig/multisig.go index 4abdf7bbb..9ab8fffb5 100644 --- a/chain/actors/builtin/multisig/multisig.go +++ b/chain/actors/builtin/multisig/multisig.go @@ -12,7 +12,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" - msig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" + msig11 "github.com/filecoin-project/go-state-types/builtin/v11/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" @@ -45,6 +45,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -109,6 +112,9 @@ func MakeState(store adt.Store, av actorstypes.Version, signers []address.Addres case actorstypes.Version10: return make10(store, signers, threshold, startEpoch, unlockDuration, initialBalance) + case actorstypes.Version11: + return make11(store, signers, threshold, startEpoch, unlockDuration, initialBalance) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -135,7 +141,7 @@ type State interface { GetState() interface{} } -type Transaction = msig10.Transaction +type Transaction = msig11.Transaction var Methods = builtintypes.MethodsMultisig @@ -171,6 +177,9 @@ func Message(version actorstypes.Version, from address.Address) MessageBuilder { case actorstypes.Version10: return message10{message0{from}} + + case actorstypes.Version11: + return message11{message0{from}} default: panic(fmt.Sprintf("unsupported actors version: %d", version)) } @@ -194,13 +203,13 @@ type MessageBuilder interface { } // this type is the same between v0 and v2 -type ProposalHashData = msig10.ProposalHashData -type ProposeReturn = msig10.ProposeReturn -type ProposeParams = msig10.ProposeParams -type ApproveReturn = msig10.ApproveReturn +type ProposalHashData = msig11.ProposalHashData +type ProposeReturn = msig11.ProposeReturn +type ProposeParams = msig11.ProposeParams +type ApproveReturn = msig11.ApproveReturn func txnParams(id uint64, data *ProposalHashData) ([]byte, error) { - params := msig10.TxnIDParams{ID: msig10.TxnID(id)} + params := msig11.TxnIDParams{ID: msig11.TxnID(id)} if data != nil { if data.Requester.Protocol() != address.ID { return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester) @@ -234,5 +243,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/multisig/v11.go b/chain/actors/builtin/multisig/v11.go new file mode 100644 index 000000000..3627dc959 --- /dev/null +++ b/chain/actors/builtin/multisig/v11.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" + builtin11 "github.com/filecoin-project/go-state-types/builtin" + msig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) { + out := state11{store: store} + out.State = msig11.State{} + out.State.Signers = signers + out.State.NumApprovalsThreshold = threshold + out.State.StartEpoch = startEpoch + out.State.UnlockDuration = unlockDuration + out.State.InitialBalance = initialBalance + + em, err := adt11.StoreEmptyMap(store, builtin11.DefaultHamtBitwidth) + if err != nil { + return nil, err + } + + out.State.PendingTxns = em + + return &out, nil +} + +type state11 struct { + msig11.State + store adt.Store +} + +func (s *state11) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) { + return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil +} + +func (s *state11) StartEpoch() (abi.ChainEpoch, error) { + return s.State.StartEpoch, nil +} + +func (s *state11) UnlockDuration() (abi.ChainEpoch, error) { + return s.State.UnlockDuration, nil +} + +func (s *state11) InitialBalance() (abi.TokenAmount, error) { + return s.State.InitialBalance, nil +} + +func (s *state11) Threshold() (uint64, error) { + return s.State.NumApprovalsThreshold, nil +} + +func (s *state11) Signers() ([]address.Address, error) { + return s.State.Signers, nil +} + +func (s *state11) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error { + arr, err := adt11.AsMap(s.store, s.State.PendingTxns, builtin11.DefaultHamtBitwidth) + if err != nil { + return err + } + var out msig11.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 *state11) PendingTxnChanged(other State) (bool, error) { + other11, ok := other.(*state11) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.PendingTxns.Equals(other11.PendingTxns), nil +} + +func (s *state11) transactions() (adt.Map, error) { + return adt11.AsMap(s.store, s.PendingTxns, builtin11.DefaultHamtBitwidth) +} + +func (s *state11) decodeTransaction(val *cbg.Deferred) (Transaction, error) { + var tx msig11.Transaction + if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return Transaction{}, err + } + return Transaction(tx), nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) ActorKey() string { + return manifest.MultisigKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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/message11.go b/chain/actors/builtin/paych/message11.go new file mode 100644 index 000000000..7a9ec1c8e --- /dev/null +++ b/chain/actors/builtin/paych/message11.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" + builtin11 "github.com/filecoin-project/go-state-types/builtin" + init11 "github.com/filecoin-project/go-state-types/builtin/v11/init" + paych11 "github.com/filecoin-project/go-state-types/builtin/v11/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 message11 struct{ from address.Address } + +func (m message11) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) { + + actorCodeID, ok := actors.GetActorCodeID(actorstypes.Version11, "paymentchannel") + if !ok { + return nil, xerrors.Errorf("error getting actor paymentchannel code id for actor version %d", 11) + } + + params, aerr := actors.SerializeParams(&paych11.ConstructorParams{From: m.from, To: to}) + if aerr != nil { + return nil, aerr + } + enc, aerr := actors.SerializeParams(&init11.ExecParams{ + CodeCID: actorCodeID, + ConstructorParams: params, + }) + if aerr != nil { + return nil, aerr + } + + return &types.Message{ + To: init_.Address, + From: m.from, + Value: initialAmount, + Method: builtin11.MethodsInit.Exec, + Params: enc, + }, nil +} + +func (m message11) Update(paych address.Address, sv *paychtypes.SignedVoucher, secret []byte) (*types.Message, error) { + params, aerr := actors.SerializeParams(&paych11.UpdateChannelStateParams{ + + Sv: toV11SignedVoucher(*sv), + + Secret: secret, + }) + if aerr != nil { + return nil, aerr + } + + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin11.MethodsPaych.UpdateChannelState, + Params: params, + }, nil +} + +func toV11SignedVoucher(sv paychtypes.SignedVoucher) paych11.SignedVoucher { + merges := make([]paych11.Merge, len(sv.Merges)) + for i := range sv.Merges { + merges[i] = paych11.Merge{ + Lane: sv.Merges[i].Lane, + Nonce: sv.Merges[i].Nonce, + } + } + + return paych11.SignedVoucher{ + ChannelAddr: sv.ChannelAddr, + TimeLockMin: sv.TimeLockMin, + TimeLockMax: sv.TimeLockMax, + SecretHash: sv.SecretHash, + Extra: (*paych11.ModVerifyParams)(sv.Extra), + Lane: sv.Lane, + Nonce: sv.Nonce, + Amount: sv.Amount, + MinSettleHeight: sv.MinSettleHeight, + Merges: merges, + Signature: sv.Signature, + } +} + +func (m message11) Settle(paych address.Address) (*types.Message, error) { + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin11.MethodsPaych.Settle, + }, nil +} + +func (m message11) Collect(paych address.Address) (*types.Message, error) { + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin11.MethodsPaych.Collect, + }, nil +} diff --git a/chain/actors/builtin/paych/paych.go b/chain/actors/builtin/paych/paych.go index 0e6a3ca07..ccf48dbce 100644 --- a/chain/actors/builtin/paych/paych.go +++ b/chain/actors/builtin/paych/paych.go @@ -47,6 +47,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -161,6 +164,9 @@ func Message(version actorstypes.Version, from address.Address) MessageBuilder { case actorstypes.Version10: return message10{from} + case actorstypes.Version11: + return message11{from} + default: panic(fmt.Sprintf("unsupported actors version: %d", version)) } @@ -201,5 +207,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/paych/v11.go b/chain/actors/builtin/paych/v11.go new file mode 100644 index 000000000..977a013f1 --- /dev/null +++ b/chain/actors/builtin/paych/v11.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" + paych11 "github.com/filecoin-project/go-state-types/builtin/v11/paych" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store) (State, error) { + out := state11{store: store} + out.State = paych11.State{} + return &out, nil +} + +type state11 struct { + paych11.State + store adt.Store + lsAmt *adt11.Array +} + +// Channel owner, who has funded the actor +func (s *state11) From() (address.Address, error) { + return s.State.From, nil +} + +// Recipient of payouts from channel +func (s *state11) To() (address.Address, error) { + return s.State.To, nil +} + +// Height at which the channel can be `Collected` +func (s *state11) SettlingAt() (abi.ChainEpoch, error) { + return s.State.SettlingAt, nil +} + +// Amount successfully redeemed through the payment channel, paid out on `Collect()` +func (s *state11) ToSend() (abi.TokenAmount, error) { + return s.State.ToSend, nil +} + +func (s *state11) getOrLoadLsAmt() (*adt11.Array, error) { + if s.lsAmt != nil { + return s.lsAmt, nil + } + + // Get the lane state from the chain + lsamt, err := adt11.AsArray(s.store, s.State.LaneStates, paych11.LaneStatesAmtBitwidth) + if err != nil { + return nil, err + } + + s.lsAmt = lsamt + return lsamt, nil +} + +// Get total number of lanes +func (s *state11) LaneCount() (uint64, error) { + lsamt, err := s.getOrLoadLsAmt() + if err != nil { + return 0, err + } + return lsamt.Length(), nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +// Iterate lane states +func (s *state11) 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 paych11.LaneState + return lsamt.ForEach(&ls, func(i int64) error { + return cb(uint64(i), &laneState11{ls}) + }) +} + +type laneState11 struct { + paych11.LaneState +} + +func (ls *laneState11) Redeemed() (big.Int, error) { + return ls.LaneState.Redeemed, nil +} + +func (ls *laneState11) Nonce() (uint64, error) { + return ls.LaneState.Nonce, nil +} + +func (s *state11) ActorKey() string { + return manifest.PaychKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 6dca61435..f3bcef5bb 100644 --- a/chain/actors/builtin/power/power.go +++ b/chain/actors/builtin/power/power.go @@ -9,7 +9,7 @@ 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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" @@ -27,8 +27,8 @@ import ( ) var ( - Address = builtin10.StoragePowerActorAddr - Methods = builtin10.MethodsPower + Address = builtin11.StoragePowerActorAddr + Methods = builtin11.MethodsPower ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -48,6 +48,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -112,6 +115,9 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version10: return make10(store) + case actorstypes.Version11: + return make11(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -176,5 +182,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/power/v11.go b/chain/actors/builtin/power/v11.go new file mode 100644 index 000000000..0ec1e2bdc --- /dev/null +++ b/chain/actors/builtin/power/v11.go @@ -0,0 +1,207 @@ +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" + builtin11 "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" + + "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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store) (State, error) { + out := state11{store: store} + + s, err := power11.ConstructState(store) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state11 struct { + power11.State + store adt.Store +} + +func (s *state11) TotalLocked() (abi.TokenAmount, error) { + return s.TotalPledgeCollateral, nil +} + +func (s *state11) 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 *state11) TotalCommitted() (Claim, error) { + return Claim{ + RawBytePower: s.TotalBytesCommitted, + QualityAdjPower: s.TotalQABytesCommitted, + }, nil +} + +func (s *state11) MinerPower(addr address.Address) (Claim, bool, error) { + claims, err := s.claims() + if err != nil { + return Claim{}, false, err + } + var claim power11.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 *state11) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) { + return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a) +} + +func (s *state11) TotalPowerSmoothed() (builtin.FilterEstimate, error) { + return builtin.FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil +} + +func (s *state11) MinerCounts() (uint64, uint64, error) { + return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil +} + +func (s *state11) 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 *state11) ForEachClaim(cb func(miner address.Address, claim Claim) error) error { + claims, err := s.claims() + if err != nil { + return err + } + + var claim power11.Claim + return claims.ForEach(&claim, func(k string) error { + a, err := address.NewFromBytes([]byte(k)) + if err != nil { + return err + } + return cb(a, Claim{ + RawBytePower: claim.RawBytePower, + QualityAdjPower: claim.QualityAdjPower, + }) + }) +} + +func (s *state11) ClaimsChanged(other State) (bool, error) { + other11, ok := other.(*state11) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.Claims.Equals(other11.State.Claims), nil +} + +func (s *state11) SetTotalQualityAdjPower(p abi.StoragePower) error { + s.State.TotalQualityAdjPower = p + return nil +} + +func (s *state11) SetTotalRawBytePower(p abi.StoragePower) error { + s.State.TotalRawBytePower = p + return nil +} + +func (s *state11) SetThisEpochQualityAdjPower(p abi.StoragePower) error { + s.State.ThisEpochQualityAdjPower = p + return nil +} + +func (s *state11) SetThisEpochRawBytePower(p abi.StoragePower) error { + s.State.ThisEpochRawBytePower = p + return nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) claims() (adt.Map, error) { + return adt11.AsMap(s.store, s.Claims, builtin11.DefaultHamtBitwidth) +} + +func (s *state11) decodeClaim(val *cbg.Deferred) (Claim, error) { + var ci power11.Claim + if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return Claim{}, err + } + return fromV11Claim(ci), nil +} + +func fromV11Claim(v11 power11.Claim) Claim { + return Claim{ + RawBytePower: v11.RawBytePower, + QualityAdjPower: v11.QualityAdjPower, + } +} + +func (s *state11) ActorKey() string { + return manifest.PowerKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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/registry.go b/chain/actors/builtin/registry.go index 4ce48098d..4addbd451 100644 --- a/chain/actors/builtin/registry.go +++ b/chain/actors/builtin/registry.go @@ -26,6 +26,22 @@ import ( reward10 "github.com/filecoin-project/go-state-types/builtin/v10/reward" system10 "github.com/filecoin-project/go-state-types/builtin/v10/system" verifreg10 "github.com/filecoin-project/go-state-types/builtin/v10/verifreg" + account11 "github.com/filecoin-project/go-state-types/builtin/v11/account" + cron11 "github.com/filecoin-project/go-state-types/builtin/v11/cron" + datacap11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + eam11 "github.com/filecoin-project/go-state-types/builtin/v11/eam" + ethaccount11 "github.com/filecoin-project/go-state-types/builtin/v11/ethaccount" + evm11 "github.com/filecoin-project/go-state-types/builtin/v11/evm" + _init11 "github.com/filecoin-project/go-state-types/builtin/v11/init" + market11 "github.com/filecoin-project/go-state-types/builtin/v11/market" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" + paych11 "github.com/filecoin-project/go-state-types/builtin/v11/paych" + placeholder11 "github.com/filecoin-project/go-state-types/builtin/v11/placeholder" + power11 "github.com/filecoin-project/go-state-types/builtin/v11/power" + reward11 "github.com/filecoin-project/go-state-types/builtin/v11/reward" + system11 "github.com/filecoin-project/go-state-types/builtin/v11/system" + verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/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" @@ -377,6 +393,110 @@ func MakeRegistry(av actorstypes.Version) []RegistryEntry { } } + case actorstypes.Version11: + for key, codeID := range codeIDs { + switch key { + case manifest.AccountKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: account11.Methods, + state: new(account11.State), + }) + case manifest.CronKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: cron11.Methods, + state: new(cron11.State), + }) + case manifest.InitKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: _init11.Methods, + state: new(_init11.State), + }) + case manifest.MarketKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: market11.Methods, + state: new(market11.State), + }) + case manifest.MinerKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: miner11.Methods, + state: new(miner11.State), + }) + case manifest.MultisigKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: multisig11.Methods, + state: new(multisig11.State), + }) + case manifest.PaychKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: paych11.Methods, + state: new(paych11.State), + }) + case manifest.PowerKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: power11.Methods, + state: new(power11.State), + }) + case manifest.RewardKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: reward11.Methods, + state: new(reward11.State), + }) + case manifest.SystemKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: system11.Methods, + state: new(system11.State), + }) + case manifest.VerifregKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: verifreg11.Methods, + state: new(verifreg11.State), + }) + case manifest.DatacapKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: datacap11.Methods, + state: new(datacap11.State), + }) + + case manifest.EvmKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: evm11.Methods, + state: new(evm11.State), + }) + case manifest.EamKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: eam11.Methods, + state: nil, + }) + case manifest.PlaceholderKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: placeholder11.Methods, + state: nil, + }) + case manifest.EthAccountKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: ethaccount11.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 01462d680..b0060a217 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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 = builtin10.RewardActorAddr - Methods = builtin10.MethodsReward + Address = builtin11.RewardActorAddr + Methods = builtin11.MethodsReward ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -46,6 +46,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -110,6 +113,9 @@ func MakeState(store adt.Store, av actorstypes.Version, currRealizedPower abi.St case actorstypes.Version10: return make10(store, currRealizedPower) + case actorstypes.Version11: + return make11(store, currRealizedPower) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -152,5 +158,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/reward/v11.go b/chain/actors/builtin/reward/v11.go new file mode 100644 index 000000000..1d6a5fdf4 --- /dev/null +++ b/chain/actors/builtin/reward/v11.go @@ -0,0 +1,120 @@ +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" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + reward11 "github.com/filecoin-project/go-state-types/builtin/v11/reward" + smoothing11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, currRealizedPower abi.StoragePower) (State, error) { + out := state11{store: store} + out.State = *reward11.ConstructState(currRealizedPower) + return &out, nil +} + +type state11 struct { + reward11.State + store adt.Store +} + +func (s *state11) ThisEpochReward() (abi.TokenAmount, error) { + return s.State.ThisEpochReward, nil +} + +func (s *state11) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) { + + return builtin.FilterEstimate{ + PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate, + VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate, + }, nil + +} + +func (s *state11) ThisEpochBaselinePower() (abi.StoragePower, error) { + return s.State.ThisEpochBaselinePower, nil +} + +func (s *state11) TotalStoragePowerReward() (abi.TokenAmount, error) { + return s.State.TotalStoragePowerReward, nil +} + +func (s *state11) EffectiveBaselinePower() (abi.StoragePower, error) { + return s.State.EffectiveBaselinePower, nil +} + +func (s *state11) EffectiveNetworkTime() (abi.ChainEpoch, error) { + return s.State.EffectiveNetworkTime, nil +} + +func (s *state11) CumsumBaseline() (reward11.Spacetime, error) { + return s.State.CumsumBaseline, nil +} + +func (s *state11) CumsumRealized() (reward11.Spacetime, error) { + return s.State.CumsumRealized, nil +} + +func (s *state11) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) { + return miner11.InitialPledgeForPower( + qaPower, + s.State.ThisEpochBaselinePower, + s.State.ThisEpochRewardSmoothed, + smoothing11.FilterEstimate{ + PositionEstimate: networkQAPower.PositionEstimate, + VelocityEstimate: networkQAPower.VelocityEstimate, + }, + circSupply, + ), nil +} + +func (s *state11) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) { + return miner11.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed, + smoothing11.FilterEstimate{ + PositionEstimate: networkQAPower.PositionEstimate, + VelocityEstimate: networkQAPower.VelocityEstimate, + }, + sectorWeight), nil +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) ActorKey() string { + return manifest.RewardKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 c7589efa1..4db8db610 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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 = builtin10.SystemActorAddr + Address = builtin11.SystemActorAddr ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -41,6 +41,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -105,6 +108,9 @@ func MakeState(store adt.Store, av actorstypes.Version, builtinActors cid.Cid) ( case actorstypes.Version10: return make10(store, builtinActors) + case actorstypes.Version11: + return make11(store, builtinActors) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -131,5 +137,6 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/builtin/system/v11.go b/chain/actors/builtin/system/v11.go new file mode 100644 index 000000000..9b92afaf0 --- /dev/null +++ b/chain/actors/builtin/system/v11.go @@ -0,0 +1,72 @@ +package system + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + actorstypes "github.com/filecoin-project/go-state-types/actors" + system11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, builtinActors cid.Cid) (State, error) { + out := state11{store: store} + out.State = system11.State{ + BuiltinActors: builtinActors, + } + return &out, nil +} + +type state11 struct { + system11.State + store adt.Store +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) GetBuiltinActors() cid.Cid { + + return s.State.BuiltinActors + +} + +func (s *state11) SetBuiltinActors(c cid.Cid) error { + + s.State.BuiltinActors = c + return nil + +} + +func (s *state11) ActorKey() string { + return manifest.SystemKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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/v11.go b/chain/actors/builtin/verifreg/v11.go new file mode 100644 index 000000000..d2abde6c9 --- /dev/null +++ b/chain/actors/builtin/verifreg/v11.go @@ -0,0 +1,152 @@ +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" + builtin11 "github.com/filecoin-project/go-state-types/builtin" + adt11 "github.com/filecoin-project/go-state-types/builtin/v11/util/adt" + verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/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 = (*state11)(nil) + +func load11(store adt.Store, root cid.Cid) (State, error) { + out := state11{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make11(store adt.Store, rootKeyAddress address.Address) (State, error) { + out := state11{store: store} + + s, err := verifreg11.ConstructState(store, rootKeyAddress) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state11 struct { + verifreg11.State + store adt.Store +} + +func (s *state11) RootKey() (address.Address, error) { + return s.State.RootKey, nil +} + +func (s *state11) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) { + + return false, big.Zero(), xerrors.Errorf("unsupported in actors v11") + +} + +func (s *state11) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) { + return getDataCap(s.store, actors.Version11, s.verifiers, addr) +} + +func (s *state11) RemoveDataCapProposalID(verifier address.Address, client address.Address) (bool, uint64, error) { + return getRemoveDataCapProposalID(s.store, actors.Version11, s.removeDataCapProposalIDs, verifier, client) +} + +func (s *state11) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error { + return forEachCap(s.store, actors.Version11, s.verifiers, cb) +} + +func (s *state11) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error { + + return xerrors.Errorf("unsupported in actors v11") + +} + +func (s *state11) verifiedClients() (adt.Map, error) { + + return nil, xerrors.Errorf("unsupported in actors v11") + +} + +func (s *state11) verifiers() (adt.Map, error) { + return adt11.AsMap(s.store, s.Verifiers, builtin11.DefaultHamtBitwidth) +} + +func (s *state11) removeDataCapProposalIDs() (adt.Map, error) { + return adt11.AsMap(s.store, s.RemoveDataCapProposalIDs, builtin11.DefaultHamtBitwidth) +} + +func (s *state11) GetState() interface{} { + return &s.State +} + +func (s *state11) GetAllocation(clientIdAddr address.Address, allocationId verifreg9.AllocationId) (*Allocation, bool, error) { + + alloc, ok, err := s.FindAllocation(s.store, clientIdAddr, verifreg11.AllocationId(allocationId)) + return (*Allocation)(alloc), ok, err +} + +func (s *state11) GetAllocations(clientIdAddr address.Address) (map[AllocationId]Allocation, error) { + + v11Map, err := s.LoadAllocationsToMap(s.store, clientIdAddr) + + retMap := make(map[AllocationId]Allocation, len(v11Map)) + for k, v := range v11Map { + retMap[AllocationId(k)] = Allocation(v) + } + + return retMap, err + +} + +func (s *state11) GetClaim(providerIdAddr address.Address, claimId verifreg9.ClaimId) (*Claim, bool, error) { + + claim, ok, err := s.FindClaim(s.store, providerIdAddr, verifreg11.ClaimId(claimId)) + return (*Claim)(claim), ok, err + +} + +func (s *state11) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, error) { + + v11Map, err := s.LoadClaimsToMap(s.store, providerIdAddr) + + retMap := make(map[ClaimId]Claim, len(v11Map)) + for k, v := range v11Map { + retMap[ClaimId(k)] = Claim(v) + } + + return retMap, err + +} + +func (s *state11) ActorKey() string { + return manifest.VerifregKey +} + +func (s *state11) ActorVersion() actorstypes.Version { + return actorstypes.Version11 +} + +func (s *state11) 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 1380a9207..678a776bd 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" - builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "github.com/filecoin-project/go-state-types/builtin" verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" @@ -25,8 +25,8 @@ import ( ) var ( - Address = builtin10.VerifiedRegistryActorAddr - Methods = builtin10.MethodsVerifiedRegistry + Address = builtin11.VerifiedRegistryActorAddr + Methods = builtin11.MethodsVerifiedRegistry ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -46,6 +46,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version10: return load10(store, act.Head) + case actorstypes.Version11: + return load11(store, act.Head) + } } @@ -110,6 +113,9 @@ func MakeState(store adt.Store, av actorstypes.Version, rootKeyAddress address.A case actorstypes.Version10: return make10(store, rootKeyAddress) + case actorstypes.Version11: + return make11(store, rootKeyAddress) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -146,6 +152,7 @@ func AllCodes() []cid.Cid { (&state8{}).Code(), (&state9{}).Code(), (&state10{}).Code(), + (&state11{}).Code(), } } diff --git a/chain/actors/policy/policy.go b/chain/actors/policy/policy.go index eff7ba899..4b90c46a0 100644 --- a/chain/actors/policy/policy.go +++ b/chain/actors/policy/policy.go @@ -7,12 +7,16 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" "github.com/filecoin-project/go-state-types/big" builtin10 "github.com/filecoin-project/go-state-types/builtin" + builtin11 "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" miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner" - paych10 "github.com/filecoin-project/go-state-types/builtin/v10/paych" verifreg10 "github.com/filecoin-project/go-state-types/builtin/v10/verifreg" + market11 "github.com/filecoin-project/go-state-types/builtin/v11/market" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + paych11 "github.com/filecoin-project/go-state-types/builtin/v11/paych" + verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/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" @@ -51,10 +55,10 @@ import ( ) const ( - ChainFinality = miner10.ChainFinality + ChainFinality = miner11.ChainFinality SealRandomnessLookback = ChainFinality - PaychSettleDelay = paych10.SettleDelay - MaxPreCommitRandomnessLookback = builtin10.EpochsInDay + SealRandomnessLookback + PaychSettleDelay = paych11.SettleDelay + MaxPreCommitRandomnessLookback = builtin11.EpochsInDay + SealRandomnessLookback ) // SetSupportedProofTypes sets supported proof types, across all actor versions. @@ -165,11 +169,13 @@ func SetPreCommitChallengeDelay(delay abi.ChainEpoch) { miner10.PreCommitChallengeDelay = delay + miner11.PreCommitChallengeDelay = delay + } // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay. func GetPreCommitChallengeDelay() abi.ChainEpoch { - return miner10.PreCommitChallengeDelay + return miner11.PreCommitChallengeDelay } // SetConsensusMinerMinPower sets the minimum power of an individual miner must @@ -215,6 +221,10 @@ func SetConsensusMinerMinPower(p abi.StoragePower) { policy.ConsensusMinerMinPower = p } + for _, policy := range builtin11.PoStProofPolicies { + policy.ConsensusMinerMinPower = p + } + } // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should @@ -241,6 +251,8 @@ func SetMinVerifiedDealSize(size abi.StoragePower) { verifreg10.MinVerifiedDealSize = size + verifreg11.MinVerifiedDealSize = size + } func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProof) (abi.ChainEpoch, error) { @@ -286,6 +298,10 @@ func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProo return miner10.MaxProveCommitDuration[t], nil + case actorstypes.Version11: + + return miner11.MaxProveCommitDuration[t], nil + default: return 0, xerrors.Errorf("unsupported actors version") } @@ -341,6 +357,11 @@ func SetProviderCollateralSupplyTarget(num, denom big.Int) { Denominator: denom, } + market11.ProviderCollateralSupplyTarget = builtin11.BigFrac{ + Numerator: num, + Denominator: denom, + } + } func DealProviderCollateralBounds( @@ -404,13 +425,18 @@ func DealProviderCollateralBounds( min, max := market10.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) return min, max, nil + case actorstypes.Version11: + + min, max := market11.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 market10.DealDurationBounds(pieceSize) + return market11.DealDurationBounds(pieceSize) } // Sets the challenge window and scales the proving period to match (such that @@ -479,6 +505,13 @@ func SetWPoStChallengeWindow(period abi.ChainEpoch) { // scale it if we're scaling the challenge period. miner10.WPoStDisputeWindow = period * 30 + miner11.WPoStChallengeWindow = period + miner11.WPoStProvingPeriod = period * abi.ChainEpoch(miner11.WPoStPeriodDeadlines) + + // by default, this is 2x finality which is 30 periods. + // scale it if we're scaling the challenge period. + miner11.WPoStDisputeWindow = period * 30 + } func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch { @@ -491,15 +524,15 @@ func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch { } func GetMaxSectorExpirationExtension() abi.ChainEpoch { - return miner10.MaxSectorExpirationExtension + return miner11.MaxSectorExpirationExtension } func GetMinSectorExpiration() abi.ChainEpoch { - return miner10.MinSectorExpiration + return miner11.MinSectorExpiration } func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, error) { - sectorsPerPart, err := builtin10.PoStProofWindowPoStPartitionSectors(p) + sectorsPerPart, err := builtin11.PoStProofWindowPoStPartitionSectors(p) if err != nil { return 0, err } @@ -519,7 +552,7 @@ func GetSectorMaxLifetime(proof abi.RegisteredSealProof, nwVer network.Version) return builtin4.SealProofPoliciesV0[proof].SectorMaxLifetime } - return builtin10.SealProofPoliciesV11[proof].SectorMaxLifetime + return builtin11.SealProofPoliciesV11[proof].SectorMaxLifetime } func GetAddressedSectorsMax(nwVer network.Version) (int, error) { @@ -559,6 +592,9 @@ func GetAddressedSectorsMax(nwVer network.Version) (int, error) { case actorstypes.Version10: return miner10.AddressedSectorsMax, nil + case actorstypes.Version11: + return miner11.AddressedSectorsMax, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -612,6 +648,10 @@ func GetDeclarationsMax(nwVer network.Version) (int, error) { return miner10.DeclarationsMax, nil + case actorstypes.Version11: + + return miner11.DeclarationsMax, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -664,6 +704,10 @@ func AggregateProveCommitNetworkFee(nwVer network.Version, aggregateSize int, ba return miner10.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil + case actorstypes.Version11: + + return miner11.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil + default: return big.Zero(), xerrors.Errorf("unsupported network version") } @@ -716,6 +760,10 @@ func AggregatePreCommitNetworkFee(nwVer network.Version, aggregateSize int, base return miner10.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil + case actorstypes.Version11: + + return miner11.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil + default: return big.Zero(), xerrors.Errorf("unsupported network version") } diff --git a/chain/actors/version.go b/chain/actors/version.go index e50e85a5d..3a5b935bf 100644 --- a/chain/actors/version.go +++ b/chain/actors/version.go @@ -16,7 +16,7 @@ const ({{range .actorVersions}} var LatestVersion = 11 -var Versions = []int{0, 2, 3, 4, 5, 6, 7, 8, 9, 10} +var Versions = []int{0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} const ( Version0 Version = 0 @@ -29,6 +29,7 @@ const ( Version8 Version = 8 Version9 Version = 9 Version10 Version = 10 + Version11 Version = 11 ) /* inline-gen end */ diff --git a/chain/consensus/filcns/upgrades.go b/chain/consensus/filcns/upgrades.go index 4d1ba3af5..7b5fbd858 100644 --- a/chain/consensus/filcns/upgrades.go +++ b/chain/consensus/filcns/upgrades.go @@ -245,6 +245,10 @@ func DefaultUpgradeSchedule() stmgr.UpgradeSchedule { StopWithin: 5, }}, Expensive: true, + }, { + Height: build.UpgradeNV19Height, + Network: network.Version19, + Migration: UpgradeActorsV11, }, } @@ -1698,7 +1702,6 @@ func upgradeActorsV10Common( return newRoot, nil } -//Example upgrade function if upgrade requires only code changes func UpgradeActorsV11(ctx context.Context, sm *stmgr.StateManager, _ stmgr.MigrationCache, _ stmgr.ExecMonitor, root cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) (cid.Cid, error) { oldAv := actorstypes.Version10 newAv := actorstypes.Version11 @@ -1811,6 +1814,7 @@ func LiteMigration(ctx context.Context, bstore blockstore.Blockstore, newActorsM Head: head, Nonce: actorIn.Nonce, Balance: actorIn.Balance, + Address: actorIn.Address, } err = actorsOut.SetActor(addr, &newActor) if err != nil { diff --git a/chain/state/statetree.go b/chain/state/statetree.go index 62d70eff7..7a5908c08 100644 --- a/chain/state/statetree.go +++ b/chain/state/statetree.go @@ -156,7 +156,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: + case network.Version18, network.Version19: return types.StateTreeVersion5, nil default: diff --git a/documentation/en/api-v0-methods-miner.md b/documentation/en/api-v0-methods-miner.md index d18be03f5..969cf82df 100644 --- a/documentation/en/api-v0-methods-miner.md +++ b/documentation/en/api-v0-methods-miner.md @@ -474,7 +474,7 @@ Inputs: ], "Bw==", 10101, - 18 + 19 ] ``` diff --git a/documentation/en/api-v0-methods.md b/documentation/en/api-v0-methods.md index fe639b2f3..c10baca18 100644 --- a/documentation/en/api-v0-methods.md +++ b/documentation/en/api-v0-methods.md @@ -4727,7 +4727,7 @@ Perms: read Inputs: ```json [ - 18 + 19 ] ``` @@ -4742,7 +4742,7 @@ Perms: read Inputs: ```json [ - 18 + 19 ] ``` @@ -6458,7 +6458,7 @@ Inputs: ] ``` -Response: `18` +Response: `19` ### 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 fe5dd542c..5e056e159 100644 --- a/documentation/en/api-v1-unstable-methods.md +++ b/documentation/en/api-v1-unstable-methods.md @@ -6202,7 +6202,7 @@ Perms: read Inputs: ```json [ - 18 + 19 ] ``` @@ -6217,7 +6217,7 @@ Perms: read Inputs: ```json [ - 18 + 19 ] ``` @@ -8016,7 +8016,7 @@ Inputs: ] ``` -Response: `18` +Response: `19` ### StateReadState StateReadState returns the indicated actor's state. diff --git a/extern/filecoin-ffi b/extern/filecoin-ffi index 86eac2161..d2e527cf6 160000 --- a/extern/filecoin-ffi +++ b/extern/filecoin-ffi @@ -1 +1 @@ -Subproject commit 86eac2161f442945bffee3fbfe7d094c20b48dd3 +Subproject commit d2e527cf6881fd4f8a9547f15ffa1674a8004ea3 diff --git a/gen/inlinegen-data.json b/gen/inlinegen-data.json index 8384e749d..ec55f0d52 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], - "latestActorsVersion": 10, + "actorVersions": [0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + "latestActorsVersion": 11, - "networkVersions": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], - "latestNetworkVersion": 18 + "networkVersions": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + "latestNetworkVersion": 19 } diff --git a/itests/kit/ensemble_opts_nv.go b/itests/kit/ensemble_opts_nv.go index 67dcbfd2e..c44dca92f 100644 --- a/itests/kit/ensemble_opts_nv.go +++ b/itests/kit/ensemble_opts_nv.go @@ -49,12 +49,12 @@ func LatestActorsAt(upgradeHeight abi.ChainEpoch) EnsembleOpt { }) /* inline-gen start */ return UpgradeSchedule(stmgr.Upgrade{ - Network: network.Version17, + Network: network.Version18, Height: -1, }, stmgr.Upgrade{ - Network: network.Version18, + Network: network.Version19, Height: upgradeHeight, - Migration: filcns.UpgradeActorsV10, + Migration: filcns.UpgradeActorsV11, }) /* inline-gen end */ } diff --git a/itests/migration_nv19_test.go b/itests/migration_nv19_test.go new file mode 100644 index 000000000..c1a32ccbe --- /dev/null +++ b/itests/migration_nv19_test.go @@ -0,0 +1,83 @@ +package itests + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "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" + "github.com/filecoin-project/go-state-types/manifest" + "github.com/filecoin-project/go-state-types/network" + gstStore "github.com/filecoin-project/go-state-types/store" + + "github.com/filecoin-project/lotus/blockstore" + "github.com/filecoin-project/lotus/chain/actors" + builtin2 "github.com/filecoin-project/lotus/chain/actors/builtin" + "github.com/filecoin-project/lotus/chain/consensus/filcns" + "github.com/filecoin-project/lotus/chain/state" + "github.com/filecoin-project/lotus/chain/stmgr" + "github.com/filecoin-project/lotus/chain/types" + "github.com/filecoin-project/lotus/chain/types/ethtypes" + "github.com/filecoin-project/lotus/chain/vm" + "github.com/filecoin-project/lotus/itests/kit" + "github.com/filecoin-project/lotus/node/impl" +) + +func TestMigrationNV19(t *testing.T) { + kit.QuietMiningLogs() + + nv19epoch := abi.ChainEpoch(100) + testClient, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(), + kit.UpgradeSchedule(stmgr.Upgrade{ + Network: network.Version18, + Height: -1, + }, stmgr.Upgrade{ + Network: network.Version19, + Height: nv19epoch, + Migration: filcns.UpgradeActorsV11, + }, + )) + + ens.InterconnectAll().BeginMining(10 * time.Millisecond) + + clientApi := testClient.FullNode.(*impl.FullNodeAPI) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + testClient.WaitTillChain(ctx, kit.HeightAtLeast(nv19epoch+5)) + + bs := blockstore.NewAPIBlockstore(testClient) + ctxStore := gstStore.WrapBlockStore(ctx, bs) + + currTs, err := clientApi.ChainHead(ctx) + require.NoError(t, err) + + newStateTree, err := state.LoadStateTree(ctxStore, currTs.Blocks()[0].ParentStateRoot) + require.NoError(t, err) + + require.Equal(t, types.StateTreeVersion5, newStateTree.Version()) + + codeIDsv11, ok := actors.GetActorCodeIDsFromManifest(actorstypes.Version11) + require.True(t, ok) + + // check the EAM actor + EAMActor, err := newStateTree.GetActor(builtin.EthereumAddressManagerActorAddr) + require.NoError(t, err) + EAMCodeID, ok := codeIDsv11[manifest.EamKey] + require.True(t, ok) + require.Equal(t, EAMCodeID, EAMActor.Code) + + // check the EthZeroAddress + ethZeroAddr, err := (ethtypes.EthAddress{}).ToFilecoinAddress() + require.NoError(t, err) + ethZeroAddrID, err := newStateTree.LookupID(ethZeroAddr) + require.NoError(t, err) + ethZeroActor, err := newStateTree.GetActor(ethZeroAddrID) + require.NoError(t, err) + require.True(t, builtin2.IsEthAccountActor(ethZeroActor.Code)) + require.Equal(t, vm.EmptyObjectCid, ethZeroActor.Head) +}