5733c71c50
We were ignoring quite a few error cases, and had one case where we weren't actually updating state where we wanted to. Unfortunately, if the linter doesn't pass, nobody has any reason to actually check lint failures in CI. There are three remaining XXXs marked in the code for lint.
788 lines
23 KiB
Go
788 lines
23 KiB
Go
package state
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
"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"
|
|
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin/market"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin/miner"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin/paych"
|
|
"github.com/filecoin-project/specs-actors/actors/util/adt"
|
|
"github.com/ipfs/go-cid"
|
|
cbor "github.com/ipfs/go-ipld-cbor"
|
|
typegen "github.com/whyrusleeping/cbor-gen"
|
|
|
|
"github.com/filecoin-project/lotus/api/apibstore"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
)
|
|
|
|
// UserData is the data returned from the DiffTipSetKeyFunc
|
|
type UserData interface{}
|
|
|
|
// ChainAPI abstracts out calls made by this class to external APIs
|
|
type ChainAPI interface {
|
|
apibstore.ChainIO
|
|
StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
|
|
}
|
|
|
|
// StatePredicates has common predicates for responding to state changes
|
|
type StatePredicates struct {
|
|
api ChainAPI
|
|
cst *cbor.BasicIpldStore
|
|
}
|
|
|
|
func NewStatePredicates(api ChainAPI) *StatePredicates {
|
|
return &StatePredicates{
|
|
api: api,
|
|
cst: cbor.NewCborStore(apibstore.NewAPIBlockstore(api)),
|
|
}
|
|
}
|
|
|
|
// DiffTipSetKeyFunc check if there's a change form oldState to newState, and returns
|
|
// - changed: was there a change
|
|
// - user: user-defined data representing the state change
|
|
// - err
|
|
type DiffTipSetKeyFunc func(ctx context.Context, oldState, newState types.TipSetKey) (changed bool, user UserData, err error)
|
|
|
|
type DiffActorStateFunc func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error)
|
|
|
|
// OnActorStateChanged calls diffStateFunc when the state changes for the given actor
|
|
func (sp *StatePredicates) OnActorStateChanged(addr address.Address, diffStateFunc DiffActorStateFunc) DiffTipSetKeyFunc {
|
|
return func(ctx context.Context, oldState, newState types.TipSetKey) (changed bool, user UserData, err error) {
|
|
oldActor, err := sp.api.StateGetActor(ctx, addr, oldState)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
newActor, err := sp.api.StateGetActor(ctx, addr, newState)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if oldActor.Head.Equals(newActor.Head) {
|
|
return false, nil, nil
|
|
}
|
|
return diffStateFunc(ctx, oldActor.Head, newActor.Head)
|
|
}
|
|
}
|
|
|
|
type DiffStorageMarketStateFunc func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error)
|
|
|
|
// OnStorageMarketActorChanged calls diffStorageMarketState when the state changes for the market actor
|
|
func (sp *StatePredicates) OnStorageMarketActorChanged(diffStorageMarketState DiffStorageMarketStateFunc) DiffTipSetKeyFunc {
|
|
return sp.OnActorStateChanged(builtin.StorageMarketActorAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
|
|
var oldState market.State
|
|
if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
var newState market.State
|
|
if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
return diffStorageMarketState(ctx, &oldState, &newState)
|
|
})
|
|
}
|
|
|
|
type BalanceTables struct {
|
|
EscrowTable *adt.BalanceTable
|
|
LockedTable *adt.BalanceTable
|
|
}
|
|
|
|
// DiffBalanceTablesFunc compares two balance tables
|
|
type DiffBalanceTablesFunc func(ctx context.Context, oldBalanceTable, newBalanceTable BalanceTables) (changed bool, user UserData, err error)
|
|
|
|
// OnBalanceChanged runs when the escrow table for available balances changes
|
|
func (sp *StatePredicates) OnBalanceChanged(diffBalances DiffBalanceTablesFunc) DiffStorageMarketStateFunc {
|
|
return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
|
|
if oldState.EscrowTable.Equals(newState.EscrowTable) && oldState.LockedTable.Equals(newState.LockedTable) {
|
|
return false, nil, nil
|
|
}
|
|
|
|
ctxStore := &contextStore{
|
|
ctx: ctx,
|
|
cst: sp.cst,
|
|
}
|
|
|
|
oldEscrowRoot, err := adt.AsBalanceTable(ctxStore, oldState.EscrowTable)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
oldLockedRoot, err := adt.AsBalanceTable(ctxStore, oldState.LockedTable)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newEscrowRoot, err := adt.AsBalanceTable(ctxStore, newState.EscrowTable)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newLockedRoot, err := adt.AsBalanceTable(ctxStore, newState.LockedTable)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
return diffBalances(ctx, BalanceTables{oldEscrowRoot, oldLockedRoot}, BalanceTables{newEscrowRoot, newLockedRoot})
|
|
}
|
|
}
|
|
|
|
type DiffAdtArraysFunc func(ctx context.Context, oldDealStateRoot, newDealStateRoot *adt.Array) (changed bool, user UserData, err error)
|
|
|
|
// OnDealStateChanged calls diffDealStates when the market deal state changes
|
|
func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffAdtArraysFunc) DiffStorageMarketStateFunc {
|
|
return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
|
|
if oldState.States.Equals(newState.States) {
|
|
return false, nil, nil
|
|
}
|
|
|
|
ctxStore := &contextStore{
|
|
ctx: ctx,
|
|
cst: sp.cst,
|
|
}
|
|
|
|
oldRoot, err := adt.AsArray(ctxStore, oldState.States)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
newRoot, err := adt.AsArray(ctxStore, newState.States)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
return diffDealStates(ctx, oldRoot, newRoot)
|
|
}
|
|
}
|
|
|
|
// OnDealProposalChanged calls diffDealProps when the market proposal state changes
|
|
func (sp *StatePredicates) OnDealProposalChanged(diffDealProps DiffAdtArraysFunc) DiffStorageMarketStateFunc {
|
|
return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
|
|
if oldState.Proposals.Equals(newState.Proposals) {
|
|
return false, nil, nil
|
|
}
|
|
|
|
ctxStore := &contextStore{
|
|
ctx: ctx,
|
|
cst: sp.cst,
|
|
}
|
|
|
|
oldRoot, err := adt.AsArray(ctxStore, oldState.Proposals)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
newRoot, err := adt.AsArray(ctxStore, newState.Proposals)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
return diffDealProps(ctx, oldRoot, newRoot)
|
|
}
|
|
}
|
|
|
|
var _ AdtArrayDiff = &MarketDealProposalChanges{}
|
|
|
|
type MarketDealProposalChanges struct {
|
|
Added []ProposalIDState
|
|
Removed []ProposalIDState
|
|
}
|
|
|
|
type ProposalIDState struct {
|
|
ID abi.DealID
|
|
Proposal market.DealProposal
|
|
}
|
|
|
|
func (m *MarketDealProposalChanges) Add(key uint64, val *typegen.Deferred) error {
|
|
dp := new(market.DealProposal)
|
|
err := dp.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Added = append(m.Added, ProposalIDState{abi.DealID(key), *dp})
|
|
return nil
|
|
}
|
|
|
|
func (m *MarketDealProposalChanges) Modify(key uint64, from, to *typegen.Deferred) error {
|
|
// short circuit, DealProposals are static
|
|
return nil
|
|
}
|
|
|
|
func (m *MarketDealProposalChanges) Remove(key uint64, val *typegen.Deferred) error {
|
|
dp := new(market.DealProposal)
|
|
err := dp.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Removed = append(m.Removed, ProposalIDState{abi.DealID(key), *dp})
|
|
return nil
|
|
}
|
|
|
|
// OnDealProposalAmtChanged detects changes in the deal proposal AMT for all deal proposals and returns a MarketProposalsChanges structure containing:
|
|
// - Added Proposals
|
|
// - Modified Proposals
|
|
// - Removed Proposals
|
|
func (sp *StatePredicates) OnDealProposalAmtChanged() DiffAdtArraysFunc {
|
|
return func(ctx context.Context, oldDealProps, newDealProps *adt.Array) (changed bool, user UserData, err error) {
|
|
proposalChanges := new(MarketDealProposalChanges)
|
|
if err := DiffAdtArray(oldDealProps, newDealProps, proposalChanges); err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if len(proposalChanges.Added)+len(proposalChanges.Removed) == 0 {
|
|
return false, nil, nil
|
|
}
|
|
|
|
return true, proposalChanges, nil
|
|
}
|
|
}
|
|
|
|
var _ AdtArrayDiff = &MarketDealStateChanges{}
|
|
|
|
type MarketDealStateChanges struct {
|
|
Added []DealIDState
|
|
Modified []DealStateChange
|
|
Removed []DealIDState
|
|
}
|
|
|
|
type DealIDState struct {
|
|
ID abi.DealID
|
|
Deal market.DealState
|
|
}
|
|
|
|
func (m *MarketDealStateChanges) Add(key uint64, val *typegen.Deferred) error {
|
|
ds := new(market.DealState)
|
|
err := ds.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Added = append(m.Added, DealIDState{abi.DealID(key), *ds})
|
|
return nil
|
|
}
|
|
|
|
func (m *MarketDealStateChanges) Modify(key uint64, from, to *typegen.Deferred) error {
|
|
dsFrom := new(market.DealState)
|
|
if err := dsFrom.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
|
|
return err
|
|
}
|
|
|
|
dsTo := new(market.DealState)
|
|
if err := dsTo.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
|
|
return err
|
|
}
|
|
|
|
if *dsFrom != *dsTo {
|
|
m.Modified = append(m.Modified, DealStateChange{abi.DealID(key), dsFrom, dsTo})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MarketDealStateChanges) Remove(key uint64, val *typegen.Deferred) error {
|
|
ds := new(market.DealState)
|
|
err := ds.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Removed = append(m.Removed, DealIDState{abi.DealID(key), *ds})
|
|
return nil
|
|
}
|
|
|
|
// OnDealStateAmtChanged detects changes in the deal state AMT for all deal states and returns a MarketDealStateChanges structure containing:
|
|
// - Added Deals
|
|
// - Modified Deals
|
|
// - Removed Deals
|
|
func (sp *StatePredicates) OnDealStateAmtChanged() DiffAdtArraysFunc {
|
|
return func(ctx context.Context, oldDealStates, newDealStates *adt.Array) (changed bool, user UserData, err error) {
|
|
dealStateChanges := new(MarketDealStateChanges)
|
|
if err := DiffAdtArray(oldDealStates, newDealStates, dealStateChanges); err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if len(dealStateChanges.Added)+len(dealStateChanges.Modified)+len(dealStateChanges.Removed) == 0 {
|
|
return false, nil, nil
|
|
}
|
|
|
|
return true, dealStateChanges, nil
|
|
}
|
|
}
|
|
|
|
// ChangedDeals is a set of changes to deal state
|
|
type ChangedDeals map[abi.DealID]DealStateChange
|
|
|
|
// DealStateChange is a change in deal state from -> to
|
|
type DealStateChange struct {
|
|
ID abi.DealID
|
|
From *market.DealState
|
|
To *market.DealState
|
|
}
|
|
|
|
// DealStateChangedForIDs detects changes in the deal state AMT for the given deal IDs
|
|
func (sp *StatePredicates) DealStateChangedForIDs(dealIds []abi.DealID) DiffAdtArraysFunc {
|
|
return func(ctx context.Context, oldDealStateArray, newDealStateArray *adt.Array) (changed bool, user UserData, err error) {
|
|
changedDeals := make(ChangedDeals)
|
|
for _, dealID := range dealIds {
|
|
var oldDealPtr, newDealPtr *market.DealState
|
|
var oldDeal, newDeal market.DealState
|
|
|
|
// If the deal has been removed, we just set it to nil
|
|
found, err := oldDealStateArray.Get(uint64(dealID), &oldDeal)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
if found {
|
|
oldDealPtr = &oldDeal
|
|
}
|
|
|
|
found, err = newDealStateArray.Get(uint64(dealID), &newDeal)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
if found {
|
|
newDealPtr = &newDeal
|
|
}
|
|
|
|
if oldDeal != newDeal {
|
|
changedDeals[dealID] = DealStateChange{dealID, oldDealPtr, newDealPtr}
|
|
}
|
|
}
|
|
if len(changedDeals) > 0 {
|
|
return true, changedDeals, nil
|
|
}
|
|
return false, nil, nil
|
|
}
|
|
}
|
|
|
|
// ChangedBalances is a set of changes to deal state
|
|
type ChangedBalances map[address.Address]BalanceChange
|
|
|
|
// BalanceChange is a change in balance from -> to
|
|
type BalanceChange struct {
|
|
From abi.TokenAmount
|
|
To abi.TokenAmount
|
|
}
|
|
|
|
// AvailableBalanceChangedForAddresses detects changes in the escrow table for the given addresses
|
|
func (sp *StatePredicates) AvailableBalanceChangedForAddresses(getAddrs func() []address.Address) DiffBalanceTablesFunc {
|
|
return func(ctx context.Context, oldBalances, newBalances BalanceTables) (changed bool, user UserData, err error) {
|
|
changedBalances := make(ChangedBalances)
|
|
addrs := getAddrs()
|
|
for _, addr := range addrs {
|
|
// If the deal has been removed, we just set it to nil
|
|
oldEscrowBalance, err := oldBalances.EscrowTable.Get(addr)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
oldLockedBalance, err := oldBalances.LockedTable.Get(addr)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
oldBalance := big.Sub(oldEscrowBalance, oldLockedBalance)
|
|
|
|
newEscrowBalance, err := newBalances.EscrowTable.Get(addr)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newLockedBalance, err := newBalances.LockedTable.Get(addr)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newBalance := big.Sub(newEscrowBalance, newLockedBalance)
|
|
|
|
if !oldBalance.Equals(newBalance) {
|
|
changedBalances[addr] = BalanceChange{oldBalance, newBalance}
|
|
}
|
|
}
|
|
if len(changedBalances) > 0 {
|
|
return true, changedBalances, nil
|
|
}
|
|
return false, nil, nil
|
|
}
|
|
}
|
|
|
|
type DiffMinerActorStateFunc func(ctx context.Context, oldState *miner.State, newState *miner.State) (changed bool, user UserData, err error)
|
|
|
|
func (sp *StatePredicates) OnInitActorChange(diffInitActorState DiffInitActorStateFunc) DiffTipSetKeyFunc {
|
|
return sp.OnActorStateChanged(builtin.InitActorAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
|
|
var oldState init_.State
|
|
if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
var newState init_.State
|
|
if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
return diffInitActorState(ctx, &oldState, &newState)
|
|
})
|
|
|
|
}
|
|
|
|
func (sp *StatePredicates) OnMinerActorChange(minerAddr address.Address, diffMinerActorState DiffMinerActorStateFunc) DiffTipSetKeyFunc {
|
|
return sp.OnActorStateChanged(minerAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
|
|
var oldState miner.State
|
|
if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
var newState miner.State
|
|
if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
return diffMinerActorState(ctx, &oldState, &newState)
|
|
})
|
|
}
|
|
|
|
type MinerSectorChanges struct {
|
|
Added []miner.SectorOnChainInfo
|
|
Extended []SectorExtensions
|
|
Removed []miner.SectorOnChainInfo
|
|
}
|
|
|
|
var _ AdtArrayDiff = &MinerSectorChanges{}
|
|
|
|
type SectorExtensions struct {
|
|
From miner.SectorOnChainInfo
|
|
To miner.SectorOnChainInfo
|
|
}
|
|
|
|
func (m *MinerSectorChanges) Add(key uint64, val *typegen.Deferred) error {
|
|
si := new(miner.SectorOnChainInfo)
|
|
err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Added = append(m.Added, *si)
|
|
return nil
|
|
}
|
|
|
|
func (m *MinerSectorChanges) Modify(key uint64, from, to *typegen.Deferred) error {
|
|
siFrom := new(miner.SectorOnChainInfo)
|
|
err := siFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
siTo := new(miner.SectorOnChainInfo)
|
|
err = siTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if siFrom.Expiration != siTo.Expiration {
|
|
m.Extended = append(m.Extended, SectorExtensions{
|
|
From: *siFrom,
|
|
To: *siTo,
|
|
})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MinerSectorChanges) Remove(key uint64, val *typegen.Deferred) error {
|
|
si := new(miner.SectorOnChainInfo)
|
|
err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Removed = append(m.Removed, *si)
|
|
return nil
|
|
}
|
|
|
|
func (sp *StatePredicates) OnMinerSectorChange() DiffMinerActorStateFunc {
|
|
return func(ctx context.Context, oldState, newState *miner.State) (changed bool, user UserData, err error) {
|
|
ctxStore := &contextStore{
|
|
ctx: ctx,
|
|
cst: sp.cst,
|
|
}
|
|
|
|
sectorChanges := &MinerSectorChanges{
|
|
Added: []miner.SectorOnChainInfo{},
|
|
Extended: []SectorExtensions{},
|
|
Removed: []miner.SectorOnChainInfo{},
|
|
}
|
|
|
|
// no sector changes
|
|
if oldState.Sectors.Equals(newState.Sectors) {
|
|
return false, nil, nil
|
|
}
|
|
|
|
oldSectors, err := adt.AsArray(ctxStore, oldState.Sectors)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newSectors, err := adt.AsArray(ctxStore, newState.Sectors)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if err := DiffAdtArray(oldSectors, newSectors, sectorChanges); err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
// nothing changed
|
|
if len(sectorChanges.Added)+len(sectorChanges.Extended)+len(sectorChanges.Removed) == 0 {
|
|
return false, nil, nil
|
|
}
|
|
|
|
return true, sectorChanges, nil
|
|
}
|
|
}
|
|
|
|
type MinerPreCommitChanges struct {
|
|
Added []miner.SectorPreCommitOnChainInfo
|
|
Removed []miner.SectorPreCommitOnChainInfo
|
|
}
|
|
|
|
func (m *MinerPreCommitChanges) AsKey(key string) (adt.Keyer, error) {
|
|
sector, err := adt.ParseUIntKey(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return miner.SectorKey(abi.SectorNumber(sector)), nil
|
|
}
|
|
|
|
func (m *MinerPreCommitChanges) Add(key string, val *typegen.Deferred) error {
|
|
sp := new(miner.SectorPreCommitOnChainInfo)
|
|
err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Added = append(m.Added, *sp)
|
|
return nil
|
|
}
|
|
|
|
func (m *MinerPreCommitChanges) Modify(key string, from, to *typegen.Deferred) error {
|
|
return nil
|
|
}
|
|
|
|
func (m *MinerPreCommitChanges) Remove(key string, val *typegen.Deferred) error {
|
|
sp := new(miner.SectorPreCommitOnChainInfo)
|
|
err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.Removed = append(m.Removed, *sp)
|
|
return nil
|
|
}
|
|
|
|
func (sp *StatePredicates) OnMinerPreCommitChange() DiffMinerActorStateFunc {
|
|
return func(ctx context.Context, oldState, newState *miner.State) (changed bool, user UserData, err error) {
|
|
ctxStore := &contextStore{
|
|
ctx: ctx,
|
|
cst: sp.cst,
|
|
}
|
|
|
|
precommitChanges := &MinerPreCommitChanges{
|
|
Added: []miner.SectorPreCommitOnChainInfo{},
|
|
Removed: []miner.SectorPreCommitOnChainInfo{},
|
|
}
|
|
|
|
if oldState.PreCommittedSectors.Equals(newState.PreCommittedSectors) {
|
|
return false, nil, nil
|
|
}
|
|
|
|
oldPrecommits, err := adt.AsMap(ctxStore, oldState.PreCommittedSectors)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newPrecommits, err := adt.AsMap(ctxStore, newState.PreCommittedSectors)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if err := DiffAdtMap(oldPrecommits, newPrecommits, precommitChanges); err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if len(precommitChanges.Added)+len(precommitChanges.Removed) == 0 {
|
|
return false, nil, nil
|
|
}
|
|
|
|
return true, precommitChanges, nil
|
|
}
|
|
}
|
|
|
|
// DiffPaymentChannelStateFunc is function that compares two states for the payment channel
|
|
type DiffPaymentChannelStateFunc func(ctx context.Context, oldState *paych.State, newState *paych.State) (changed bool, user UserData, err error)
|
|
|
|
// OnPaymentChannelActorChanged calls diffPaymentChannelState when the state changes for the the payment channel actor
|
|
func (sp *StatePredicates) OnPaymentChannelActorChanged(paychAddr address.Address, diffPaymentChannelState DiffPaymentChannelStateFunc) DiffTipSetKeyFunc {
|
|
return sp.OnActorStateChanged(paychAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
|
|
var oldState paych.State
|
|
if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
var newState paych.State
|
|
if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
|
|
return false, nil, err
|
|
}
|
|
return diffPaymentChannelState(ctx, &oldState, &newState)
|
|
})
|
|
}
|
|
|
|
// PayChToSendChange is a difference in the amount to send on a payment channel when the money is collected
|
|
type PayChToSendChange struct {
|
|
OldToSend abi.TokenAmount
|
|
NewToSend abi.TokenAmount
|
|
}
|
|
|
|
// OnToSendAmountChanges monitors changes on the total amount to send from one party to the other on a payment channel
|
|
func (sp *StatePredicates) OnToSendAmountChanges() DiffPaymentChannelStateFunc {
|
|
return func(ctx context.Context, oldState *paych.State, newState *paych.State) (changed bool, user UserData, err error) {
|
|
if oldState.ToSend.Equals(newState.ToSend) {
|
|
return false, nil, nil
|
|
}
|
|
return true, &PayChToSendChange{
|
|
OldToSend: oldState.ToSend,
|
|
NewToSend: newState.ToSend,
|
|
}, nil
|
|
}
|
|
}
|
|
|
|
type AddressPair struct {
|
|
ID address.Address
|
|
PK address.Address
|
|
}
|
|
|
|
type InitActorAddressChanges struct {
|
|
Added []AddressPair
|
|
Modified []AddressChange
|
|
Removed []AddressPair
|
|
}
|
|
|
|
type AddressChange struct {
|
|
From AddressPair
|
|
To AddressPair
|
|
}
|
|
|
|
type DiffInitActorStateFunc func(ctx context.Context, oldState *init_.State, newState *init_.State) (changed bool, user UserData, err error)
|
|
|
|
func (i *InitActorAddressChanges) AsKey(key string) (adt.Keyer, error) {
|
|
addr, err := address.NewFromBytes([]byte(key))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return adt.AddrKey(addr), nil
|
|
}
|
|
|
|
func (i *InitActorAddressChanges) Add(key string, val *typegen.Deferred) error {
|
|
pkAddr, err := address.NewFromBytes([]byte(key))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
id := new(typegen.CborInt)
|
|
if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
|
|
return err
|
|
}
|
|
idAddr, err := address.NewIDAddress(uint64(*id))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
i.Added = append(i.Added, AddressPair{
|
|
ID: idAddr,
|
|
PK: pkAddr,
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (i *InitActorAddressChanges) Modify(key string, from, to *typegen.Deferred) error {
|
|
pkAddr, err := address.NewFromBytes([]byte(key))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fromID := new(typegen.CborInt)
|
|
if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
|
|
return err
|
|
}
|
|
fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
toID := new(typegen.CborInt)
|
|
if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
|
|
return err
|
|
}
|
|
toIDAddr, err := address.NewIDAddress(uint64(*toID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
i.Modified = append(i.Modified, AddressChange{
|
|
From: AddressPair{
|
|
ID: fromIDAddr,
|
|
PK: pkAddr,
|
|
},
|
|
To: AddressPair{
|
|
ID: toIDAddr,
|
|
PK: pkAddr,
|
|
},
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (i *InitActorAddressChanges) Remove(key string, val *typegen.Deferred) error {
|
|
pkAddr, err := address.NewFromBytes([]byte(key))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
id := new(typegen.CborInt)
|
|
if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
|
|
return err
|
|
}
|
|
idAddr, err := address.NewIDAddress(uint64(*id))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
i.Removed = append(i.Removed, AddressPair{
|
|
ID: idAddr,
|
|
PK: pkAddr,
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
|
|
return func(ctx context.Context, oldState, newState *init_.State) (changed bool, user UserData, err error) {
|
|
ctxStore := &contextStore{
|
|
ctx: ctx,
|
|
cst: sp.cst,
|
|
}
|
|
|
|
addressChanges := &InitActorAddressChanges{
|
|
Added: []AddressPair{},
|
|
Modified: []AddressChange{},
|
|
Removed: []AddressPair{},
|
|
}
|
|
|
|
if oldState.AddressMap.Equals(newState.AddressMap) {
|
|
return false, nil, nil
|
|
}
|
|
|
|
oldAddrs, err := adt.AsMap(ctxStore, oldState.AddressMap)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
newAddrs, err := adt.AsMap(ctxStore, newState.AddressMap)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if err := DiffAdtMap(oldAddrs, newAddrs, addressChanges); err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
if len(addressChanges.Added)+len(addressChanges.Removed)+len(addressChanges.Modified) == 0 {
|
|
return false, nil, nil
|
|
}
|
|
|
|
return true, addressChanges, nil
|
|
}
|
|
}
|