lotus/chain/actors/builtin/market/v3.go

305 lines
7.6 KiB
Go
Raw Normal View History

2021-01-16 04:58:18 +00:00
package market
import (
"bytes"
"github.com/ipfs/go-cid"
cbg "github.com/whyrusleeping/cbor-gen"
"golang.org/x/xerrors"
2021-01-16 04:58:18 +00:00
2022-09-07 23:30:55 +00:00
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi"
2022-10-03 05:51:30 +00:00
verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
2022-09-06 15:49:29 +00:00
market3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/market"
adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
2022-09-07 23:30:55 +00:00
"github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types"
2021-01-16 04:58:18 +00:00
)
var _ State = (*state3)(nil)
func load3(store adt.Store, root cid.Cid) (State, error) {
out := state3{store: store}
err := store.Get(store.Context(), root, &out)
if err != nil {
return nil, err
}
return &out, nil
}
func make3(store adt.Store) (State, error) {
out := state3{store: store}
2022-04-07 18:46:23 +00:00
s, err := market3.ConstructState(store)
if err != nil {
return nil, err
}
out.State = *s
return &out, nil
}
2021-01-16 04:58:18 +00:00
type state3 struct {
market3.State
store adt.Store
}
func (s *state3) TotalLocked() (abi.TokenAmount, error) {
fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
fml = types.BigAdd(fml, s.TotalClientStorageFee)
return fml, nil
}
func (s *state3) BalancesChanged(otherState State) (bool, error) {
otherState3, ok := otherState.(*state3)
2021-01-16 04:58:18 +00:00
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(otherState3.State.EscrowTable) || !s.State.LockedTable.Equals(otherState3.State.LockedTable), nil
2021-01-16 04:58:18 +00:00
}
func (s *state3) StatesChanged(otherState State) (bool, error) {
otherState3, ok := otherState.(*state3)
2021-01-16 04:58:18 +00:00
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(otherState3.State.States), nil
2021-01-16 04:58:18 +00:00
}
func (s *state3) States() (DealStates, error) {
stateArray, err := adt3.AsArray(s.store, s.State.States, market3.StatesAmtBitwidth)
if err != nil {
return nil, err
}
return &dealStates3{stateArray}, nil
}
func (s *state3) ProposalsChanged(otherState State) (bool, error) {
otherState3, ok := otherState.(*state3)
2021-01-16 04:58:18 +00:00
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(otherState3.State.Proposals), nil
2021-01-16 04:58:18 +00:00
}
func (s *state3) Proposals() (DealProposals, error) {
proposalArray, err := adt3.AsArray(s.store, s.State.Proposals, market3.ProposalsAmtBitwidth)
if err != nil {
return nil, err
}
return &dealProposals3{proposalArray}, nil
}
func (s *state3) EscrowTable() (BalanceTable, error) {
bt, err := adt3.AsBalanceTable(s.store, s.State.EscrowTable)
if err != nil {
return nil, err
}
return &balanceTable3{bt}, nil
}
func (s *state3) LockedTable() (BalanceTable, error) {
bt, err := adt3.AsBalanceTable(s.store, s.State.LockedTable)
if err != nil {
return nil, err
}
return &balanceTable3{bt}, nil
}
func (s *state3) VerifyDealsForActivation(
minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
) (weight, verifiedWeight abi.DealWeight, err error) {
w, vw, _, err := market3.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
return w, vw, err
}
func (s *state3) NextID() (abi.DealID, error) {
return s.State.NextID, nil
}
2021-01-16 04:58:18 +00:00
type balanceTable3 struct {
*adt3.BalanceTable
}
func (bt *balanceTable3) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
asMap := (*adt3.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 dealStates3 struct {
adt.Array
}
func (s *dealStates3) Get(dealID abi.DealID) (*DealState, bool, error) {
var deal3 market3.DealState
found, err := s.Array.Get(uint64(dealID), &deal3)
2021-01-16 04:58:18 +00:00
if err != nil {
return nil, false, err
}
if !found {
return nil, false, nil
}
deal := fromV3DealState(deal3)
2021-01-16 04:58:18 +00:00
return &deal, true, nil
}
func (s *dealStates3) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
var ds3 market3.DealState
return s.Array.ForEach(&ds3, func(idx int64) error {
return cb(abi.DealID(idx), fromV3DealState(ds3))
2021-01-16 04:58:18 +00:00
})
}
func (s *dealStates3) decode(val *cbg.Deferred) (*DealState, error) {
var ds3 market3.DealState
if err := ds3.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
2021-01-16 04:58:18 +00:00
return nil, err
}
ds := fromV3DealState(ds3)
2021-01-16 04:58:18 +00:00
return &ds, nil
}
func (s *dealStates3) array() adt.Array {
return s.Array
}
2022-04-07 23:36:27 +00:00
func fromV3DealState(v3 market3.DealState) DealState {
2022-09-26 16:47:48 +00:00
return DealState{
SectorStartEpoch: v3.SectorStartEpoch,
LastUpdatedEpoch: v3.LastUpdatedEpoch,
SlashEpoch: v3.SlashEpoch,
VerifiedClaim: 0,
}
2021-01-16 04:58:18 +00:00
}
type dealProposals3 struct {
adt.Array
}
func (s *dealProposals3) Get(dealID abi.DealID) (*DealProposal, bool, error) {
var proposal3 market3.DealProposal
found, err := s.Array.Get(uint64(dealID), &proposal3)
2021-01-16 04:58:18 +00:00
if err != nil {
return nil, false, err
}
if !found {
return nil, false, nil
}
2022-03-12 18:07:35 +00:00
proposal, err := fromV3DealProposal(proposal3)
if err != nil {
return nil, true, xerrors.Errorf("decoding proposal: %w", err)
}
2021-01-16 04:58:18 +00:00
return &proposal, true, nil
}
func (s *dealProposals3) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
var dp3 market3.DealProposal
return s.Array.ForEach(&dp3, func(idx int64) error {
2022-03-12 18:07:35 +00:00
dp, err := fromV3DealProposal(dp3)
if err != nil {
return xerrors.Errorf("decoding proposal: %w", err)
}
return cb(abi.DealID(idx), dp)
2021-01-16 04:58:18 +00:00
})
}
func (s *dealProposals3) decode(val *cbg.Deferred) (*DealProposal, error) {
var dp3 market3.DealProposal
if err := dp3.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
2021-01-16 04:58:18 +00:00
return nil, err
}
2022-03-12 18:07:35 +00:00
dp, err := fromV3DealProposal(dp3)
if err != nil {
return nil, err
}
2021-01-16 04:58:18 +00:00
return &dp, nil
}
func (s *dealProposals3) array() adt.Array {
return s.Array
}
2022-04-07 23:36:27 +00:00
func fromV3DealProposal(v3 market3.DealProposal) (DealProposal, error) {
2022-04-07 21:36:17 +00:00
2022-04-07 23:36:27 +00:00
label, err := labelFromGoString(v3.Label)
2022-09-06 15:49:29 +00:00
2022-04-07 23:36:27 +00:00
if err != nil {
return DealProposal{}, xerrors.Errorf("error setting deal label: %w", err)
}
2022-04-07 21:36:17 +00:00
2022-04-07 23:36:27 +00:00
return DealProposal{
PieceCID: v3.PieceCID,
PieceSize: v3.PieceSize,
VerifiedDeal: v3.VerifiedDeal,
Client: v3.Client,
Provider: v3.Provider,
Label: label,
StartEpoch: v3.StartEpoch,
EndEpoch: v3.EndEpoch,
StoragePricePerEpoch: v3.StoragePricePerEpoch,
ProviderCollateral: v3.ProviderCollateral,
ClientCollateral: v3.ClientCollateral,
}, nil
2021-01-16 04:58:18 +00:00
}
func (s *state3) GetState() interface{} {
return &s.State
}
var _ PublishStorageDealsReturn = (*publishStorageDealsReturn3)(nil)
func decodePublishStorageDealsReturn3(b []byte) (PublishStorageDealsReturn, error) {
var retval market3.PublishStorageDealsReturn
if err := retval.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
return nil, xerrors.Errorf("failed to unmarshal PublishStorageDealsReturn: %w", err)
}
return &publishStorageDealsReturn3{retval}, nil
}
type publishStorageDealsReturn3 struct {
market3.PublishStorageDealsReturn
}
2022-04-12 19:34:45 +00:00
func (r *publishStorageDealsReturn3) IsDealValid(index uint64) (bool, int, error) {
2022-04-07 18:46:23 +00:00
// PublishStorageDeals only succeeded if all deals were valid in this version of actors
2022-04-12 19:34:45 +00:00
return true, int(index), nil
2022-04-07 18:46:23 +00:00
}
func (r *publishStorageDealsReturn3) DealIDs() ([]abi.DealID, error) {
2022-04-07 18:46:23 +00:00
return r.IDs, nil
}
2022-10-03 05:51:30 +00:00
2022-10-05 18:43:16 +00:00
func (s *state3) GetAllocationIdForPendingDeal(dealId abi.DealID) (verifregtypes.AllocationId, error) {
2022-10-03 05:51:30 +00:00
return 0, xerrors.Errorf("unsupported before actors v9")
}