334 lines
11 KiB
Go
334 lines
11 KiB
Go
package storageadapter
|
|
|
|
// this file implements storagemarket.StorageClientNode
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
"go.uber.org/fx"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
cborutil "github.com/filecoin-project/go-cbor-util"
|
|
"github.com/filecoin-project/go-fil-markets/shared"
|
|
"github.com/filecoin-project/go-fil-markets/storagemarket"
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
"github.com/filecoin-project/go-state-types/big"
|
|
"github.com/filecoin-project/go-state-types/crypto"
|
|
"github.com/filecoin-project/go-state-types/exitcode"
|
|
market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
|
|
miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
|
|
market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
|
|
|
|
"github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/build"
|
|
marketactor "github.com/filecoin-project/lotus/chain/actors/builtin/market"
|
|
"github.com/filecoin-project/lotus/chain/events"
|
|
"github.com/filecoin-project/lotus/chain/events/state"
|
|
"github.com/filecoin-project/lotus/chain/market"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/lib/sigs"
|
|
"github.com/filecoin-project/lotus/markets/utils"
|
|
"github.com/filecoin-project/lotus/node/impl/full"
|
|
"github.com/filecoin-project/lotus/node/modules/helpers"
|
|
)
|
|
|
|
type ClientNodeAdapter struct {
|
|
*clientApi
|
|
|
|
fundmgr *market.FundManager
|
|
ev *events.Events
|
|
scMgr *SectorCommittedManager
|
|
deMgr *DealExpiryManager
|
|
}
|
|
|
|
type clientApi struct {
|
|
full.ChainAPI
|
|
full.StateAPI
|
|
full.MpoolAPI
|
|
}
|
|
|
|
func NewClientNodeAdapter(mctx helpers.MetricsCtx, lc fx.Lifecycle, stateapi full.StateAPI, chain full.ChainAPI, mpool full.MpoolAPI, fundmgr *market.FundManager) storagemarket.StorageClientNode {
|
|
capi := &clientApi{chain, stateapi, mpool}
|
|
ctx := helpers.LifecycleCtx(mctx, lc)
|
|
|
|
ev := events.NewEvents(ctx, capi)
|
|
a := &ClientNodeAdapter{
|
|
clientApi: capi,
|
|
|
|
fundmgr: fundmgr,
|
|
ev: ev,
|
|
}
|
|
a.scMgr = NewSectorCommittedManager(ev, a, &apiWrapper{api: capi})
|
|
dsMatcher := newDealStateMatcher(state.NewStatePredicates(state.WrapFastAPI(capi)))
|
|
a.deMgr = NewDealExpiryManager(ev, capi, capi, dsMatcher)
|
|
return a
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) ListStorageProviders(ctx context.Context, encodedTs shared.TipSetToken) ([]*storagemarket.StorageProviderInfo, error) {
|
|
tsk, err := types.TipSetKeyFromBytes(encodedTs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
addresses, err := c.StateListMiners(ctx, tsk)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var out []*storagemarket.StorageProviderInfo
|
|
|
|
for _, addr := range addresses {
|
|
mi, err := c.GetMinerInfo(ctx, addr, encodedTs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
out = append(out, mi)
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) VerifySignature(ctx context.Context, sig crypto.Signature, addr address.Address, input []byte, encodedTs shared.TipSetToken) (bool, error) {
|
|
addr, err := c.StateAccountKey(ctx, addr, types.EmptyTSK)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
err = sigs.Verify(&sig, addr, input)
|
|
return err == nil, err
|
|
}
|
|
|
|
// Adds funds with the StorageMinerActor for a storage participant. Used by both providers and clients.
|
|
func (c *ClientNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) (cid.Cid, error) {
|
|
// (Provider Node API)
|
|
smsg, err := c.MpoolPushMessage(ctx, &types.Message{
|
|
To: miner2.StorageMarketActorAddr,
|
|
From: addr,
|
|
Value: amount,
|
|
Method: miner2.MethodsMarket.AddBalance,
|
|
}, nil)
|
|
if err != nil {
|
|
return cid.Undef, err
|
|
}
|
|
|
|
return smsg.Cid(), nil
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) ReserveFunds(ctx context.Context, wallet, addr address.Address, amt abi.TokenAmount) (cid.Cid, error) {
|
|
return c.fundmgr.Reserve(ctx, wallet, addr, amt)
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) ReleaseFunds(ctx context.Context, addr address.Address, amt abi.TokenAmount) error {
|
|
return c.fundmgr.Release(addr, amt)
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) GetBalance(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (storagemarket.Balance, error) {
|
|
tsk, err := types.TipSetKeyFromBytes(encodedTs)
|
|
if err != nil {
|
|
return storagemarket.Balance{}, err
|
|
}
|
|
|
|
bal, err := c.StateMarketBalance(ctx, addr, tsk)
|
|
if err != nil {
|
|
return storagemarket.Balance{}, err
|
|
}
|
|
|
|
return utils.ToSharedBalance(bal), nil
|
|
}
|
|
|
|
// ValidatePublishedDeal validates that the provided deal has appeared on chain and references the same ClientDeal
|
|
// returns the Deal id if there is no error
|
|
// TODO: Don't return deal ID
|
|
func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal storagemarket.ClientDeal) (abi.DealID, error) {
|
|
log.Infow("DEAL ACCEPTED!")
|
|
|
|
pubmsg, err := c.ChainGetMessage(ctx, *deal.PublishMessage)
|
|
if err != nil {
|
|
return 0, xerrors.Errorf("getting deal publish message: %w", err)
|
|
}
|
|
|
|
mi, err := c.StateMinerInfo(ctx, deal.Proposal.Provider, types.EmptyTSK)
|
|
if err != nil {
|
|
return 0, xerrors.Errorf("getting miner worker failed: %w", err)
|
|
}
|
|
|
|
fromid, err := c.StateLookupID(ctx, pubmsg.From, types.EmptyTSK)
|
|
if err != nil {
|
|
return 0, xerrors.Errorf("failed to resolve from msg ID addr: %w", err)
|
|
}
|
|
|
|
var pubOk bool
|
|
pubAddrs := append([]address.Address{mi.Worker, mi.Owner}, mi.ControlAddresses...)
|
|
for _, a := range pubAddrs {
|
|
if fromid == a {
|
|
pubOk = true
|
|
break
|
|
}
|
|
}
|
|
if !pubOk {
|
|
return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s,%+v", pubmsg.From, deal.Proposal.Provider, pubAddrs)
|
|
}
|
|
|
|
if pubmsg.To != miner2.StorageMarketActorAddr {
|
|
return 0, xerrors.Errorf("deal publish message wasn't set to StorageMarket actor (to=%s)", pubmsg.To)
|
|
}
|
|
|
|
if pubmsg.Method != miner2.MethodsMarket.PublishStorageDeals {
|
|
return 0, xerrors.Errorf("deal publish message called incorrect method (method=%s)", pubmsg.Method)
|
|
}
|
|
|
|
var params market2.PublishStorageDealsParams
|
|
if err := params.UnmarshalCBOR(bytes.NewReader(pubmsg.Params)); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
dealIdx := -1
|
|
for i, storageDeal := range params.Deals {
|
|
// TODO: make it less hacky
|
|
sd := storageDeal
|
|
eq, err := cborutil.Equals(&deal.ClientDealProposal, &sd)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if eq {
|
|
dealIdx = i
|
|
break
|
|
}
|
|
}
|
|
|
|
if dealIdx == -1 {
|
|
return 0, xerrors.Errorf("deal publish didn't contain our deal (message cid: %s)", deal.PublishMessage)
|
|
}
|
|
|
|
// TODO: timeout
|
|
ret, err := c.StateWaitMsg(ctx, *deal.PublishMessage, build.MessageConfidence, api.LookbackNoLimit, true)
|
|
if err != nil {
|
|
return 0, xerrors.Errorf("waiting for deal publish message: %w", err)
|
|
}
|
|
if ret.Receipt.ExitCode != 0 {
|
|
return 0, xerrors.Errorf("deal publish failed: exit=%d", ret.Receipt.ExitCode)
|
|
}
|
|
|
|
var res market2.PublishStorageDealsReturn
|
|
if err := res.UnmarshalCBOR(bytes.NewReader(ret.Receipt.Return)); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return res.IDs[dealIdx], nil
|
|
}
|
|
|
|
var clientOverestimation = struct {
|
|
numerator int64
|
|
denominator int64
|
|
}{
|
|
numerator: 12,
|
|
denominator: 10,
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) DealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, isVerified bool) (abi.TokenAmount, abi.TokenAmount, error) {
|
|
bounds, err := c.StateDealProviderCollateralBounds(ctx, size, isVerified, types.EmptyTSK)
|
|
if err != nil {
|
|
return abi.TokenAmount{}, abi.TokenAmount{}, err
|
|
}
|
|
|
|
min := big.Mul(bounds.Min, big.NewInt(clientOverestimation.numerator))
|
|
min = big.Div(min, big.NewInt(clientOverestimation.denominator))
|
|
return min, bounds.Max, nil
|
|
}
|
|
|
|
// TODO: Remove dealID parameter, change publishCid to be cid.Cid (instead of pointer)
|
|
func (c *ClientNodeAdapter) OnDealSectorPreCommitted(ctx context.Context, provider address.Address, dealID abi.DealID, proposal market2.DealProposal, publishCid *cid.Cid, cb storagemarket.DealSectorPreCommittedCallback) error {
|
|
return c.scMgr.OnDealSectorPreCommitted(ctx, provider, marketactor.DealProposal(proposal), *publishCid, cb)
|
|
}
|
|
|
|
// TODO: Remove dealID parameter, change publishCid to be cid.Cid (instead of pointer)
|
|
func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider address.Address, dealID abi.DealID, sectorNumber abi.SectorNumber, proposal market2.DealProposal, publishCid *cid.Cid, cb storagemarket.DealSectorCommittedCallback) error {
|
|
return c.scMgr.OnDealSectorCommitted(ctx, provider, sectorNumber, marketactor.DealProposal(proposal), *publishCid, cb)
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) OnDealExpiredOrSlashed(ctx context.Context, publishCid cid.Cid, proposal market0.DealProposal, onDealExpired storagemarket.DealExpiredCallback, onDealSlashed storagemarket.DealSlashedCallback) error {
|
|
return c.deMgr.OnDealExpiredOrSlashed(ctx, publishCid, proposal, onDealExpired, onDealSlashed)
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) SignProposal(ctx context.Context, signer address.Address, proposal market2.DealProposal) (*market2.ClientDealProposal, error) {
|
|
// TODO: output spec signed proposal
|
|
buf, err := cborutil.Dump(&proposal)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
signer, err = c.StateAccountKey(ctx, signer, types.EmptyTSK)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
sig, err := c.Wallet.WalletSign(ctx, signer, buf, api.MsgMeta{
|
|
Type: api.MTDealProposal,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &market2.ClientDealProposal{
|
|
Proposal: proposal,
|
|
ClientSignature: *sig,
|
|
}, nil
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) GetDefaultWalletAddress(ctx context.Context) (address.Address, error) {
|
|
addr, err := c.DefWallet.GetDefault()
|
|
return addr, err
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetToken, abi.ChainEpoch, error) {
|
|
head, err := c.ChainHead(ctx)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
return head.Key().Bytes(), head.Height(), nil
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
|
|
receipt, err := c.StateWaitMsg(ctx, mcid, build.MessageConfidence, api.LookbackNoLimit, true)
|
|
if err != nil {
|
|
return cb(0, nil, cid.Undef, err)
|
|
}
|
|
return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, receipt.Message, nil)
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) GetMinerInfo(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (*storagemarket.StorageProviderInfo, error) {
|
|
tsk, err := types.TipSetKeyFromBytes(encodedTs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mi, err := c.StateMinerInfo(ctx, addr, tsk)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
out := utils.NewStorageProviderInfo(addr, mi.Worker, mi.SectorSize, *mi.PeerId, mi.Multiaddrs)
|
|
return &out, nil
|
|
}
|
|
|
|
func (c *ClientNodeAdapter) SignBytes(ctx context.Context, signer address.Address, b []byte) (*crypto.Signature, error) {
|
|
signer, err := c.StateAccountKey(ctx, signer, types.EmptyTSK)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localSignature, err := c.Wallet.WalletSign(ctx, signer, b, api.MsgMeta{
|
|
Type: api.MTUnknown, // TODO: pass type here
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return localSignature, nil
|
|
}
|
|
|
|
var _ storagemarket.StorageClientNode = &ClientNodeAdapter{}
|