lotus/chain/gen/genesis/miners.go

351 lines
11 KiB
Go
Raw Normal View History

2020-02-11 20:48:03 +00:00
package genesis
import (
"bytes"
"context"
"fmt"
"math/rand"
2020-04-10 21:07:18 +00:00
"github.com/ipfs/go-cid"
2020-02-18 21:37:59 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
2020-04-20 13:54:06 +00:00
cbg "github.com/whyrusleeping/cbor-gen"
2020-04-10 21:07:18 +00:00
"golang.org/x/xerrors"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/go-address"
2020-04-29 18:06:05 +00:00
"github.com/filecoin-project/sector-storage/ffiwrapper"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/filecoin-project/specs-actors/actors/abi/big"
"github.com/filecoin-project/specs-actors/actors/builtin"
2020-02-12 02:13:00 +00:00
"github.com/filecoin-project/specs-actors/actors/builtin/market"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/specs-actors/actors/builtin/miner"
2020-04-10 21:07:18 +00:00
"github.com/filecoin-project/specs-actors/actors/builtin/power"
2020-02-12 02:13:00 +00:00
"github.com/filecoin-project/specs-actors/actors/crypto"
"github.com/filecoin-project/specs-actors/actors/runtime"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/lotus/chain/store"
2020-04-10 20:04:04 +00:00
"github.com/filecoin-project/lotus/chain/types"
2020-02-11 20:48:03 +00:00
"github.com/filecoin-project/lotus/chain/vm"
"github.com/filecoin-project/lotus/genesis"
)
func MinerAddress(genesisIndex uint64) address.Address {
maddr, err := address.NewIDAddress(MinerStart + genesisIndex)
if err != nil {
panic(err)
}
return maddr
}
type fakedSigSyscalls struct {
runtime.Syscalls
}
func (fss *fakedSigSyscalls) VerifySignature(signature crypto.Signature, signer address.Address, plaintext []byte) error {
return nil
}
2020-02-12 02:13:00 +00:00
func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid, miners []genesis.Miner) (cid.Cid, error) {
vm, err := vm.NewVM(sroot, 0, &fakeRand{}, cs.Blockstore(), &fakedSigSyscalls{cs.VMSys()})
2020-02-11 20:48:03 +00:00
if err != nil {
2020-02-12 02:13:00 +00:00
return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
2020-02-11 20:48:03 +00:00
}
2020-02-12 02:13:00 +00:00
if len(miners) == 0 {
return cid.Undef, xerrors.New("no genesis miners")
2020-02-11 20:48:03 +00:00
}
minerInfos := make([]struct {
maddr address.Address
presealExp abi.ChainEpoch
dealIDs []abi.DealID
}, len(miners))
2020-02-12 02:13:00 +00:00
for i, m := range miners {
// Create miner through power actor
i := i
m := m
2020-02-11 20:48:03 +00:00
2020-04-29 18:06:05 +00:00
spt, err := ffiwrapper.SealProofTypeFromSectorSize(m.SectorSize)
if err != nil {
return cid.Undef, err
}
2020-02-12 02:13:00 +00:00
{
2020-02-14 21:38:18 +00:00
constructorParams := &power.CreateMinerParams{
2020-04-29 18:06:05 +00:00
Owner: m.Worker,
Worker: m.Worker,
2020-06-05 20:06:11 +00:00
Peer: []byte(m.PeerId),
2020-04-29 18:06:05 +00:00
SealProofType: spt,
2020-02-11 20:48:03 +00:00
}
2020-02-12 02:13:00 +00:00
params := mustEnc(constructorParams)
2020-02-25 20:54:58 +00:00
rval, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, m.Owner, m.PowerBalance, builtin.MethodsPower.CreateMiner, params)
2020-02-12 02:13:00 +00:00
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
}
2020-02-11 20:48:03 +00:00
var ma power.CreateMinerReturn
if err := ma.UnmarshalCBOR(bytes.NewReader(rval)); err != nil {
2020-04-21 14:32:17 +00:00
return cid.Undef, xerrors.Errorf("unmarshaling CreateMinerReturn: %w", err)
2020-02-12 02:13:00 +00:00
}
expma := MinerAddress(uint64(i))
if ma.IDAddress != expma {
return cid.Undef, xerrors.Errorf("miner assigned wrong address: %s != %s", ma.IDAddress, expma)
2020-02-11 20:48:03 +00:00
}
minerInfos[i].maddr = ma.IDAddress
err = vm.MutateState(ctx, minerInfos[i].maddr, func(cst cbor.IpldStore, st *miner.State) error {
maxPeriods := miner.MaxSectorExpirationExtension / miner.WPoStProvingPeriod
minerInfos[i].presealExp = (maxPeriods-1)*miner.WPoStProvingPeriod + st.ProvingPeriodStart - 1
return nil
})
2020-02-11 20:48:03 +00:00
}
2020-02-12 02:13:00 +00:00
// Add market funds
2020-02-11 20:48:03 +00:00
2020-02-12 02:13:00 +00:00
{
params := mustEnc(&minerInfos[i].maddr)
2020-02-25 20:54:58 +00:00
_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
2020-02-12 02:13:00 +00:00
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
}
2020-02-11 20:48:03 +00:00
}
2020-02-21 16:57:40 +00:00
{
params := mustEnc(&m.Worker)
2020-02-25 20:54:58 +00:00
_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.AddBalance, params)
2020-02-21 16:57:40 +00:00
if err != nil {
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
}
}
2020-02-11 20:48:03 +00:00
2020-02-12 02:13:00 +00:00
// Publish preseal deals
2020-02-11 20:48:03 +00:00
2020-02-12 02:13:00 +00:00
{
2020-04-20 13:54:06 +00:00
publish := func(params *market.PublishStorageDealsParams) error {
fmt.Printf("publishing %d storage deals on miner %s with worker %s\n", len(params.Deals), params.Deals[0].Proposal.Provider, m.Worker)
ret, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.PublishStorageDeals, mustEnc(params))
if err != nil {
return xerrors.Errorf("failed to create genesis miner: %w", err)
}
var ids market.PublishStorageDealsReturn
if err := ids.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
2020-04-21 14:32:17 +00:00
return xerrors.Errorf("unmarsahling publishStorageDeals result: %w", err)
2020-04-20 13:54:06 +00:00
}
minerInfos[i].dealIDs = append(minerInfos[i].dealIDs, ids.IDs...)
2020-04-20 13:54:06 +00:00
return nil
}
2020-02-12 02:13:00 +00:00
params := &market.PublishStorageDealsParams{}
for _, preseal := range m.Sectors {
2020-05-14 02:32:04 +00:00
preseal.Deal.VerifiedDeal = true
2020-02-12 02:13:00 +00:00
params.Deals = append(params.Deals, market.ClientDealProposal{
Proposal: preseal.Deal,
2020-02-21 19:28:20 +00:00
ClientSignature: crypto.Signature{Type: crypto.SigTypeBLS}, // TODO: do we want to sign these? Or do we want to fake signatures for genesis setup?
2020-02-12 02:13:00 +00:00
})
2020-02-11 20:48:03 +00:00
2020-04-20 13:54:06 +00:00
if len(params.Deals) == cbg.MaxLength {
if err := publish(params); err != nil {
return cid.Undef, err
}
params = &market.PublishStorageDealsParams{}
}
2020-02-11 20:48:03 +00:00
}
2020-04-20 13:54:06 +00:00
if len(params.Deals) > 0 {
if err := publish(params); err != nil {
return cid.Undef, err
}
}
2020-02-11 20:48:03 +00:00
}
}
2020-02-11 20:48:03 +00:00
// adjust total network power for equal pledge per sector
rawPow, qaPow := big.NewInt(0), big.NewInt(0)
{
for i, m := range miners {
for pi := range m.Sectors {
rawPow = types.BigAdd(rawPow, types.NewInt(uint64(m.SectorSize)))
2020-02-18 21:37:59 +00:00
dweight, err := dealWeight(ctx, vm, minerInfos[i].maddr, []abi.DealID{minerInfos[i].dealIDs[pi]}, 0, minerInfos[i].presealExp)
2020-02-18 21:37:59 +00:00
if err != nil {
return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
2020-02-18 21:37:59 +00:00
}
sectorWeight := miner.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
qaPow = types.BigAdd(qaPow, sectorWeight)
2020-02-18 21:37:59 +00:00
}
}
err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
st.TotalQualityAdjPower = qaPow
st.TotalRawBytePower = rawPow
return nil
})
if err != nil {
return cid.Undef, xerrors.Errorf("mutating state: %w", err)
}
}
2020-02-18 21:37:59 +00:00
for i, m := range miners {
// Commit sectors
{
for pi, preseal := range m.Sectors {
params := &miner.SectorPreCommitInfo{
SealProof: preseal.ProofType,
SectorNumber: preseal.SectorID,
SealedCID: preseal.CommR,
SealRandEpoch: -1,
DealIDs: []abi.DealID{minerInfos[i].dealIDs[pi]},
Expiration: minerInfos[i].presealExp, // TODO: Allow setting externally!
}
2020-04-10 20:04:04 +00:00
dweight, err := dealWeight(ctx, vm, minerInfos[i].maddr, params.DealIDs, 0, minerInfos[i].presealExp)
if err != nil {
return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
}
sectorWeight := miner.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
// we've added fake power for this sector above, remove it now
err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight)
st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
2020-02-18 21:37:59 +00:00
return nil
})
if err != nil {
return cid.Undef, xerrors.Errorf("removing fake power: %w", err)
2020-02-18 21:37:59 +00:00
}
epochReward, err := currentEpochBlockReward(ctx, vm, minerInfos[i].maddr)
if err != nil {
return cid.Undef, xerrors.Errorf("getting current epoch reward: %w", err)
2020-02-18 21:37:59 +00:00
}
tpow, err := currentTotalPower(ctx, vm, minerInfos[i].maddr)
if err != nil {
return cid.Undef, xerrors.Errorf("getting current total power: %w", err)
}
2020-02-18 21:37:59 +00:00
pledge := miner.InitialPledgeForPower(sectorWeight, tpow.QualityAdjPower, tpow.PledgeCollateral, epochReward, circSupply(ctx, vm, minerInfos[i].maddr))
2020-04-21 12:36:54 +00:00
_, err = doExecValue(ctx, vm, minerInfos[i].maddr, m.Worker, pledge, builtin.MethodsMiner.PreCommitSector, mustEnc(params))
if err != nil {
return cid.Undef, xerrors.Errorf("failed to confirm presealed sectors: %w", err)
}
2020-02-18 21:37:59 +00:00
// Commit one-by-one, otherwise pledge math tends to explode
confirmParams := &builtin.ConfirmSectorProofsParams{
Sectors: []abi.SectorNumber{preseal.SectorID},
}
_, err = doExecValue(ctx, vm, minerInfos[i].maddr, builtin.StoragePowerActorAddr, big.Zero(), builtin.MethodsMiner.ConfirmSectorProofsValid, mustEnc(confirmParams))
2020-02-19 19:26:11 +00:00
if err != nil {
return cid.Undef, xerrors.Errorf("failed to confirm presealed sectors: %w", err)
2020-02-19 19:26:11 +00:00
}
2020-02-18 21:37:59 +00:00
}
2020-02-11 20:48:03 +00:00
}
}
// Sanity-check total network power
2020-03-11 07:29:17 +00:00
err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
if !st.TotalRawBytePower.Equals(rawPow) {
return xerrors.Errorf("st.TotalRawBytePower doesn't match previously calculated rawPow")
}
if !st.TotalQualityAdjPower.Equals(qaPow) {
return xerrors.Errorf("st.TotalQualityAdjPower doesn't match previously calculated qaPow")
}
2020-03-11 07:29:17 +00:00
return nil
})
if err != nil {
return cid.Undef, xerrors.Errorf("mutating state: %w", err)
}
2020-03-11 07:29:17 +00:00
2020-02-11 20:48:03 +00:00
c, err := vm.Flush(ctx)
2020-04-21 14:32:17 +00:00
if err != nil {
2020-04-21 21:38:26 +00:00
return cid.Undef, xerrors.Errorf("flushing vm: %w", err)
2020-04-21 14:32:17 +00:00
}
return c, nil
2020-02-11 20:48:03 +00:00
}
// TODO: copied from actors test harness, deduplicate or remove from here
type fakeRand struct{}
2020-04-08 15:11:42 +00:00
func (fr *fakeRand) GetRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
out := make([]byte, 32)
_, _ = rand.New(rand.NewSource(int64(randEpoch))).Read(out)
return out, nil
}
func currentTotalPower(ctx context.Context, vm *vm.VM, maddr address.Address) (*power.CurrentTotalPowerReturn, error) {
pwret, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil)
if err != nil {
return nil, err
}
var pwr power.CurrentTotalPowerReturn
if err := pwr.UnmarshalCBOR(bytes.NewReader(pwret)); err != nil {
return nil, err
}
return &pwr, nil
}
func dealWeight(ctx context.Context, vm *vm.VM, maddr address.Address, dealIDs []abi.DealID, sectorStart, sectorExpiry abi.ChainEpoch) (market.VerifyDealsForActivationReturn, error) {
params := &market.VerifyDealsForActivationParams{
DealIDs: dealIDs,
SectorStart: sectorStart,
SectorExpiry: sectorExpiry,
}
var dealWeights market.VerifyDealsForActivationReturn
ret, err := doExecValue(ctx, vm,
builtin.StorageMarketActorAddr,
maddr,
abi.NewTokenAmount(0),
builtin.MethodsMarket.VerifyDealsForActivation,
mustEnc(params),
)
if err != nil {
return market.VerifyDealsForActivationReturn{}, err
}
if err := dealWeights.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
return market.VerifyDealsForActivationReturn{}, err
}
return dealWeights, nil
}
func currentEpochBlockReward(ctx context.Context, vm *vm.VM, maddr address.Address) (abi.TokenAmount, error) {
rwret, err := doExecValue(ctx, vm, builtin.RewardActorAddr, maddr, big.Zero(), builtin.MethodsReward.LastPerEpochReward, nil)
if err != nil {
return abi.TokenAmount{}, err
}
epochReward := abi.NewTokenAmount(0)
if err := epochReward.UnmarshalCBOR(bytes.NewReader(rwret)); err != nil {
return abi.TokenAmount{}, err
}
return epochReward, nil
}
func circSupply(ctx context.Context, vmi *vm.VM, maddr address.Address) abi.TokenAmount {
unsafeVM := &vm.UnsafeVM{VM: vmi}
rt := unsafeVM.MakeRuntime(ctx, &types.Message{
GasLimit: 1_000_000_000,
From: maddr,
}, maddr, 0, 0, 0)
return rt.TotalFilCircSupply()
}