rules: add ChanPolicyBounds rule

Author: ellemouton

rules/chan_policy_bounds.go

@@ -0,0 +1,334 @@
+package rules
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"github.com/lightninglabs/lightning-terminal/firewalldb"
+	"github.com/lightninglabs/lightning-terminal/litrpc"
+	mid "github.com/lightninglabs/lightning-terminal/rpcmiddleware"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"google.golang.org/protobuf/proto"
+)
+
+var (
+	// Compile-time checks to ensure that ChanPolicyBounds and
+	// ChanPolicyBoundsMgr implement the appropriate Manager, Enforcer and
+	// Values interface.
+	_ Manager  = (*ChanPolicyBoundsMgr)(nil)
+	_ Enforcer = (*ChanPolicyBounds)(nil)
+	_ Values   = (*ChanPolicyBounds)(nil)
+)
+
+// ChanPolicyBoundsName is the string identifier of the ChanPolicyBounds rule.
+const ChanPolicyBoundsName = "channel-policy-bounds"
+
+// ChanPolicyBoundsMgr manages the ChanPolicyBounds rule.
+type ChanPolicyBoundsMgr struct{}
+
+// Stop cleans up the resources held by the manager.
+//
+// NOTE: This is part of the Manager interface.
+func (b *ChanPolicyBoundsMgr) Stop() error {
+	return nil
+}
+
+// NewEnforcer constructs a new ChanPolicyBounds rule enforcer using the passed
+// values and config.
+//
+// NOTE: This is part of the Manager interface.
+func (b *ChanPolicyBoundsMgr) NewEnforcer(_ Config, values Values) (Enforcer,
+	error) {
+
+	bounds, ok := values.(*ChanPolicyBounds)
+	if !ok {
+		return nil, fmt.Errorf("values must be of type "+
+			"ChanPolicyBounds, got %T", values)
+	}
+
+	return bounds, nil
+}
+
+// NewValueFromProto converts the given proto value into a ChanPolicyBounds
+// Value object.
+//
+// NOTE: This is part of the Manager interface.
+func (b *ChanPolicyBoundsMgr) NewValueFromProto(value *litrpc.RuleValue) (
+	Values, error) {
+
+	rv, ok := value.Value.(*litrpc.RuleValue_ChanPolicyBounds)
+	if !ok {
+		return nil, fmt.Errorf("incorrect RuleValue type")
+	}
+
+	policyBounds := rv.ChanPolicyBounds
+
+	return &ChanPolicyBounds{
+		MinBaseMsat:  policyBounds.MinBaseMsat,
+		MaxBaseMsat:  policyBounds.MaxBaseMsat,
+		MinRatePPM:   policyBounds.MinRatePpm,
+		MaxRatePPM:   policyBounds.MaxRatePpm,
+		MinCLTVDelta: policyBounds.MinCltvDelta,
+		MaxCLTVDelta: policyBounds.MaxCltvDelta,
+		MinHtlcMsat:  policyBounds.MinHtlcMsat,
+		MaxHtlcMsat:  policyBounds.MaxHtlcMsat,
+	}, nil
+}
+
+// EmptyValue returns a new instance of ChanPolicyBounds.
+//
+// NOTE: This is part of the Manager interface.
+func (b *ChanPolicyBoundsMgr) EmptyValue() Values {
+	return &ChanPolicyBounds{}
+}
+
+// ChanPolicyBounds represents the channel policy bounds rule.
+type ChanPolicyBounds struct {
+	// MinBaseMsat is the minimum base fee in msat that can set for a
+	// channel.
+	MinBaseMsat uint64 `json:"min_base_msat"`
+
+	// MaxBaseMsat is the maximum base fee in msat that can set for a
+	// channel.
+	MaxBaseMsat uint64 `json:"max_base_msat"`
+
+	// MinRatePPM is the minimum ppm fee in msat that can be set for a
+	// channel.
+	MinRatePPM uint32 `json:"min_rate_ppm"`
+
+	// MaxRatePPM is the maximum ppm fee in msat that can be set for a
+	// channel.
+	MaxRatePPM uint32 `json:"max_rate_ppm"`
+
+	// MinCLTVDelta is the minimum cltv delta that may set for a channel.
+	MinCLTVDelta uint32 `json:"min_cltv_delta"`
+
+	// MaxCLTVDelta is the maximum cltv delta that may set for a channel.
+	MaxCLTVDelta uint32 `json:"max_cltv_delta"`
+
+	// MinHtlcMsat is the minimum htlc size msat that may set for a channel.
+	MinHtlcMsat uint64 `json:"min_htlc_msat"`
+
+	// MaxHtlcMsat is the maximum htlc size in msat that may be set for a
+	// channel.
+	MaxHtlcMsat uint64 `json:"max_htlc_msat"`
+}
+
+// HandleRequest checks the validity of a request using the ChanPolicyBounds
+// rpcmiddleware.RoundTripCheckers.
+//
+// NOTE: this is part of the Enforcer interface.
+func (f *ChanPolicyBounds) HandleRequest(ctx context.Context, uri string,
+	msg proto.Message) (proto.Message, error) {
+
+	checkers := f.checkers()
+	if checkers == nil {
+		return nil, nil
+	}
+
+	checker, ok := checkers[uri]
+	if !ok {
+		return nil, nil
+	}
+
+	if !checker.HandlesRequest(msg.ProtoReflect().Type()) {
+		return nil, fmt.Errorf("invalid implementation, checker "+
+			"for URI %s does not accept request of type %v",
+			uri, msg.ProtoReflect().Type())
+	}
+
+	return checker.HandleRequest(ctx, msg)
+}
+
+// HandleResponse handles and possible alters a response. This is a noop for the
+// ChanPolicyBounds rule.
+//
+// NOTE: this is part of the Enforcer interface.
+func (f *ChanPolicyBounds) HandleResponse(_ context.Context, _ string,
+	_ proto.Message) (proto.Message, error) {
+
+	return nil, nil
+}
+
+// HandleErrorResponse handles and possible alters an error. This is a noop for
+// the ChanPolicyBounds rule.
+//
+// NOTE: this is part of the Enforcer interface.
+func (f *ChanPolicyBounds) HandleErrorResponse(_ context.Context, _ string,
+	_ error) (error, error) {
+
+	return nil, nil
+}
+
+// checkers returns a map of URI to rpcmiddleware.RoundTripChecker which define
+// how the URI should be handled.
+func (f *ChanPolicyBounds) checkers() map[string]mid.RoundTripChecker {
+	return map[string]mid.RoundTripChecker{
+		"/lnrpc.Lightning/UpdateChannelPolicy": mid.NewRequestChecker(
+			&lnrpc.PolicyUpdateRequest{},
+			&lnrpc.PolicyUpdateResponse{},
+			func(ctx context.Context,
+				r *lnrpc.PolicyUpdateRequest) error {
+
+				return f.checkPolicyUpdate(ctx, r)
+			},
+		),
+	}
+}
+
+// checkPolicyUpdate verifies that the given lnrpc.PolicyUpdateRequest request
+// is valid given the ChanPolicyBounds values.
+func (f *ChanPolicyBounds) checkPolicyUpdate(_ context.Context,
+	req *lnrpc.PolicyUpdateRequest) error {
+
+	if req.BaseFeeMsat < int64(f.MinBaseMsat) ||
+		req.BaseFeeMsat > int64(f.MaxBaseMsat) {
+
+		return fmt.Errorf("invalid base fee amount")
+	}
+
+	if req.FeeRate == 0 && req.FeeRatePpm == 0 && f.MinRatePPM > 0 {
+		return fmt.Errorf("invalid fee rate")
+	}
+
+	feeRate := req.FeeRatePpm
+	if req.FeeRate != 0 {
+		feeRate = uint32(math.Round(req.FeeRate * 1000000))
+	}
+
+	if feeRate < f.MinRatePPM || feeRate > f.MaxRatePPM {
+		return fmt.Errorf("invalid fee rate")
+	}
+
+	if req.TimeLockDelta < f.MinCLTVDelta ||
+		req.TimeLockDelta > f.MaxCLTVDelta {
+
+		return fmt.Errorf("invalid cltv delta")
+	}
+
+	if req.MinHtlcMsatSpecified {
+		if req.MinHtlcMsat < f.MinHtlcMsat {
+			return fmt.Errorf("invalid min htlc msat amount")
+		}
+	}
+
+	if req.MaxHtlcMsat > f.MaxHtlcMsat {
+		return fmt.Errorf("invalid max htlc msat amount")
+	}
+
+	return nil
+}
+
+// VerifySane checks that the value of the values is ok given the min and max
+// allowed values.
+//
+// NOTE: this is part of the Values interface.
+func (f *ChanPolicyBounds) VerifySane(minVal, maxVal Values) error {
+	minFB, ok := minVal.(*ChanPolicyBounds)
+	if !ok {
+		return fmt.Errorf("min value is not of type ChanPolicyBounds")
+	}
+
+	maxFB, ok := maxVal.(*ChanPolicyBounds)
+	if !ok {
+		return fmt.Errorf("max value is not of type ChanPolicyBounds")
+	}
+
+	if !(f.MinBaseMsat >= minFB.MinBaseMsat &&
+		f.MinBaseMsat <= maxFB.MinBaseMsat) {
+
+		return fmt.Errorf("invalid min base fee")
+	}
+
+	if !(f.MaxBaseMsat >= minFB.MaxBaseMsat &&
+		f.MaxBaseMsat <= maxFB.MaxBaseMsat) {
+
+		return fmt.Errorf("invalid max base fee")
+	}
+
+	if !(f.MinRatePPM >= minFB.MinRatePPM &&
+		f.MinRatePPM <= maxFB.MinRatePPM) {
+
+		return fmt.Errorf("invalid min proportional fee")
+	}
+
+	if !(f.MaxRatePPM >= minFB.MaxRatePPM &&
+		f.MaxRatePPM <= maxFB.MaxRatePPM) {
+
+		return fmt.Errorf("invalid max proportional fee")
+	}
+
+	if !(f.MinCLTVDelta >= minFB.MinCLTVDelta &&
+		f.MinCLTVDelta <= maxFB.MinCLTVDelta) {
+
+		return fmt.Errorf("invalid min cltv delta")
+	}
+
+	if !(f.MaxCLTVDelta >= minFB.MaxCLTVDelta &&
+		f.MaxCLTVDelta <= maxFB.MaxCLTVDelta) {
+
+		return fmt.Errorf("invalid max cltv delta")
+	}
+
+	if !(f.MinHtlcMsat >= minFB.MinHtlcMsat &&
+		f.MinHtlcMsat <= maxFB.MinHtlcMsat) {
+
+		return fmt.Errorf("invalid min htlc msat amt")
+	}
+
+	if !(f.MaxHtlcMsat >= minFB.MaxHtlcMsat &&
+		f.MaxHtlcMsat <= maxFB.MaxHtlcMsat) {
+
+		return fmt.Errorf("invalid max htlc msat amt")
+	}
+
+	return nil
+}
+
+// ToProto converts the rule Values to the litrpc counterpart.
+//
+// NOTE: this is part of the Values interface.
+func (f *ChanPolicyBounds) ToProto() *litrpc.RuleValue {
+	return &litrpc.RuleValue{
+		Value: &litrpc.RuleValue_ChanPolicyBounds{
+			ChanPolicyBounds: &litrpc.ChannelPolicyBounds{
+				MinBaseMsat:  f.MinBaseMsat,
+				MaxBaseMsat:  f.MaxBaseMsat,
+				MinRatePpm:   f.MinRatePPM,
+				MaxRatePpm:   f.MaxRatePPM,
+				MinCltvDelta: f.MinCLTVDelta,
+				MaxCltvDelta: f.MaxCLTVDelta,
+				MinHtlcMsat:  f.MinHtlcMsat,
+				MaxHtlcMsat:  f.MaxHtlcMsat,
+			},
+		},
+	}
+}
+
+// RuleName returns the name of the rule that these values are to be used with.
+//
+// NOTE: this is part of the Values interface.
+func (f *ChanPolicyBounds) RuleName() string {
+	return ChanPolicyBoundsName
+}
+
+// PseudoToReal attempts to convert any appropriate pseudo fields in the rule
+// Values to their corresponding real values. It uses the passed PrivacyMapDB to
+// find the real values. This is a no-op for the ChanPolicyBounds rule.
+//
+// NOTE: this is part of the Values interface.
+func (f *ChanPolicyBounds) PseudoToReal(_ firewalldb.PrivacyMapDB) (Values,
+	error) {
+
+	return f, nil
+}
+
+// RealToPseudo converts the rule Values to a new one that uses pseudo keys,
+// channel IDs, channel points etc. It returns a map of real to pseudo strings
+// that should be persisted. This is a no-op for the ChanPolicyBounds rule.
+//
+// NOTE: this is part of the Values interface.
+func (f *ChanPolicyBounds) RealToPseudo() (Values, map[string]string, error) {
+	return f, nil, nil
+}