lotus/paych/paych.go

349 lines
8.0 KiB
Go
Raw Normal View History

2019-08-09 21:42:56 +00:00
package paych
import (
2019-09-25 12:56:04 +00:00
"bytes"
2019-08-09 21:42:56 +00:00
"context"
"fmt"
"math"
"strconv"
2019-08-09 21:42:56 +00:00
"golang.org/x/xerrors"
2019-09-09 13:59:07 +00:00
logging "github.com/ipfs/go-log"
2019-09-16 16:40:26 +00:00
"go.uber.org/fx"
2019-09-09 13:59:07 +00:00
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/address"
"github.com/filecoin-project/lotus/chain/stmgr"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/node/impl/full"
2019-08-09 21:42:56 +00:00
)
2019-09-09 13:59:07 +00:00
var log = logging.Logger("paych")
2019-09-16 16:40:26 +00:00
type ManagerApi struct {
fx.In
full.MpoolAPI
full.WalletAPI
full.StateAPI
2019-09-16 16:40:26 +00:00
}
type Manager struct {
store *Store
sm *stmgr.StateManager
2019-09-16 13:46:05 +00:00
2019-09-16 16:40:26 +00:00
mpool full.MpoolAPI
wallet full.WalletAPI
state full.StateAPI
2019-08-09 21:42:56 +00:00
}
2019-09-16 16:40:26 +00:00
func NewManager(sm *stmgr.StateManager, pchstore *Store, api ManagerApi) *Manager {
return &Manager{
2019-08-09 21:42:56 +00:00
store: pchstore,
sm: sm,
2019-09-16 16:40:26 +00:00
2019-09-16 21:26:19 +00:00
mpool: api.MpoolAPI,
2019-09-16 16:40:26 +00:00
wallet: api.WalletAPI,
state: api.StateAPI,
2019-08-09 21:42:56 +00:00
}
}
func maxLaneFromState(st *actors.PaymentChannelActorState) (uint64, error) {
maxLane := uint64(math.MaxUint64)
for lane := range st.LaneStates {
ilane, err := strconv.ParseUint(lane, 10, 64)
if err != nil {
return 0, err
}
if ilane+1 > maxLane+1 {
maxLane = ilane
}
}
return maxLane, nil
}
func (pm *Manager) TrackInboundChannel(ctx context.Context, ch address.Address) error {
_, st, err := pm.loadPaychState(ctx, ch)
if err != nil {
return err
}
maxLane, err := maxLaneFromState(st)
if err != nil {
return err
}
return pm.store.TrackChannel(&ChannelInfo{
Channel: ch,
Control: st.To,
Target: st.From,
Direction: DirInbound,
NextLane: maxLane + 1,
})
}
2019-09-16 17:23:48 +00:00
func (pm *Manager) loadOutboundChannelInfo(ctx context.Context, ch address.Address) (*ChannelInfo, error) {
_, st, err := pm.loadPaychState(ctx, ch)
if err != nil {
2019-09-16 17:23:48 +00:00
return nil, err
}
maxLane, err := maxLaneFromState(st)
if err != nil {
2019-09-16 17:23:48 +00:00
return nil, err
}
2019-09-16 17:23:48 +00:00
return &ChannelInfo{
Channel: ch,
Control: st.From,
Target: st.To,
Direction: DirOutbound,
NextLane: maxLane + 1,
2019-09-16 17:23:48 +00:00
}, nil
}
func (pm *Manager) TrackOutboundChannel(ctx context.Context, ch address.Address) error {
ci, err := pm.loadOutboundChannelInfo(ctx, ch)
if err != nil {
return err
}
return pm.store.TrackChannel(ci)
}
func (pm *Manager) ListChannels() ([]address.Address, error) {
return pm.store.ListChannels()
}
func (pm *Manager) GetChannelInfo(addr address.Address) (*ChannelInfo, error) {
return pm.store.getChannelInfo(addr)
2019-08-09 21:42:56 +00:00
}
// checks if the given voucher is valid (is or could become spendable at some point)
func (pm *Manager) CheckVoucherValid(ctx context.Context, ch address.Address, sv *types.SignedVoucher) error {
2019-08-09 21:42:56 +00:00
act, pca, err := pm.loadPaychState(ctx, ch)
if err != nil {
return err
}
// verify signature
vb, err := sv.SigningBytes()
if err != nil {
return err
}
2019-08-13 18:47:40 +00:00
// TODO: technically, either party may create and sign a voucher.
// However, for now, we only accept them from the channel creator.
// More complex handling logic can be added later
2019-08-09 21:42:56 +00:00
if err := sv.Signature.Verify(pca.From, vb); err != nil {
return err
}
sendAmount := sv.Amount
// now check the lane state
2019-08-13 18:47:40 +00:00
// TODO: should check against vouchers in our local store too
// there might be something conflicting
2019-08-09 21:42:56 +00:00
ls, ok := pca.LaneStates[fmt.Sprint(sv.Lane)]
if !ok {
} else {
if ls.Closed {
return fmt.Errorf("voucher is on a closed lane")
}
if ls.Nonce >= sv.Nonce {
return fmt.Errorf("nonce too low")
}
sendAmount = types.BigSub(sv.Amount, ls.Redeemed)
}
// TODO: also account for vouchers on other lanes we've received
newTotal := types.BigAdd(sendAmount, pca.ToSend)
2019-09-23 17:11:44 +00:00
if act.Balance.LessThan(newTotal) {
2019-08-09 21:42:56 +00:00
return fmt.Errorf("not enough funds in channel to cover voucher")
}
if len(sv.Merges) != 0 {
return fmt.Errorf("dont currently support paych lane merges")
}
return nil
}
// checks if the given voucher is currently spendable
func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address, sv *types.SignedVoucher, secret []byte, proof []byte) (bool, error) {
2019-08-09 21:42:56 +00:00
owner, err := pm.getPaychOwner(ctx, ch)
if err != nil {
return false, err
}
2019-09-09 13:59:07 +00:00
if sv.Extra != nil && proof == nil {
known, err := pm.ListVouchers(ctx, ch)
if err != nil {
return false, err
}
for _, v := range known {
if v.Proof != nil && v.Voucher.Equals(sv) {
log.Info("CheckVoucherSpendable: using stored proof")
proof = v.Proof
break
}
}
if proof == nil {
log.Warn("CheckVoucherSpendable: nil proof for voucher with validation")
}
}
2019-08-09 21:42:56 +00:00
enc, err := actors.SerializeParams(&actors.PCAUpdateChannelStateParams{
Sv: *sv,
Secret: secret,
Proof: proof,
})
if err != nil {
return false, err
}
2019-09-09 20:03:10 +00:00
ret, err := pm.sm.Call(ctx, &types.Message{
2019-08-09 21:42:56 +00:00
From: owner,
To: ch,
Method: actors.PCAMethods.UpdateChannelState,
Params: enc,
}, nil)
if err != nil {
return false, err
}
if ret.ExitCode != 0 {
return false, nil
}
return true, nil
}
func (pm *Manager) getPaychOwner(ctx context.Context, ch address.Address) (address.Address, error) {
2019-09-09 20:03:10 +00:00
ret, err := pm.sm.Call(ctx, &types.Message{
2019-08-09 21:42:56 +00:00
From: ch,
To: ch,
Method: actors.PCAMethods.GetOwner,
}, nil)
if err != nil {
return address.Undef, err
}
if ret.ExitCode != 0 {
return address.Undef, fmt.Errorf("failed to get payment channel owner (exit code %d)", ret.ExitCode)
}
return address.NewFromBytes(ret.Return)
}
2019-09-16 21:25:23 +00:00
func (pm *Manager) AddVoucher(ctx context.Context, ch address.Address, sv *types.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
if err := pm.CheckVoucherValid(ctx, ch, sv); err != nil {
2019-09-16 21:25:23 +00:00
return types.NewInt(0), err
}
2019-09-25 12:56:04 +00:00
pm.store.lk.Lock()
defer pm.store.lk.Unlock()
ci, err := pm.store.getChannelInfo(ch)
if err != nil {
return types.NewInt(0), err
}
laneState, err := pm.laneState(ctx, ch, sv.Lane)
if err != nil {
return types.NewInt(0), err
}
if laneState.Closed {
return types.NewInt(0), xerrors.New("lane closed")
}
if minDelta.GreaterThan(types.NewInt(0)) && laneState.Nonce > sv.Nonce {
2019-09-25 12:56:04 +00:00
return types.NewInt(0), xerrors.Errorf("already storing voucher with higher nonce; %d > %d", laneState.Nonce, sv.Nonce)
}
// look for duplicates
for i, v := range ci.Vouchers {
if !sv.Equals(v.Voucher) {
continue
}
if v.Proof != nil {
if !bytes.Equal(v.Proof, proof) {
log.Warnf("AddVoucher: multiple proofs for single voucher, storing both")
break
}
log.Warnf("AddVoucher: voucher re-added with matching proof")
return types.NewInt(0), nil
}
log.Warnf("AddVoucher: adding proof to stored voucher")
ci.Vouchers[i] = &VoucherInfo{
Voucher: v.Voucher,
Proof: proof,
}
return types.NewInt(0), pm.store.putChannelInfo(ci)
}
delta := types.BigSub(sv.Amount, laneState.Redeemed)
if minDelta.GreaterThan(delta) {
return delta, xerrors.Errorf("addVoucher: supplied token amount too low; minD=%s, D=%s; laneAmt=%s; v.Amt=%s", minDelta, delta, laneState.Redeemed, sv.Amount)
}
ci.Vouchers = append(ci.Vouchers, &VoucherInfo{
Voucher: sv,
Proof: proof,
})
if ci.NextLane <= sv.Lane {
ci.NextLane = sv.Lane + 1
}
return delta, pm.store.putChannelInfo(ci)
}
2019-08-12 19:51:01 +00:00
func (pm *Manager) AllocateLane(ch address.Address) (uint64, error) {
return pm.store.AllocateLane(ch)
}
2019-09-09 13:59:07 +00:00
func (pm *Manager) ListVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
2019-08-12 19:51:01 +00:00
// TODO: just having a passthrough method like this feels odd. Seems like
// there should be some filtering we're doing here
return pm.store.VouchersForPaych(ch)
}
func (pm *Manager) OutboundChanTo(from, to address.Address) (address.Address, error) {
2019-09-16 13:46:05 +00:00
pm.store.lk.Lock()
defer pm.store.lk.Unlock()
return pm.store.findChan(func(ci *ChannelInfo) bool {
if ci.Direction != DirOutbound {
return false
}
return ci.Control == from && ci.Target == to
})
}
2019-08-12 19:51:01 +00:00
func (pm *Manager) NextNonceForLane(ctx context.Context, ch address.Address, lane uint64) (uint64, error) {
vouchers, err := pm.store.VouchersForPaych(ch)
if err != nil {
return 0, err
}
var maxnonce uint64
for _, v := range vouchers {
2019-09-09 13:59:07 +00:00
if v.Voucher.Lane == lane {
if v.Voucher.Nonce > maxnonce {
maxnonce = v.Voucher.Nonce
2019-08-12 19:51:01 +00:00
}
}
}
return maxnonce + 1, nil
2019-08-12 19:51:01 +00:00
}