lotus/chain/gen/genesis/genesis.go

581 lines
17 KiB
Go
Raw Normal View History

2020-02-11 20:48:03 +00:00
package genesis
import (
"context"
2020-08-24 18:33:49 +00:00
"crypto/rand"
2020-02-12 00:58:55 +00:00
"encoding/json"
2020-08-18 21:30:49 +00:00
"fmt"
"github.com/filecoin-project/lotus/chain/actors/builtin"
"github.com/filecoin-project/lotus/journal"
2020-02-11 20:48:03 +00:00
"github.com/ipfs/go-cid"
"github.com/ipfs/go-datastore"
cbor "github.com/ipfs/go-ipld-cbor"
logging "github.com/ipfs/go-log/v2"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
2020-07-18 13:46:47 +00:00
2020-09-07 03:49:10 +00:00
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto"
builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/lotus/build"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/types"
2020-05-14 02:32:04 +00:00
"github.com/filecoin-project/lotus/chain/vm"
2020-02-12 00:58:55 +00:00
"github.com/filecoin-project/lotus/genesis"
bstore "github.com/filecoin-project/lotus/lib/blockstore"
2020-07-24 09:34:48 +00:00
"github.com/filecoin-project/lotus/lib/sigs"
2020-02-11 20:48:03 +00:00
)
2020-02-12 00:58:55 +00:00
const AccountStart = 100
const MinerStart = 1000
const MaxAccounts = MinerStart - AccountStart
2020-02-11 20:48:03 +00:00
var log = logging.Logger("genesis")
type GenesisBootstrap struct {
Genesis *types.BlockHeader
}
2020-04-21 21:38:26 +00:00
2020-02-12 00:58:55 +00:00
/*
From a list of parameters, create a genesis block / initial state
The process:
- Bootstrap state (MakeInitialStateTree)
2020-02-12 22:12:11 +00:00
- Create empty state
2020-02-14 21:38:18 +00:00
- Create system actor
2020-02-12 22:12:11 +00:00
- Make init actor
2020-02-12 00:58:55 +00:00
- Create accounts mappings
- Set NextID to MinerStart
- Setup Reward (1.4B fil)
- Setup Cron
2020-02-12 22:12:11 +00:00
- Create empty power actor
2020-02-12 00:58:55 +00:00
- Create empty market
2020-04-21 18:25:43 +00:00
- Create verified registry
2020-02-12 00:58:55 +00:00
- Setup burnt fund address
2020-02-12 22:12:11 +00:00
- Initialize account / msig balances
2020-02-12 00:58:55 +00:00
- Instantiate early vm with genesis syscalls
- Create miners
2020-02-12 22:12:11 +00:00
- Each:
- power.CreateMiner, set msg value to PowerBalance
2020-02-12 00:58:55 +00:00
- market.AddFunds with correct value
2020-02-12 02:13:00 +00:00
- market.PublishDeals for related sectors
2020-06-26 13:23:52 +00:00
- Set network power in the power actor to what we'll have after genesis creation
- Recreate reward actor state with the right power
2020-06-26 13:23:52 +00:00
- For each precommitted sector
- Get deal weight
- Calculate QA Power
- Remove fake power from the power actor
- Calculate pledge
- Precommit
- Confirm valid
2020-02-12 00:58:55 +00:00
Data Types:
PreSeal :{
2020-02-12 22:12:11 +00:00
CommR CID
CommD CID
SectorID SectorNumber
Deal market.DealProposal # Start at 0, self-deal!
2020-02-12 00:58:55 +00:00
}
Genesis: {
Accounts: [ # non-miner, non-singleton actors, max len = MaxAccounts
{
Type: "account" / "multisig",
Value: "attofil",
[Meta: {msig settings, account key..}]
},...
],
Miners: [
{
Owner, Worker Addr # ID
MarketBalance, PowerBalance TokenAmount
SectorSize uint64
PreSeals []PreSeal
},...
],
}
*/
2020-07-28 17:51:47 +00:00
func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template genesis.Template) (*state.StateTree, map[address.Address]address.Address, error) {
2020-02-12 00:58:55 +00:00
// Create empty state tree
cst := cbor.NewCborStore(bs)
2020-02-17 17:19:06 +00:00
_, err := cst.Put(context.TODO(), []struct{}{})
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("putting empty object: %w", err)
2020-02-17 17:19:06 +00:00
}
state, err := state.NewStateTree(cst, types.StateTreeVersion0)
2020-02-12 00:58:55 +00:00
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("making new state tree: %w", err)
2020-02-12 00:58:55 +00:00
}
2020-02-14 21:38:18 +00:00
// Create system actor
sysact, err := SetupSystemActor(bs)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup init actor: %w", err)
2020-02-14 21:38:18 +00:00
}
if err := state.SetActor(builtin0.SystemActorAddr, sysact); err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set init actor: %w", err)
2020-02-14 21:38:18 +00:00
}
2020-02-12 00:58:55 +00:00
// Create init actor
idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
2020-02-12 00:58:55 +00:00
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup init actor: %w", err)
2020-02-12 00:58:55 +00:00
}
if err := state.SetActor(builtin0.InitActorAddr, initact); err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set init actor: %w", err)
2020-02-12 00:58:55 +00:00
}
// Setup reward
// RewardActor's state is overrwritten by SetupStorageMiners
rewact, err := SetupRewardActor(bs, big.Zero())
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup init actor: %w", err)
}
err = state.SetActor(builtin0.RewardActorAddr, rewact)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set network account actor: %w", err)
}
// Setup cron
cronact, err := SetupCronActor(bs)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup cron actor: %w", err)
}
if err := state.SetActor(builtin0.CronActorAddr, cronact); err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set cron actor: %w", err)
}
// Create empty power actor
spact, err := SetupStoragePowerActor(bs)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
}
if err := state.SetActor(builtin0.StoragePowerActorAddr, spact); err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set storage market actor: %w", err)
}
// Create empty market actor
2020-02-12 07:44:20 +00:00
marketact, err := SetupStorageMarketActor(bs)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
}
if err := state.SetActor(builtin0.StorageMarketActorAddr, marketact); err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set market actor: %w", err)
}
2020-04-21 18:25:43 +00:00
// Create verified registry
verifact, err := SetupVerifiedRegistryActor(bs)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
2020-04-21 18:25:43 +00:00
}
if err := state.SetActor(builtin0.VerifiedRegistryActorAddr, verifact); err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set market actor: %w", err)
2020-04-21 18:25:43 +00:00
}
burntRoot, err := cst.Put(ctx, &account0.State{
Address: builtin0.BurntFundsActorAddr,
2020-08-23 01:53:44 +00:00
})
if err != nil {
return nil, nil, xerrors.Errorf("failed to setup burnt funds actor state: %w", err)
}
// Setup burnt-funds
err = state.SetActor(builtin0.BurntFundsActorAddr, &types.Actor{
Code: builtin0.AccountActorCodeID,
Balance: types.NewInt(0),
2020-08-23 01:53:44 +00:00
Head: burntRoot,
})
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("set burnt funds account actor: %w", err)
}
2020-02-12 00:58:55 +00:00
// Create accounts
for _, info := range template.Accounts {
2020-02-12 00:58:55 +00:00
switch info.Type {
case genesis.TAccount:
if err := createAccountActor(ctx, cst, state, info, keyIDs); err != nil {
return nil, nil, xerrors.Errorf("failed to create account actor: %w", err)
}
case genesis.TMultisig:
ida, err := address.NewIDAddress(uint64(idStart))
if err != nil {
return nil, nil, err
}
idStart++
2020-02-12 00:58:55 +00:00
if err := createMultisigAccount(ctx, bs, cst, state, ida, info, keyIDs); err != nil {
return nil, nil, err
}
default:
return nil, nil, xerrors.New("unsupported account type")
2020-02-12 00:58:55 +00:00
}
}
2020-05-14 02:32:04 +00:00
vregroot, err := address.NewIDAddress(80)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, err
2020-05-14 02:32:04 +00:00
}
if err = createMultisigAccount(ctx, bs, cst, state, vregroot, template.VerifregRootKey, keyIDs); err != nil {
return nil, nil, xerrors.Errorf("failed to set up verified registry signer: %w", err)
2020-05-14 02:32:04 +00:00
}
2020-07-23 20:44:09 +00:00
// Setup the first verifier as ID-address 81
// TODO: remove this
skBytes, err := sigs.Generate(crypto.SigTypeBLS)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("creating random verifier secret key: %w", err)
2020-07-23 20:44:09 +00:00
}
verifierPk, err := sigs.ToPublic(crypto.SigTypeBLS, skBytes)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("creating random verifier public key: %w", err)
2020-07-23 20:44:09 +00:00
}
verifierAd, err := address.NewBLSAddress(verifierPk)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("creating random verifier address: %w", err)
2020-07-23 20:44:09 +00:00
}
verifierId, err := address.NewIDAddress(81)
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, err
2020-07-23 20:44:09 +00:00
}
verifierState, err := cst.Put(ctx, &account0.State{Address: verifierAd})
2020-07-23 20:44:09 +00:00
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, err
2020-07-23 20:44:09 +00:00
}
err = state.SetActor(verifierId, &types.Actor{
Code: builtin0.AccountActorCodeID,
2020-07-23 20:44:09 +00:00
Balance: types.NewInt(0),
Head: verifierState,
})
if err != nil {
2020-07-28 17:51:47 +00:00
return nil, nil, xerrors.Errorf("setting account from actmap: %w", err)
2020-07-23 20:44:09 +00:00
}
totalFilAllocated := big.Zero()
// flush as ForEach works on the HAMT
if _, err := state.Flush(ctx); err != nil {
return nil, nil, err
}
err = state.ForEach(func(addr address.Address, act *types.Actor) error {
totalFilAllocated = big.Add(totalFilAllocated, act.Balance)
return nil
})
if err != nil {
return nil, nil, xerrors.Errorf("summing account balances in state tree: %w", err)
}
totalFil := big.Mul(big.NewInt(int64(build.FilBase)), big.NewInt(int64(build.FilecoinPrecision)))
remainingFil := big.Sub(totalFil, totalFilAllocated)
2020-08-18 17:56:54 +00:00
if remainingFil.Sign() < 0 {
return nil, nil, xerrors.Errorf("somehow overallocated filecoin (allocated = %s)", types.FIL(totalFilAllocated))
}
template.RemainderAccount.Balance = remainingFil
if err := createMultisigAccount(ctx, bs, cst, state, builtin.ReserveAddress, template.RemainderAccount, keyIDs); err != nil {
return nil, nil, xerrors.Errorf("failed to set up remainder account: %w", err)
2020-08-18 21:30:49 +00:00
}
return state, keyIDs, nil
}
func createAccountActor(ctx context.Context, cst cbor.IpldStore, state *state.StateTree, info genesis.Actor, keyIDs map[address.Address]address.Address) error {
var ainfo genesis.AccountMeta
if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
return xerrors.Errorf("unmarshaling account meta: %w", err)
}
st, err := cst.Put(ctx, &account0.State{Address: ainfo.Owner})
if err != nil {
return err
}
ida, ok := keyIDs[ainfo.Owner]
if !ok {
return fmt.Errorf("no registered ID for account actor: %s", ainfo.Owner)
}
err = state.SetActor(ida, &types.Actor{
Code: builtin0.AccountActorCodeID,
Balance: info.Balance,
Head: st,
})
if err != nil {
return xerrors.Errorf("setting account from actmap: %w", err)
}
return nil
2020-02-12 00:58:55 +00:00
}
func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.IpldStore, state *state.StateTree, ida address.Address, info genesis.Actor, keyIDs map[address.Address]address.Address) error {
if info.Type != genesis.TMultisig {
return fmt.Errorf("can only call createMultisigAccount with multisig Actor info")
}
var ainfo genesis.MultisigMeta
if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
return xerrors.Errorf("unmarshaling account meta: %w", err)
}
pending, err := adt0.MakeEmptyMap(adt0.WrapStore(ctx, cst)).Root()
if err != nil {
return xerrors.Errorf("failed to create empty map: %v", err)
}
2020-07-24 09:34:48 +00:00
var signers []address.Address
2020-08-18 10:33:11 +00:00
for _, e := range ainfo.Signers {
idAddress, ok := keyIDs[e]
2020-08-19 20:32:53 +00:00
if !ok {
return fmt.Errorf("no registered key ID for signer: %s", e)
}
// Check if actor already exists
_, err := state.GetActor(e)
if err == nil {
2020-08-18 10:33:11 +00:00
signers = append(signers, idAddress)
continue
}
st, err := cst.Put(ctx, &account0.State{Address: e})
2020-07-20 15:03:27 +00:00
if err != nil {
return err
}
err = state.SetActor(idAddress, &types.Actor{
Code: builtin0.AccountActorCodeID,
Balance: types.NewInt(0),
2020-07-20 15:03:27 +00:00
Head: st,
})
if err != nil {
return xerrors.Errorf("setting account from actmap: %w", err)
}
signers = append(signers, idAddress)
2020-05-14 02:32:04 +00:00
}
st, err := cst.Put(ctx, &multisig0.State{
Signers: signers,
NumApprovalsThreshold: uint64(ainfo.Threshold),
StartEpoch: abi.ChainEpoch(ainfo.VestingStart),
UnlockDuration: abi.ChainEpoch(ainfo.VestingDuration),
PendingTxns: pending,
InitialBalance: info.Balance,
})
if err != nil {
return err
}
err = state.SetActor(ida, &types.Actor{
Code: builtin0.MultisigActorCodeID,
Balance: info.Balance,
Head: st,
})
if err != nil {
return xerrors.Errorf("setting account from actmap: %w", err)
}
return nil
2020-02-12 00:58:55 +00:00
}
2020-07-28 17:51:47 +00:00
func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot cid.Cid, template genesis.Template, keyIDs map[address.Address]address.Address) (cid.Cid, error) {
2020-05-14 02:32:04 +00:00
verifNeeds := make(map[address.Address]abi.PaddedPieceSize)
var sum abi.PaddedPieceSize
vmopt := vm.VMOpts{
StateBase: stateroot,
Epoch: 0,
Rand: &fakeRand{},
Bstore: cs.Blockstore(),
Syscalls: mkFakedSigSyscalls(cs.VMSys()),
CircSupplyCalc: nil,
2020-09-14 12:17:45 +00:00
NtwkVersion: genesisNetworkVersion,
BaseFee: types.NewInt(0),
}
2020-09-14 12:17:45 +00:00
vm, err := vm.NewVM(ctx, &vmopt)
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
}
for mi, m := range template.Miners {
for si, s := range m.Sectors {
if s.Deal.Provider != m.ID {
return cid.Undef, xerrors.Errorf("Sector %d in miner %d in template had mismatch in provider and miner ID: %s != %s", si, mi, s.Deal.Provider, m.ID)
}
amt := s.Deal.PieceSize
2020-07-28 17:51:47 +00:00
verifNeeds[keyIDs[s.Deal.Client]] += amt
2020-05-14 02:32:04 +00:00
sum += amt
}
}
2020-07-24 09:34:48 +00:00
verifregRoot, err := address.NewIDAddress(80)
2020-05-14 02:32:04 +00:00
if err != nil {
return cid.Undef, err
}
2020-07-23 20:44:09 +00:00
verifier, err := address.NewIDAddress(81)
2020-05-14 02:32:04 +00:00
if err != nil {
return cid.Undef, err
}
_, err = doExecValue(ctx, vm, builtin0.VerifiedRegistryActorAddr, verifregRoot, types.NewInt(0), builtin0.MethodsVerifiedRegistry.AddVerifier, mustEnc(&verifreg0.AddVerifierParams{
2020-05-14 02:32:04 +00:00
Address: verifier,
Allowance: abi.NewStoragePower(int64(sum)), // eh, close enough
2020-05-14 02:32:04 +00:00
}))
if err != nil {
2020-07-20 15:03:27 +00:00
return cid.Undef, xerrors.Errorf("failed to create verifier: %w", err)
2020-05-14 02:32:04 +00:00
}
for c, amt := range verifNeeds {
_, err := doExecValue(ctx, vm, builtin0.VerifiedRegistryActorAddr, verifier, types.NewInt(0), builtin0.MethodsVerifiedRegistry.AddVerifiedClient, mustEnc(&verifreg0.AddVerifiedClientParams{
2020-05-14 02:32:04 +00:00
Address: c,
Allowance: abi.NewStoragePower(int64(amt)),
2020-05-14 02:32:04 +00:00
}))
if err != nil {
return cid.Undef, xerrors.Errorf("failed to add verified client: %w", err)
}
}
st, err := vm.Flush(ctx)
if err != nil {
return cid.Cid{}, xerrors.Errorf("vm flush: %w", err)
}
return st, nil
2020-05-14 02:32:04 +00:00
}
func MakeGenesisBlock(ctx context.Context, j journal.Journal, bs bstore.Blockstore, sys vm.SyscallBuilder, template genesis.Template) (*GenesisBootstrap, error) {
if j == nil {
j = journal.NilJournal()
}
2020-07-28 17:51:47 +00:00
st, keyIDs, err := MakeInitialStateTree(ctx, bs, template)
2020-02-11 20:48:03 +00:00
if err != nil {
return nil, xerrors.Errorf("make initial state tree failed: %w", err)
}
stateroot, err := st.Flush(ctx)
2020-02-11 20:48:03 +00:00
if err != nil {
return nil, xerrors.Errorf("flush state tree failed: %w", err)
}
// temp chainstore
cs := store.NewChainStore(bs, bs, datastore.NewMapDatastore(), sys, j)
2020-05-14 02:32:04 +00:00
// Verify PreSealed Data
2020-07-28 17:51:47 +00:00
stateroot, err = VerifyPreSealedData(ctx, cs, stateroot, template, keyIDs)
2020-05-14 02:32:04 +00:00
if err != nil {
return nil, xerrors.Errorf("failed to verify presealed data: %w", err)
}
2020-02-12 02:13:00 +00:00
stateroot, err = SetupStorageMiners(ctx, cs, stateroot, template.Miners)
2020-02-11 20:48:03 +00:00
if err != nil {
return nil, xerrors.Errorf("setup miners failed: %w", err)
2020-02-11 20:48:03 +00:00
}
store := adt0.WrapStore(ctx, cbor.NewCborStore(bs))
emptyroot, err := adt0.MakeEmptyArray(store).Root()
2020-02-11 20:48:03 +00:00
if err != nil {
return nil, xerrors.Errorf("amt build failed: %w", err)
}
mm := &types.MsgMeta{
BlsMessages: emptyroot,
SecpkMessages: emptyroot,
}
mmb, err := mm.ToStorageBlock()
if err != nil {
return nil, xerrors.Errorf("serializing msgmeta failed: %w", err)
}
if err := bs.Put(mmb); err != nil {
return nil, xerrors.Errorf("putting msgmeta block to blockstore: %w", err)
}
log.Infof("Empty Genesis root: %s", emptyroot)
2020-08-24 18:33:49 +00:00
tickBuf := make([]byte, 32)
_, _ = rand.Read(tickBuf)
2020-02-11 20:48:03 +00:00
genesisticket := &types.Ticket{
2020-08-24 18:33:49 +00:00
VRFProof: tickBuf,
2020-02-11 20:48:03 +00:00
}
filecoinGenesisCid, err := cid.Decode("bafyreiaqpwbbyjo4a42saasj36kkrpv4tsherf2e7bvezkert2a7dhonoi")
if err != nil {
return nil, xerrors.Errorf("failed to decode filecoin genesis block CID: %w", err)
}
2020-08-18 13:04:31 +00:00
if !expectedCid().Equals(filecoinGenesisCid) {
return nil, xerrors.Errorf("expectedCid != filecoinGenesisCid")
}
gblk, err := getGenesisBlock()
if err != nil {
return nil, xerrors.Errorf("failed to construct filecoin genesis block: %w", err)
}
2020-08-18 13:04:31 +00:00
if !filecoinGenesisCid.Equals(gblk.Cid()) {
return nil, xerrors.Errorf("filecoinGenesisCid != gblk.Cid")
}
if err := bs.Put(gblk); err != nil {
return nil, xerrors.Errorf("failed writing filecoin genesis block to blockstore: %w", err)
}
2020-02-11 20:48:03 +00:00
b := &types.BlockHeader{
Miner: builtin0.SystemActorAddr,
Ticket: genesisticket,
Parents: []cid.Cid{filecoinGenesisCid},
2020-02-11 20:48:03 +00:00
Height: 0,
ParentWeight: types.NewInt(0),
ParentStateRoot: stateroot,
Messages: mmb.Cid(),
ParentMessageReceipts: emptyroot,
2020-03-21 22:25:00 +00:00
BLSAggregate: nil,
BlockSig: nil,
Timestamp: template.Timestamp,
ElectionProof: new(types.ElectionProof),
2020-04-08 15:11:42 +00:00
BeaconEntries: []types.BeaconEntry{
{
2020-04-08 15:11:42 +00:00
Round: 0,
Data: make([]byte, 32),
},
},
ParentBaseFee: abi.NewTokenAmount(build.InitialBaseFee),
2020-02-11 20:48:03 +00:00
}
sb, err := b.ToStorageBlock()
if err != nil {
return nil, xerrors.Errorf("serializing block header failed: %w", err)
}
if err := bs.Put(sb); err != nil {
return nil, xerrors.Errorf("putting header to blockstore: %w", err)
}
return &GenesisBootstrap{
Genesis: b,
}, nil
}