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

feat: Introduce nv19 skeleton

Browse Source 
Update to go-state-types v0.11.0-alpha-1

Introduce dummy v11 actor bundles

Make new actors adapters

Add upgrade to Upgrade Schedules

make jen

Update to go-state-types v0.11.0-alpha-2
This commit is contained in:
Aayush 2023-03-29 12:05:42 -04:00
parent 5f91072d4d
commit 3636af4cd9
55 changed files with 2970 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/types.go
View File

@ -339,6 +339,8 @@ type ForkUpgradeParams struct {
UpgradeSkyrHeight abi.ChainEpoch
UpgradeSharkHeight abi.ChainEpoch
UpgradeHyggeHeight abi.ChainEpoch
UpgradeLightningHeight abi.ChainEpoch
UpgradeThunderHeight abi.ChainEpoch
}
type NonceMapType map[address.Address]uint64

BIN
build/actors/v11.tar.zst Normal file
View File

Binary file not shown.

181
build/builtin_actors_gen.go
View File

@ -48,9 +48,32 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzacedylltr57b2n6zpadh4i2c2kis4fzzvhao3kgvfaggrrbqyacew7q"),
"verifiedregistry": MustParseCid("bafk2bzacecjkesz766626ab4svnzpq3jfs26a75vfktlfaku5fjdao2eyiqyq"),
},
}, {
Network: "butterflynet",
Version: 10,
ManifestCid: MustParseCid("bafy2bzaceckjhsggacixv2d377zfdcnuio4hzkveprio3xnhm3gohi3zy3zco"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzacedkt3uzgugcsdrcsyfvizcpyr5eshltmienbyhjne2t7t3ktkihny"),
"cron": MustParseCid("bafk2bzacecrehknegmfnhmhwy2g43cw52mvl7ptfpp44syus4iph7az7uveuq"),
"datacap": MustParseCid("bafk2bzaced4krgbpj4sywcc453l3pygqr4qocc6nxylhztsm4duvkgfwd7vws"),
"eam": MustParseCid("bafk2bzacebn5lyg5pfhjpdlf3r7lnah4x33bhp5afftdgbr4kbpuioytr4bhe"),
"ethaccount": MustParseCid("bafk2bzaceaxyu24a2tbiacfr4p367xjtptrbang4qrh3fx65cojyrzolwyi4u"),
"evm": MustParseCid("bafk2bzacea5bqaubqeuqmpguxrem2pgocjr43wcfi5e3jpw2e3b4o6tcvs746"),
"init": MustParseCid("bafk2bzaceaufptkdg2gc4eq4ijqxtqp7wxwifusxb6kxay3vdz3wr5epqjbho"),
"multisig": MustParseCid("bafk2bzacedp3c26ccw3l7fci4xhedxhqeqevkubuf5okuslq7o7rcqwqfahci"),
"paymentchannel": MustParseCid("bafk2bzacedlmiqvbutz4ebx2mezy3pqj72x2yt4gwea7sf4dv4a4s7xidelok"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzacecrzxiowkhzpgz4rl2pdldzwmmnctuq5zzntqjkgyhyfllo3afb5s"),
"storagemarket": MustParseCid("bafk2bzacebh2q3ofolirt5q2jpx367dfv22aecevsmybba3yhnxfs3foe6c5q"),
"storageminer": MustParseCid("bafk2bzaceavop4j7iwneew6h7p667gvx37baloxilxetwkhsrr26jme6yye5o"),
"storagepower": MustParseCid("bafk2bzacecfblbat4w7jkxx7kjst33lowyb7s6apdnl7fsnpmy5c3jfq5kvye"),
"system": MustParseCid("bafk2bzacebojf25kc5yo7gskdbdgg5f52oppej2jp6nknzlvrww4ue5vkddd2"),
"verifiedregistry": MustParseCid("bafk2bzaceavue3zekq4wmvttck2vgxlcensrsgh5niu5qhna2owejycorftcc"),
},
}, {
Network: "butterflynet",
Version: 10,
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzaceckjhsggacixv2d377zfdcnuio4hzkveprio3xnhm3gohi3zy3zco"),
Actors: map[string]cid.Cid{
@ -109,10 +132,10 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"verifiedregistry": MustParseCid("bafk2bzacebh7dj6j7yi5vadh7lgqjtq42qi2uq4n6zy2g5vjeathacwn2tscu"),
},
}, {
Network: "calibrationnet",
Version: 10,
BundleGitTag: "v10.0.0-rc.1",
ManifestCid: MustParseCid("bafy2bzaced25ta3j6ygs34roprilbtb3f6mxifyfnm7z7ndquaruxzdq3y7lo"),
Network: "calibrationnet",
Version: 10,
ManifestCid: MustParseCid("bafy2bzaced25ta3j6ygs34roprilbtb3f6mxifyfnm7z7ndquaruxzdq3y7lo"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzacebhfuz3sv7duvk653544xsxhdn4lsmy7ol7k6gdgancyctvmd7lnq"),
"cron": MustParseCid("bafk2bzacecw2yjb6ysieffa7lk7xd32b3n4ssowvafolt7eq52lp6lk4lkhji"),
@ -131,6 +154,29 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzacea4mtukm5zazygkdbgdf26cpnwwif5n2no7s6tknpxlwy6fpq3mug"),
"verifiedregistry": MustParseCid("bafk2bzacec67wuchq64k7kgrujguukjvdlsl24pgighqdx5vgjhyk6bycrwnc"),
},
}, {
Network: "calibrationnet",
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzacealnejzebicrebew7e3q2u7prkqeclffcyje2q2w4v4vtz5jqzcto"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzacedmhjxowg3mu3amnrl6pkm35j6xf6kfe2e3yanaw5l5n6fh7426ta"),
"cron": MustParseCid("bafk2bzacear3td3auuvpicn2mqgpodzmiprzjsugdmbnj5w3nwiachh3zjy3o"),
"datacap": MustParseCid("bafk2bzaceaxb3j7yu4w3wixv6t7h7hymtu7xswdrfxo2pgatmajvkmalig7mm"),
"eam": MustParseCid("bafk2bzacecoiy7gqecoag4hpyamfusq4pxjggziiqd6txy566ze4qu7txbfgm"),
"ethaccount": MustParseCid("bafk2bzacebrf2ryqqwzsvtr2q3azyntrhp3okjqyizhqzwce7j4xkv53lpq46"),
"evm": MustParseCid("bafk2bzacedqnoir3exqgjfi5p3s7glqqr54qgussrk6jpv5577rtan463ejm6"),
"init": MustParseCid("bafk2bzacebjkpyrfypyqjiijoceezznhd7gast4zkqpieqlmtl57qxansat6c"),
"multisig": MustParseCid("bafk2bzacebwirewz7usxyclghpo62kfep3lgmhjyabee4hxs5f53vxouli2sk"),
"paymentchannel": MustParseCid("bafk2bzacecoxwjjmpnpkhm3vdqz2o6azo4l5myaktkdn6bga24qdprlqchgck"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzacecsdqppgzyt5cveuoafr3a6x2ec5rdtowgh5hs5hr36tjloa3w7ia"),
"storagemarket": MustParseCid("bafk2bzacecalbkp24len5szr7w7yaiah4ajzpqg5kiqqybahgdrazsinfg7ki"),
"storageminer": MustParseCid("bafk2bzacedj2gw7qjccvg6myqyn7fj6noontw2ag574ndj5gtwejs3qhsgsq2"),
"storagepower": MustParseCid("bafk2bzacedw2hcinaswhl2m4quy345i35qfc425ctynukmawrctdxhhauaq5g"),
"system": MustParseCid("bafk2bzaceaved6ikzlaj5is6tadl42b256aghs4fw3u4k33n44ycbcy5zofhk"),
"verifiedregistry": MustParseCid("bafk2bzaceayyax5mvtzs65cuhx4txlt7o2ptqglj3i45sccxxm6mx4g2nsbb6"),
},
}, {
Network: "caterpillarnet",
Version: 8,
@ -177,9 +223,32 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzacecl7gizbe52xj6sfm5glubkhrdblmzuwlid6lxrwr5zhcmv4dl2ew"),
"verifiedregistry": MustParseCid("bafk2bzacebzndvdqtdck2y35smcxezldgh6nm6rbkj3g3fmiknsgg2uah235y"),
},
}, {
Network: "caterpillarnet",
Version: 10,
ManifestCid: MustParseCid("bafy2bzaceajftd7jawqnwf4kzkotksrwy6ag7mu2apkvypzrrmxboheuum5oi"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzacecsbx4tovnr5x2ifcpqbpx33oht74mgtvmaauzrqcq2wnm7prr7ak"),
"cron": MustParseCid("bafk2bzacecpzfajba6m4v4ty342jw6lcu6n63bwtldmzko733wpd2q5jzfdvu"),
"datacap": MustParseCid("bafk2bzaceaa5zplkxvguwvnecfen62buhli5rraa3ga74b33a3sbscanzx4ok"),
"eam": MustParseCid("bafk2bzaceaffoa3eqmj7h53lwjatfqrjw63l3czk3vthyjz6oyhgwka3xwp6g"),
"ethaccount": MustParseCid("bafk2bzaceb7suh5m4xagoq6ap5v5x7vrhex2coq6gu6d54jteblm36cxhk5b2"),
"evm": MustParseCid("bafk2bzaceccmwmnb42pn7y7skbjwjur7b2eqxuw4lvm3he2xpvudjzluss4os"),
"init": MustParseCid("bafk2bzaceai72h4hxbgbp6gwm3m24uujscrj4bmbh6pxoerqtduijxt6dchfq"),
"multisig": MustParseCid("bafk2bzacebycdokda2gysqpnl3dwksgidujgsksf4n6qotjq4erj5zd7clkzy"),
"paymentchannel": MustParseCid("bafk2bzaceb5ucvftftiim6cxjusdpsmbht4x33kgexxgv5447gevk47h7jjqk"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzaceajqygfkhamlzfsquqjgoy4p7pc2fruouqajapfucf22rbmtt5yf6"),
"storagemarket": MustParseCid("bafk2bzacednmzko2o5iv5kc6qxvpqfx5rq72krxzvna6cqoqem6flbfukglby"),
"storageminer": MustParseCid("bafk2bzacedayzz5qw7t7ykycf3a2hp666j5hb23a3mnmgp4xbbpvrx3h3ags4"),
"storagepower": MustParseCid("bafk2bzacedd3eiejzp35xuwjf3cvgd43b5ukqhelqmtgzqzqnt2wcy56pb744"),
"system": MustParseCid("bafk2bzacecfivztuulqqv4o5oyvvvrkblwix4hqt24pqru6ivnpioefhuhria"),
"verifiedregistry": MustParseCid("bafk2bzacecdhw6x7dfrxfysmn6tdbn2ny464omgqppxhjuawxauscidppd7pc"),
},
}, {
Network: "caterpillarnet",
Version: 10,
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzaceajftd7jawqnwf4kzkotksrwy6ag7mu2apkvypzrrmxboheuum5oi"),
Actors: map[string]cid.Cid{
@ -237,9 +306,32 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzacebgafb6h2o2g5whrujc2uvsttrussyc5t56rvhrjqkqhzdu4jopwa"),
"verifiedregistry": MustParseCid("bafk2bzacednorhcy446agy7ecpmfms2u4aoa3mj2eqomffuoerbik5yavrxyi"),
},
}, {
Network: "devnet",
Version: 10,
ManifestCid: MustParseCid("bafy2bzacebzz376j5kizfck56366kdz5aut6ktqrvqbi3efa2d4l2o2m653ts"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzacedkj5dqs5xxamnlug2d5dyjl6askf7wlmvwzhmsrzcvogv7acqfe6"),
"cron": MustParseCid("bafk2bzaceabslrigld2vshng6sppbp3bsptjtttvbxctwqe5lkyl2efom2wu4"),
"datacap": MustParseCid("bafk2bzaceagg4qklzhhg5oj4shwqpoeykeyxus7xhj2abuot2tycdwsf2oaaa"),
"eam": MustParseCid("bafk2bzaceafttsbglcetxwtzqtdniittwczogkefgnxztgsp7mymcpvdlhdik"),
"ethaccount": MustParseCid("bafk2bzacedypn6tf3yrj4bavmscddygeima3puih37fbkxuhjhlrzbjh3dbo4"),
"evm": MustParseCid("bafk2bzacec5ywczgg73fnwi36nlxso3zduop3fwj3pq6ynn5zltrs4dpcwglg"),
"init": MustParseCid("bafk2bzacebkanlbkwwtniyz4fawevnkoyje67l5nflltmciplqiutekxzzfh4"),
"multisig": MustParseCid("bafk2bzacectxa2izvpaybmmpvearekrybxtglctwnexzzneyn6xrnrmectmpa"),
"paymentchannel": MustParseCid("bafk2bzacectov7vawkhsvq7aobyjq3oppamytq425wpkxejmq65vvcdm4bt2e"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzacec3xpbrxw2rnpuve4mxfhny44lxbpbwmduy4ula4ohj2bp6wplpvc"),
"storagemarket": MustParseCid("bafk2bzacec5nexsejraoqraywka7zcacjoxgpdbopehdkhiwqwcyghtof4s3w"),
"storageminer": MustParseCid("bafk2bzacecw5xzj6z5b7qxx5xca5py4aoecmqj2pxb6nw673alufy22zckkyo"),
"storagepower": MustParseCid("bafk2bzaceckhnpxoaanjf474wxzkntlnzdofoy75ehyuydfjkuw4swhotws4y"),
"system": MustParseCid("bafk2bzaceairk5qz5hyzt4yyaxa356aszyifswiust5ilxizwxujcmtzvjzoa"),
"verifiedregistry": MustParseCid("bafk2bzaced2mkyqobpgna5jevosym3adv2bvraggigyz2jgn5cxymirxj4x3i"),
},
}, {
Network: "devnet",
Version: 10,
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzacebzz376j5kizfck56366kdz5aut6ktqrvqbi3efa2d4l2o2m653ts"),
Actors: map[string]cid.Cid{
@ -320,9 +412,32 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzaceagvlo2jtahj7dloshrmwfulrd6e2izqev32qm46eumf754weec6c"),
"verifiedregistry": MustParseCid("bafk2bzacecf3yodlyudzukumehbuabgqljyhjt5ifiv4vetcfohnvsxzynwga"),
},
}, {
Network: "mainnet",
Version: 10,
ManifestCid: MustParseCid("bafy2bzacecsuyf7mmvrhkx2evng5gnz5canlnz2fdlzu2lvcgptiq2pzuovos"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzaceampw4romta75hyz5p4cqriypmpbgnkxncgxgqn6zptv5lsp2w2bo"),
"cron": MustParseCid("bafk2bzacedcbtsifegiu432m5tysjzkxkmoczxscb6hqpmrr6img7xzdbbs2g"),
"datacap": MustParseCid("bafk2bzacealj5uk7wixhvk7l5tnredtelralwnceafqq34nb2lbylhtuyo64u"),
"eam": MustParseCid("bafk2bzacedrpm5gbleh4xkyo2jvs7p5g6f34soa6dpv7ashcdgy676snsum6g"),
"ethaccount": MustParseCid("bafk2bzaceaqoc5zakbhjxn3jljc4lxnthllzunhdor7sxhwgmskvc6drqc3fa"),
"evm": MustParseCid("bafk2bzaceahmzdxhqsm7cu2mexusjp6frm7r4kdesvti3etv5evfqboos2j4g"),
"init": MustParseCid("bafk2bzaced2f5rhir3hbpqbz5ght7ohv2kgj42g5ykxrypuo2opxsup3ykwl6"),
"multisig": MustParseCid("bafk2bzaceduf3hayh63jnl4z2knxv7cnrdenoubni22fxersc4octlwpxpmy4"),
"paymentchannel": MustParseCid("bafk2bzaceartlg4mrbwgzcwric6mtvyawpbgx2xclo2vj27nna57nxynf3pgc"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzacebnhtaejfjtzymyfmbdrfmo7vgj3zsof6zlucbmkhrvcuotw5dxpq"),
"storagemarket": MustParseCid("bafk2bzaceclejwjtpu2dhw3qbx6ow7b4pmhwa7ocrbbiqwp36sq5yeg6jz2bc"),
"storageminer": MustParseCid("bafk2bzaced4h7noksockro7glnssz2jnmo2rpzd7dvnmfs4p24zx3h6gtx47s"),
"storagepower": MustParseCid("bafk2bzacec4ay4crzo73ypmh7o3fjendhbqrxake46bprabw67fvwjz5q6ixq"),
"system": MustParseCid("bafk2bzacedakk5nofebyup4m7nvx6djksfwhnxzrfuq4oyemhpl4lllaikr64"),
"verifiedregistry": MustParseCid("bafk2bzacedfel6edzqpe5oujno7fog4i526go4dtcs6vwrdtbpy2xq6htvcg6"),
},
}, {
Network: "mainnet",
Version: 10,
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzacecsuyf7mmvrhkx2evng5gnz5canlnz2fdlzu2lvcgptiq2pzuovos"),
Actors: map[string]cid.Cid{
@ -380,9 +495,32 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzacedo4pu3iwx2gu72hinsstpiokhl5iicnb3rumzffsnhy7zhmnxhyy"),
"verifiedregistry": MustParseCid("bafk2bzaceatmqip2o3ausbntvdhj7yemu6hb3b5yqv6hm42gylbbmz7geocpm"),
},
}, {
Network: "testing",
Version: 10,
ManifestCid: MustParseCid("bafy2bzacebsp3bkxwsijenqeimhvhtg52d6o76hn6qhzxveqfq7d5hdd5l2ee"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzaceazxb6p2xg6caivmie6k2bvutyesngwyvhwv4eemwu7ia4vnqkcuy"),
"cron": MustParseCid("bafk2bzaceax6ym73boyl5zdpbcr6zmbajzylmcdvlapz5zcqgzcshakz44jbq"),
"datacap": MustParseCid("bafk2bzacea63x3v6lvtb4ast5uq3nhrpokvylymvezyr5xyjl6vtlfwkuw6qo"),
"eam": MustParseCid("bafk2bzacebhualcn7fofyqr6lhrel32ud23hcwzeenfqu3rrn5nmt6gugqgo6"),
"ethaccount": MustParseCid("bafk2bzacecgft7e3v4kbpb3tlt5s6hng74ptu3ggcdi4wmt5p4vr6qkmkw2zc"),
"evm": MustParseCid("bafk2bzaceaoqvbqetgicqpvwvcnpjx5aa74kwlhq3u7mwv4yseszxkimwz5pk"),
"init": MustParseCid("bafk2bzaceapmoyg2qppzle24t25ncyycn2uwhnw6crqkqlokkbc7w4mn74wko"),
"multisig": MustParseCid("bafk2bzacecn3dlepgaps3h6iwlq65dx6zyrbfi4pmgdqxphb5idubb6ibflwe"),
"paymentchannel": MustParseCid("bafk2bzaceaanxurr2k3ueolwcnminmdfp3tyxtntqg5fou37smeulb5dxqjzk"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzacedujdvwk4omjexdnmh2qrkqbw27v4c2g3krajhtzyfzart36bimum"),
"storagemarket": MustParseCid("bafk2bzacecdbjjxvdtltobiu7thwyyr2puunoz3q4vyfnhhxl2sbp4ovwq37s"),
"storageminer": MustParseCid("bafk2bzacebo5q7jrf4qjrhtotwt5ouzlygvml4bzofs2egdnbxyfmuo7tro6c"),
"storagepower": MustParseCid("bafk2bzacebt2ipqnorxbzncwjadkulip6blzksmwd4mmyrfjsmjyf55itra2k"),
"system": MustParseCid("bafk2bzacecf2jimdz7knhngs64ximfz3eaud6s3kiunmkybgrkupdjyo2dw7o"),
"verifiedregistry": MustParseCid("bafk2bzacecdmek2htsgcyoyl35glakyab66cojqo2y335njnm7krleb6yfbps"),
},
}, {
Network: "testing",
Version: 10,
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzacebsp3bkxwsijenqeimhvhtg52d6o76hn6qhzxveqfq7d5hdd5l2ee"),
Actors: map[string]cid.Cid{
@ -440,9 +578,32 @@ var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMet
"system": MustParseCid("bafk2bzacedo4pu3iwx2gu72hinsstpiokhl5iicnb3rumzffsnhy7zhmnxhyy"),
"verifiedregistry": MustParseCid("bafk2bzaceatmqip2o3ausbntvdhj7yemu6hb3b5yqv6hm42gylbbmz7geocpm"),
},
}, {
Network: "testing-fake-proofs",
Version: 10,
ManifestCid: MustParseCid("bafy2bzacedwap2uuii4luljckrnb4vkur2unb6fyinn7xjie6xlva2wmlygj2"),
Actors: map[string]cid.Cid{
"account": MustParseCid("bafk2bzaceazxb6p2xg6caivmie6k2bvutyesngwyvhwv4eemwu7ia4vnqkcuy"),
"cron": MustParseCid("bafk2bzaceax6ym73boyl5zdpbcr6zmbajzylmcdvlapz5zcqgzcshakz44jbq"),
"datacap": MustParseCid("bafk2bzacea63x3v6lvtb4ast5uq3nhrpokvylymvezyr5xyjl6vtlfwkuw6qo"),
"eam": MustParseCid("bafk2bzacebhualcn7fofyqr6lhrel32ud23hcwzeenfqu3rrn5nmt6gugqgo6"),
"ethaccount": MustParseCid("bafk2bzacecgft7e3v4kbpb3tlt5s6hng74ptu3ggcdi4wmt5p4vr6qkmkw2zc"),
"evm": MustParseCid("bafk2bzaceaoqvbqetgicqpvwvcnpjx5aa74kwlhq3u7mwv4yseszxkimwz5pk"),
"init": MustParseCid("bafk2bzaceapmoyg2qppzle24t25ncyycn2uwhnw6crqkqlokkbc7w4mn74wko"),
"multisig": MustParseCid("bafk2bzacecn3dlepgaps3h6iwlq65dx6zyrbfi4pmgdqxphb5idubb6ibflwe"),
"paymentchannel": MustParseCid("bafk2bzaceaanxurr2k3ueolwcnminmdfp3tyxtntqg5fou37smeulb5dxqjzk"),
"placeholder": MustParseCid("bafk2bzacedfvut2myeleyq67fljcrw4kkmn5pb5dpyozovj7jpoez5irnc3ro"),
"reward": MustParseCid("bafk2bzacedujdvwk4omjexdnmh2qrkqbw27v4c2g3krajhtzyfzart36bimum"),
"storagemarket": MustParseCid("bafk2bzacecdbjjxvdtltobiu7thwyyr2puunoz3q4vyfnhhxl2sbp4ovwq37s"),
"storageminer": MustParseCid("bafk2bzacedc5klueery4fn2voso4u76rgo54uctsculesdbxxbeh6rgp2q4te"),
"storagepower": MustParseCid("bafk2bzacecuz2h2renlfio4xkyrvvro7nwidf7utpjy3oizk2xuszoz3gmea6"),
"system": MustParseCid("bafk2bzacecf2jimdz7knhngs64ximfz3eaud6s3kiunmkybgrkupdjyo2dw7o"),
"verifiedregistry": MustParseCid("bafk2bzacecdmek2htsgcyoyl35glakyab66cojqo2y335njnm7krleb6yfbps"),
},
}, {
Network: "testing-fake-proofs",
Version: 10,
Version: 11,
BundleGitTag: "v10.0.0",
ManifestCid: MustParseCid("bafy2bzacedwap2uuii4luljckrnb4vkur2unb6fyinn7xjie6xlva2wmlygj2"),
Actors: map[string]cid.Cid{

BIN
build/openrpc/full.json.gz
View File

Binary file not shown.

8
build/params_2k.go
View File

@ -59,7 +59,11 @@ var UpgradeSkyrHeight = abi.ChainEpoch(-19)
var UpgradeSharkHeight = abi.ChainEpoch(-20)
var UpgradeHyggeHeight = abi.ChainEpoch(30)
var UpgradeHyggeHeight = abi.ChainEpoch(-21)
var UpgradeLightningHeight = 30
var UpgradeThunderHeight = 1000
var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
0: DrandMainnet,
@ -114,6 +118,8 @@ func init() {
UpgradeSkyrHeight = getUpgradeHeight("LOTUS_SKYR_HEIGHT", UpgradeSkyrHeight)
UpgradeSharkHeight = getUpgradeHeight("LOTUS_SHARK_HEIGHT", UpgradeSharkHeight)
UpgradeHyggeHeight = getUpgradeHeight("LOTUS_HYGGE_HEIGHT", UpgradeHyggeHeight)
UpgradeLightningHeight = getUpgradeHeight("LOTUS_LIGHTNING_HEIGHT", UpgradeLightningHeight)
UpgradeThunderHeight = getUpgradeHeight("LOTUS_THUNDER_HEIGHT", UpgradeThunderHeight)
BuildType |= Build2k

6
build/params_butterfly.go
View File

@ -53,6 +53,12 @@ const UpgradeSkyrHeight = -19
const UpgradeSharkHeight = abi.ChainEpoch(-20)
const UpgradeHyggeHeight = abi.ChainEpoch(600)
// ??????????
const UpgradeLightningHeight = 999999999999999
// ??????????????????
const UpgradeThunderHeight = UpgradeLightningHeight + 1
var SupportedProofTypes = []abi.RegisteredSealProof{
abi.RegisteredSealProof_StackedDrg512MiBV1,
abi.RegisteredSealProof_StackedDrg32GiBV1,

6
build/params_calibnet.go
View File

@ -73,6 +73,12 @@ const UpgradeSharkHeight = 16800 // 6 days after genesis
// 2023-02-21T16:30:00Z
const UpgradeHyggeHeight = 322354
// ??????????
const UpgradeLightningHeight = 999999999999999
// ??????????????????
const UpgradeThunderHeight = UpgradeLightningHeight + 1
var SupportedProofTypes = []abi.RegisteredSealProof{
abi.RegisteredSealProof_StackedDrg32GiBV1,
abi.RegisteredSealProof_StackedDrg64GiBV1,

8
build/params_interop.go
View File

@ -52,7 +52,13 @@ var UpgradeSkyrHeight = abi.ChainEpoch(-19)
const UpgradeSharkHeight = abi.ChainEpoch(-20)
const UpgradeHyggeHeight = abi.ChainEpoch(99999999999999)
const UpgradeHyggeHeight = abi.ChainEpoch(100)
// ??????????
const UpgradeLightningHeight = 200
// ??????????????????
const UpgradeThunderHeight = 300
var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
0: DrandMainnet,

16
build/params_mainnet.go
View File

@ -87,7 +87,13 @@ const UpgradeSkyrHeight = 1960320
const UpgradeSharkHeight = 2383680
// 2023-03-14T15:14:00Z
var UpgradeHyggeHeight = abi.ChainEpoch(2683348)
const UpgradeHyggeHeight = 2683348
// ??????????
var UpgradeLightningHeight = abi.ChainEpoch(9999999999)
// ??????????
var UpgradeThunderHeight = UpgradeLightningHeight + 1
var SupportedProofTypes = []abi.RegisteredSealProof{
abi.RegisteredSealProof_StackedDrg32GiBV1,
@ -102,8 +108,12 @@ func init() {
SetAddressNetwork(address.Mainnet)
}
if os.Getenv("LOTUS_DISABLE_HYGGE") == "1" {
UpgradeHyggeHeight = math.MaxInt64
if os.Getenv("LOTUS_DISABLE_LIGHTNING") == "1" {
UpgradeLightningHeight = math.MaxInt64
}
if os.Getenv("LOTUS_DISABLE_THUNDER") == "1" {
UpgradeThunderHeight = math.MaxInt64
}
// NOTE: DO NOT change this unless you REALLY know what you're doing. This is not consensus critical, however,

15
build/params_shared_vals.go
View File

@ -26,16 +26,17 @@ const UnixfsLinksPerLevel = 1024
const AllowableClockDriftSecs = uint64(1)
// Used by tests and some obscure tooling
/* inline-gen template
const TestNetworkVersion = network.Version{{.latestNetworkVersion}}
/* inline-gen start */
// TODO: nv19: Re-enable when migration is setup
//// Used by tests and some obscure tooling
///* inline-gen template
//
//const TestNetworkVersion = network.Version{{.latestNetworkVersion}}
//
///* inline-gen start */
const TestNetworkVersion = network.Version18
/* inline-gen end */
///* inline-gen end */
// Epochs
const ForkLengthThreshold = Finality

2
build/params_testground.go
View File

@ -106,6 +106,8 @@ var (
UpgradeSkyrHeight abi.ChainEpoch = -18
UpgradeSharkHeight abi.ChainEpoch = -19
UpgradeHyggeHeight abi.ChainEpoch = -20
UpgradeLightningHeight abi.ChainEpoch = -21
UpgradeThunderHeight abi.ChainEpoch = -22
DrandSchedule = map[abi.ChainEpoch]DrandEnum{
0: DrandMainnet,

11
chain/actors/builtin/account/account.go
View File

@ -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(),
}
}

62
chain/actors/builtin/account/v11.go generated Normal file
View File

@ -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
}

13
chain/actors/builtin/cron/cron.go
View File

@ -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(),
}
}

57
chain/actors/builtin/cron/v11.go generated Normal file
View File

@ -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
}

13
chain/actors/builtin/datacap/datacap.go
View File

@ -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(),
}
}

82
chain/actors/builtin/datacap/v11.go generated Normal file
View File

@ -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
}

10
chain/actors/builtin/evm/evm.go
View File

@ -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)
}

72
chain/actors/builtin/evm/v11.go generated Normal file
View File

@ -0,0 +1,72 @@
package evm
import (
"github.com/ipfs/go-cid"
"github.com/filecoin-project/go-state-types/abi"
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) IsAlive() (bool, error) {
return s.State.Tombstone == nil, nil
}
func (s *state11) GetState() interface{} {
return &s.State
}
func (s *state11) GetBytecodeCID() (cid.Cid, error) {
return s.State.Bytecode, nil
}
func (s *state11) GetBytecodeHash() ([32]byte, error) {
return s.State.BytecodeHash, nil
}
func (s *state11) GetBytecode() ([]byte, error) {
bc, err := s.GetBytecodeCID()
if err != nil {
return nil, err
}
var byteCode abi.CborBytesTransparent
if err := s.store.Get(s.store.Context(), bc, &byteCode); err != nil {
return nil, err
}
return byteCode, nil
}

13
chain/actors/builtin/init/init.go
View File

@ -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(),
}
}

147
chain/actors/builtin/init/v11.go generated Normal file
View File

@ -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
}

10
chain/actors/builtin/market/market.go
View File

@ -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(),
}
}

377
chain/actors/builtin/market/v11.go generated Normal file
View File

@ -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
}

7
chain/actors/builtin/miner/miner.go
View File

@ -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(),
}
}

591
chain/actors/builtin/miner/v11.go generated Normal file
View File

@ -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
}

4
chain/actors/builtin/multisig/message10.go generated
View File

@ -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,
}

77
chain/actors/builtin/multisig/message11.go generated Normal file
View File

@ -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
}

4
chain/actors/builtin/multisig/message8.go generated
View File

@ -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,
}

4
chain/actors/builtin/multisig/message9.go generated
View File

@ -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,
}

24
chain/actors/builtin/multisig/multisig.go
View File

@ -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(),
}
}

138
chain/actors/builtin/multisig/v11.go generated Normal file
View File

@ -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
}

109
chain/actors/builtin/paych/message11.go generated Normal file
View File

@ -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
}

7
chain/actors/builtin/paych/paych.go
View File

@ -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(),
}
}

135
chain/actors/builtin/paych/v11.go generated Normal file
View File

@ -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
}

13
chain/actors/builtin/power/power.go
View File

@ -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(),
}
}

207
chain/actors/builtin/power/v11.go generated Normal file
View File

@ -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
}

120
chain/actors/builtin/registry.go
View File

@ -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")
}

13
chain/actors/builtin/reward/reward.go
View File

@ -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(),
}
}

120
chain/actors/builtin/reward/v11.go generated Normal file
View File

@ -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
}

11
chain/actors/builtin/system/system.go
View File

@ -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(),
}
}

72
chain/actors/builtin/system/v11.go generated Normal file
View File

@ -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
}

152
chain/actors/builtin/verifreg/v11.go generated Normal file
View File

@ -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
}

13
chain/actors/builtin/verifreg/verifreg.go generated
View File

@ -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(),
}
}

68
chain/actors/policy/policy.go
View File

@ -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")
}

5
chain/actors/version.go
View File

@ -14,9 +14,9 @@ const ({{range .actorVersions}}
/* inline-gen start */
var LatestVersion = 10
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 */

8
chain/consensus/filcns/upgrades.go
View File

@ -245,6 +245,14 @@ func DefaultUpgradeSchedule() stmgr.UpgradeSchedule {
StopWithin: 5,
}},
Expensive: true,
}, {
Height: build.UpgradeLightningHeight,
Network: network.Version19,
Migration: nil,
}, {
Height: build.UpgradeThunderHeight,
Network: network.Version20,
Migration: nil,
},
}

2
chain/state/statetree.go
View File

@ -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, network.Version20:
return types.StateTreeVersion5, nil
default:

4
documentation/en/api-v0-methods.md
View File

@ -5534,7 +5534,9 @@ Response:
"UpgradeOhSnapHeight": 10101,
"UpgradeSkyrHeight": 10101,
"UpgradeSharkHeight": 10101,
"UpgradeHyggeHeight": 10101
"UpgradeHyggeHeight": 10101,
"UpgradeLightningHeight": 10101,
"UpgradeThunderHeight": 10101
}
}
```

4
documentation/en/api-v1-unstable-methods.md
View File

@ -6879,7 +6879,9 @@ Response:
"UpgradeOhSnapHeight": 10101,
"UpgradeSkyrHeight": 10101,
"UpgradeSharkHeight": 10101,
"UpgradeHyggeHeight": 10101
"UpgradeHyggeHeight": 10101,
"UpgradeLightningHeight": 10101,
"UpgradeThunderHeight": 10101
}
}
```

2
documentation/misc/actors_version_checklist.md
View File

@ -4,11 +4,9 @@
- [ ] Define upgrade heights in `build/params_`
- [ ] Generate adapters
- [ ] Update `gen/inlinegen-data.json`
- [ ] Update `chain/actors/version.go`
- [ ] Update adapter code in `chain/actors/builtin` if needed
- [ ] Run `make actors-gen`
- [ ] Update `chain/consensus/filcns/upgrades.go`
- [ ] Schedule
- [ ] Migration
- [ ] Update upgrade schedule in `chain/sync_test.go`
- [ ] Add upgrade field to `api/types.go/ForkUpgradeParams` and update the implementation of StateGetNetworkParams

8
gen/inlinegen-data.json
View File

@ -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, 20],
"latestNetworkVersion": 20
}

2
go.mod
View File

@ -46,7 +46,7 @@ require (
github.com/filecoin-project/go-legs v0.4.4
github.com/filecoin-project/go-padreader v0.0.1
github.com/filecoin-project/go-paramfetch v0.0.4
github.com/filecoin-project/go-state-types v0.10.0
github.com/filecoin-project/go-state-types v0.11.0-alpha-2
github.com/filecoin-project/go-statemachine v1.0.2
github.com/filecoin-project/go-statestore v0.2.0
github.com/filecoin-project/go-storedcounter v0.1.0

4
go.sum
View File

@ -356,8 +356,8 @@ github.com/filecoin-project/go-state-types v0.1.0/go.mod h1:ezYnPf0bNkTsDibL/psS
github.com/filecoin-project/go-state-types v0.1.6/go.mod h1:UwGVoMsULoCK+bWjEdd/xLCvLAQFBC7EDT477SKml+Q=
github.com/filecoin-project/go-state-types v0.1.8/go.mod h1:UwGVoMsULoCK+bWjEdd/xLCvLAQFBC7EDT477SKml+Q=
github.com/filecoin-project/go-state-types v0.1.10/go.mod h1:UwGVoMsULoCK+bWjEdd/xLCvLAQFBC7EDT477SKml+Q=
github.com/filecoin-project/go-state-types v0.10.0 h1:vsSThZIaPmOxNGG59+8D/HnlWRtlbdOjduH6ye+v8f0=
github.com/filecoin-project/go-state-types v0.10.0/go.mod h1:aLIas+W8BWAfpLWEPUOGMPBdhcVwoCG4pIQSQk26024=
github.com/filecoin-project/go-state-types v0.11.0-alpha-2 h1:LlJHUV0yL5gcP+8QH5JKIEluYC05d6g0DJot3UP47ZE=
github.com/filecoin-project/go-state-types v0.11.0-alpha-2/go.mod h1:aLIas+W8BWAfpLWEPUOGMPBdhcVwoCG4pIQSQk26024=
github.com/filecoin-project/go-statemachine v0.0.0-20200925024713-05bd7c71fbfe/go.mod h1:FGwQgZAt2Gh5mjlwJUlVB62JeYdo+if0xWxSEfBD9ig=
github.com/filecoin-project/go-statemachine v1.0.2 h1:421SSWBk8GIoCoWYYTE/d+qCWccgmRH0uXotXRDjUbc=
github.com/filecoin-project/go-statemachine v1.0.2/go.mod h1:jZdXXiHa61n4NmgWFG4w8tnqgvZVHYbJ3yW7+y8bF54=

23
itests/kit/ensemble_opts_nv.go
View File

@ -38,16 +38,17 @@ func SDRUpgradeAt(calico, persian abi.ChainEpoch) EnsembleOpt {
}
func LatestActorsAt(upgradeHeight abi.ChainEpoch) EnsembleOpt {
/* inline-gen template
return UpgradeSchedule(stmgr.Upgrade{
Network: network.Version{{add .latestNetworkVersion -1}},
Height: -1,
}, stmgr.Upgrade{
Network: network.Version{{.latestNetworkVersion}},
Height: upgradeHeight,
Migration: filcns.UpgradeActorsV{{.latestActorsVersion}},
})
/* inline-gen start */
// TODO: nv19: Re-enable when migration is setup
///* inline-gen template
// return UpgradeSchedule(stmgr.Upgrade{
// Network: network.Version{{add .latestNetworkVersion -1}},
// Height: -1,
// }, stmgr.Upgrade{
// Network: network.Version{{.latestNetworkVersion}},
// Height: upgradeHeight,
// Migration: filcns.UpgradeActorsV{{.latestActorsVersion}},
// })
///* inline-gen start */
return UpgradeSchedule(stmgr.Upgrade{
Network: network.Version17,
Height: -1,
@ -56,7 +57,7 @@ func LatestActorsAt(upgradeHeight abi.ChainEpoch) EnsembleOpt {
Height: upgradeHeight,
Migration: filcns.UpgradeActorsV10,
})
/* inline-gen end */
///* inline-gen end */
}
func TurboUpgradeAt(upgradeHeight abi.ChainEpoch) EnsembleOpt {

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

@ -1808,6 +1808,8 @@ func (a *StateAPI) StateGetNetworkParams(ctx context.Context) (*api.NetworkParam
UpgradeSkyrHeight: build.UpgradeSkyrHeight,
UpgradeSharkHeight: build.UpgradeSharkHeight,
UpgradeHyggeHeight: build.UpgradeHyggeHeight,
UpgradeLightningHeight: build.UpgradeLightningHeight,
UpgradeThunderHeight: build.UpgradeThunderHeight,
},
}, nil
}