github.com/filecoin-project/specs-actors/v4@v4.0.2/support/agent/miner_state.go (about)

     1  package agent
     2  
     3  import (
     4  	"context"
     5  
     6  	"github.com/filecoin-project/go-bitfield"
     7  	"github.com/filecoin-project/go-state-types/abi"
     8  	"github.com/filecoin-project/go-state-types/big"
     9  	"github.com/filecoin-project/go-state-types/dline"
    10  	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
    11  	miner3 "github.com/filecoin-project/specs-actors/v4/actors/builtin/miner"
    12  	"github.com/filecoin-project/specs-actors/v4/actors/util/adt"
    13  	cid "github.com/ipfs/go-cid"
    14  )
    15  
    16  type MinerStateV2 struct {
    17  	Root cid.Cid
    18  	Ctx  context.Context
    19  	st   *miner2.State
    20  }
    21  
    22  func (m *MinerStateV2) state(store adt.Store) (*miner2.State, error) {
    23  	if m.st == nil {
    24  		var st miner2.State
    25  		err := store.Get(m.Ctx, m.Root, &st)
    26  		if err != nil {
    27  			return nil, err
    28  		}
    29  		m.st = &st
    30  	}
    31  	return m.st, nil
    32  }
    33  
    34  func (m *MinerStateV2) HasSectorNo(store adt.Store, sectorNo abi.SectorNumber) (bool, error) {
    35  	st, err := m.state(store)
    36  	if err != nil {
    37  		return false, err
    38  	}
    39  	return st.HasSectorNo(store, sectorNo)
    40  }
    41  
    42  func (m *MinerStateV2) FindSector(store adt.Store, sectorNo abi.SectorNumber) (uint64, uint64, error) {
    43  	st, err := m.state(store)
    44  	if err != nil {
    45  		return 0, 0, err
    46  	}
    47  	return st.FindSector(store, sectorNo)
    48  }
    49  
    50  func (m *MinerStateV2) ProvingPeriodStart(store adt.Store) (abi.ChainEpoch, error) {
    51  	st, err := m.state(store)
    52  	if err != nil {
    53  		return 0, err
    54  	}
    55  	return st.ProvingPeriodStart, nil
    56  }
    57  
    58  func (m *MinerStateV2) LoadSectorInfo(store adt.Store, sectorNo uint64) (SimSectorInfo, error) {
    59  	st, err := m.state(store)
    60  	if err != nil {
    61  		return nil, err
    62  	}
    63  	sectors, err := st.LoadSectorInfos(store, bitfield.NewFromSet([]uint64{uint64(sectorNo)}))
    64  	if err != nil {
    65  		return nil, err
    66  	}
    67  	return &SectorInfoV2{info: sectors[0]}, nil
    68  }
    69  
    70  func (m *MinerStateV2) DeadlineInfo(store adt.Store, currEpoch abi.ChainEpoch) (*dline.Info, error) {
    71  	st, err := m.state(store)
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  	return st.DeadlineInfo(currEpoch), nil
    76  }
    77  
    78  func (m *MinerStateV2) FeeDebt(store adt.Store) (abi.TokenAmount, error) {
    79  	st, err := m.state(store)
    80  	if err != nil {
    81  		return big.Zero(), err
    82  	}
    83  	return st.FeeDebt, nil
    84  }
    85  
    86  func (m *MinerStateV2) LoadDeadlineState(store adt.Store, dlIdx uint64) (SimDeadlineState, error) {
    87  	st, err := m.state(store)
    88  	if err != nil {
    89  		return nil, err
    90  	}
    91  	dls, err := st.LoadDeadlines(store)
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  	dline, err := dls.LoadDeadline(store, dlIdx)
    96  	if err != nil {
    97  		return nil, err
    98  	}
    99  	return &DeadlineStateV2{deadline: dline}, nil
   100  }
   101  
   102  type DeadlineStateV2 struct {
   103  	deadline *miner2.Deadline
   104  }
   105  
   106  func (d *DeadlineStateV2) LoadPartition(store adt.Store, partIdx uint64) (SimPartitionState, error) {
   107  	part, err := d.deadline.LoadPartition(store, partIdx)
   108  	if err != nil {
   109  		return nil, err
   110  	}
   111  	return &PartitionStateV2{partition: part}, nil
   112  }
   113  
   114  type PartitionStateV2 struct {
   115  	partition *miner2.Partition
   116  }
   117  
   118  func (p *PartitionStateV2) Terminated() bitfield.BitField {
   119  	return p.partition.Terminated
   120  }
   121  
   122  type SectorInfoV2 struct {
   123  	info *miner2.SectorOnChainInfo
   124  }
   125  
   126  func (s *SectorInfoV2) Expiration() abi.ChainEpoch {
   127  	return s.info.Expiration
   128  }
   129  
   130  type MinerStateV3 struct {
   131  	Root cid.Cid
   132  	st   *miner3.State
   133  	Ctx  context.Context
   134  }
   135  
   136  func (m *MinerStateV3) state(store adt.Store) (*miner3.State, error) {
   137  	if m.st == nil {
   138  		var st miner3.State
   139  		err := store.Get(m.Ctx, m.Root, &st)
   140  		if err != nil {
   141  			return nil, err
   142  		}
   143  		m.st = &st
   144  	}
   145  	return m.st, nil
   146  }
   147  
   148  func (m *MinerStateV3) HasSectorNo(store adt.Store, sectorNo abi.SectorNumber) (bool, error) {
   149  	st, err := m.state(store)
   150  	if err != nil {
   151  		return false, err
   152  	}
   153  	return st.HasSectorNo(store, sectorNo)
   154  }
   155  
   156  func (m *MinerStateV3) FindSector(store adt.Store, sectorNo abi.SectorNumber) (uint64, uint64, error) {
   157  	st, err := m.state(store)
   158  	if err != nil {
   159  		return 0, 0, err
   160  	}
   161  	return st.FindSector(store, sectorNo)
   162  }
   163  
   164  func (m *MinerStateV3) ProvingPeriodStart(store adt.Store) (abi.ChainEpoch, error) {
   165  	st, err := m.state(store)
   166  	if err != nil {
   167  		return 0, err
   168  	}
   169  	return st.ProvingPeriodStart, nil
   170  }
   171  
   172  func (m *MinerStateV3) LoadSectorInfo(store adt.Store, sectorNo uint64) (SimSectorInfo, error) {
   173  	st, err := m.state(store)
   174  	if err != nil {
   175  		return nil, err
   176  	}
   177  	sectors, err := st.LoadSectorInfos(store, bitfield.NewFromSet([]uint64{uint64(sectorNo)}))
   178  	if err != nil {
   179  		return nil, err
   180  	}
   181  	return &SectorInfoV3{info: sectors[0]}, nil
   182  }
   183  
   184  func (m *MinerStateV3) DeadlineInfo(store adt.Store, currEpoch abi.ChainEpoch) (*dline.Info, error) {
   185  	st, err := m.state(store)
   186  	if err != nil {
   187  		return nil, err
   188  	}
   189  	return st.DeadlineInfo(currEpoch), nil
   190  }
   191  
   192  func (m *MinerStateV3) FeeDebt(store adt.Store) (abi.TokenAmount, error) {
   193  	st, err := m.state(store)
   194  	if err != nil {
   195  		return big.Zero(), err
   196  	}
   197  	return st.FeeDebt, nil
   198  }
   199  
   200  func (m *MinerStateV3) LoadDeadlineState(store adt.Store, dlIdx uint64) (SimDeadlineState, error) {
   201  	st, err := m.state(store)
   202  	if err != nil {
   203  		return nil, err
   204  	}
   205  	dls, err := st.LoadDeadlines(store)
   206  	if err != nil {
   207  		return nil, err
   208  	}
   209  	dline, err := dls.LoadDeadline(store, dlIdx)
   210  	if err != nil {
   211  		return nil, err
   212  	}
   213  	return &DeadlineStateV3{deadline: dline}, nil
   214  }
   215  
   216  type DeadlineStateV3 struct {
   217  	deadline *miner3.Deadline
   218  }
   219  
   220  func (d *DeadlineStateV3) LoadPartition(store adt.Store, partIdx uint64) (SimPartitionState, error) {
   221  	part, err := d.deadline.LoadPartition(store, partIdx)
   222  	if err != nil {
   223  		return nil, err
   224  	}
   225  	return &PartitionStateV3{partition: part}, nil
   226  }
   227  
   228  type PartitionStateV3 struct {
   229  	partition *miner3.Partition
   230  }
   231  
   232  func (p *PartitionStateV3) Terminated() bitfield.BitField {
   233  	return p.partition.Terminated
   234  }
   235  
   236  type SectorInfoV3 struct {
   237  	info *miner3.SectorOnChainInfo
   238  }
   239  
   240  func (s *SectorInfoV3) Expiration() abi.ChainEpoch {
   241  	return s.info.Expiration
   242  }