Introduce new commitment format to enforce channel lease expirations in scripts

breacharbiter_test.go

@@ -2296,6 +2296,7 @@ func createInitChannels(revocationWindow int) (*lnwallet.LightningChannel, *lnwa
 	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(
 		channelBal, channelBal, &aliceCfg, &bobCfg, aliceCommitPoint,
 		bobCommitPoint, *fundingTxIn, channeldb.SingleFunderTweaklessBit,
+		false, 0,
 	)
 	if err != nil {
 		return nil, nil, nil, err

chanacceptor/rpcacceptor.go

@@ -256,6 +256,42 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 			req := newRequest.request
 			pendingChanID := req.OpenChanMsg.PendingChannelID
 
+			// Map the channel commitment type to its RPC
+			// counterpart.
+			var commitmentType lnrpc.CommitmentType
+			if req.OpenChanMsg.ChannelType != nil {
+				channelFeatures := lnwire.RawFeatureVector(
+					*req.OpenChanMsg.ChannelType,
+				)
+				switch {
+				case channelFeatures.OnlyContains(
+					lnwire.ScriptEnforcedLeaseRequired,
+					lnwire.AnchorsZeroFeeHtlcTxRequired,
+					lnwire.StaticRemoteKeyRequired,
+				):
+					commitmentType = lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE
+
+				case channelFeatures.OnlyContains(
+					lnwire.AnchorsZeroFeeHtlcTxRequired,
+					lnwire.StaticRemoteKeyRequired,
+				):
+					commitmentType = lnrpc.CommitmentType_ANCHORS
+
+				case channelFeatures.OnlyContains(
+					lnwire.StaticRemoteKeyRequired,
+				):
+					commitmentType = lnrpc.CommitmentType_STATIC_REMOTE_KEY
+
+				case channelFeatures.OnlyContains():
+					commitmentType = lnrpc.CommitmentType_LEGACY
+
+				default:
+					log.Warnf("Unhandled commitment type "+
+						"in channel acceptor request: %v",
+						req.OpenChanMsg.ChannelType)
+				}
+			}
+
 			acceptRequests[pendingChanID] = newRequest
 
 			// A ChannelAcceptRequest has been received, send it to the client.
@@ -273,6 +309,7 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 				CsvDelay:         uint32(req.OpenChanMsg.CsvDelay),
 				MaxAcceptedHtlcs: uint32(req.OpenChanMsg.MaxAcceptedHTLCs),
 				ChannelFlags:     uint32(req.OpenChanMsg.ChannelFlags),
+				CommitmentType:   commitmentType,
 			}
 
 			if err := r.send(chanAcceptReq); err != nil {

chanbackup/single.go

@@ -40,6 +40,13 @@ const (
 	// AnchorsZeroFeeHtlcTxCommitVersion is a version that denotes this
 	// channel is using the zero-fee second-level anchor commitment format.
 	AnchorsZeroFeeHtlcTxCommitVersion = 3
+
+	// ScriptEnforcedLeaseVersion is a version that denotes this channel is
+	// using the zero-fee second-level anchor commitment format along with
+	// an additional CLTV requirement of the channel lease maturity on any
+	// commitment and HTLC outputs that pay directly to the channel
+	// initiator.
+	ScriptEnforcedLeaseVersion = 4
 )
 
 // Single is a static description of an existing channel that can be used for
@@ -116,6 +123,16 @@ type Single struct {
 	// ShaChainRootDesc describes how to derive the private key that was
 	// used as the shachain root for this channel.
 	ShaChainRootDesc keychain.KeyDescriptor
+
+	// LeaseExpiry represents the absolute expiration as a height of the
+	// chain of a channel lease that is applied to every output that pays
+	// directly to the channel initiator in addition to the usual CSV
+	// requirement.
+	//
+	// NOTE: This field will only be present for the following versions:
+	//
+	// - ScriptEnforcedLeaseVersion
+	LeaseExpiry uint32
 }
 
 // NewSingle creates a new static channel backup based on an existing open
@@ -177,6 +194,10 @@ func NewSingle(channel *channeldb.OpenChannel,
 	}
 
 	switch {
+	case channel.ChanType.HasLeaseExpiration():
+		single.Version = ScriptEnforcedLeaseVersion
+		single.LeaseExpiry = channel.ThawHeight
+
 	case channel.ChanType.ZeroHtlcTxFee():
 		single.Version = AnchorsZeroFeeHtlcTxCommitVersion
 
@@ -203,6 +224,7 @@ func (s *Single) Serialize(w io.Writer) error {
 	case TweaklessCommitVersion:
 	case AnchorsCommitVersion:
 	case AnchorsZeroFeeHtlcTxCommitVersion:
+	case ScriptEnforcedLeaseVersion:
 	default:
 		return fmt.Errorf("unable to serialize w/ unknown "+
 			"version: %v", s.Version)
@@ -264,6 +286,12 @@ func (s *Single) Serialize(w io.Writer) error {
 	); err != nil {
 		return err
 	}
+	if s.Version == ScriptEnforcedLeaseVersion {
+		err := lnwire.WriteElements(&singleBytes, s.LeaseExpiry)
+		if err != nil {
+			return err
+		}
+	}
 
 	return lnwire.WriteElements(
 		w,
@@ -363,6 +391,7 @@ func (s *Single) Deserialize(r io.Reader) error {
 	case TweaklessCommitVersion:
 	case AnchorsCommitVersion:
 	case AnchorsZeroFeeHtlcTxCommitVersion:
+	case ScriptEnforcedLeaseVersion:
 	default:
 		return fmt.Errorf("unable to de-serialize w/ unknown "+
 			"version: %v", s.Version)
@@ -456,8 +485,18 @@ func (s *Single) Deserialize(r io.Reader) error {
 		return err
 	}
 	s.ShaChainRootDesc.KeyLocator.Family = keychain.KeyFamily(shaKeyFam)
+	err = lnwire.ReadElements(r, &s.ShaChainRootDesc.KeyLocator.Index)
+	if err != nil {
+		return err
+	}
+
+	if s.Version == ScriptEnforcedLeaseVersion {
+		if err := lnwire.ReadElement(r, &s.LeaseExpiry); err != nil {
+			return err
+		}
+	}
 
-	return lnwire.ReadElements(r, &s.ShaChainRootDesc.KeyLocator.Index)
+	return nil
 }
 
 // UnpackFromReader is similar to Deserialize method, but it expects the passed

chanbackup/single_test.go

@@ -124,10 +124,7 @@ func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
 		isInitiator = true
 	}
 
-	chanType := channeldb.SingleFunderBit
-	if rand.Int63()%2 == 0 {
-		chanType = channeldb.SingleFunderTweaklessBit
-	}
+	chanType := channeldb.ChannelType(rand.Intn(8))
 
 	return &channeldb.OpenChannel{
 		ChainHash:       chainHash,
@@ -137,6 +134,7 @@ func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
 		ShortChannelID: lnwire.NewShortChanIDFromInt(
 			uint64(rand.Int63()),
 		),
+		ThawHeight:  rand.Uint32(),
 		IdentityPub: pub,
 		LocalChanCfg: channeldb.ChannelConfig{
 			ChannelConstraints: channeldb.ChannelConstraints{
@@ -243,6 +241,13 @@ func TestSinglePackUnpack(t *testing.T) {
 			valid:   true,
 		},
 
+		// The new script enforced channel lease version should
+		// pack/unpack with no problem.
+		{
+			version: ScriptEnforcedLeaseVersion,
+			valid:   true,
+		},
+
 		// A non-default version, atm this should result in a failure.
 		{
 			version: 99,
@@ -293,8 +298,9 @@ func TestSinglePackUnpack(t *testing.T) {
 				t.Fatalf("unable to serialize single: %v", err)
 			}
 
+			// Mutate the version byte to an unknown version.
 			rawBytes := rawSingle.Bytes()
-			rawBytes[0] ^= 5
+			rawBytes[0] = ^uint8(0)
 
 			newReader := bytes.NewReader(rawBytes)
 			err = unpackedSingle.Deserialize(newReader)

channeldb/channel.go

@@ -257,6 +257,11 @@ const (
 	// ZeroHtlcTxFeeBit indicates that the channel should use zero-fee
 	// second-level HTLC transactions.
 	ZeroHtlcTxFeeBit ChannelType = 1 << 5
+
+	// LeaseExpirationBit indicates that the channel has been leased for a
+	// period of time, constraining every output that pays to the channel
+	// initiator with an additional CLTV of the lease maturity.
+	LeaseExpirationBit ChannelType = 1 << 6
 )
 
 // IsSingleFunder returns true if the channel type if one of the known single
@@ -301,6 +306,11 @@ func (c ChannelType) IsFrozen() bool {
 	return c&FrozenBit == FrozenBit
 }
 
+// HasLeaseExpiration returns true if the channel originated from a lease.
+func (c ChannelType) HasLeaseExpiration() bool {
+	return c&LeaseExpirationBit == LeaseExpirationBit
+}
+
 // ChannelConstraints represents a set of constraints meant to allow a node to
 // limit their exposure, enact flow control and ensure that all HTLCs are
 // economically relevant. This struct will be mirrored for both sides of the
@@ -1363,7 +1373,7 @@ func putOpenChannel(chanBucket kvdb.RwBucket, channel *OpenChannel) error {
 
 	// Next, if this is a frozen channel, we'll add in the axillary
 	// information we need to store.
-	if channel.ChanType.IsFrozen() {
+	if channel.ChanType.IsFrozen() || channel.ChanType.HasLeaseExpiration() {
 		err := storeThawHeight(
 			chanBucket, channel.ThawHeight,
 		)
@@ -1404,7 +1414,7 @@ func fetchOpenChannel(chanBucket kvdb.RBucket,
 
 	// Next, if this is a frozen channel, we'll add in the axillary
 	// information we need to store.
-	if channel.ChanType.IsFrozen() {
+	if channel.ChanType.IsFrozen() || channel.ChanType.HasLeaseExpiration() {
 		thawHeight, err := fetchThawHeight(chanBucket)
 		if err != nil {
 			return nil, fmt.Errorf("unable to store thaw "+
@@ -2871,7 +2881,7 @@ func (c *OpenChannel) CloseChannel(summary *ChannelCloseSummary,
 
 		// We'll also remove the channel from the frozen channel bucket
 		// if we need to.
-		if c.ChanType.IsFrozen() {
+		if c.ChanType.IsFrozen() || c.ChanType.HasLeaseExpiration() {
 			err := deleteThawHeight(chanBucket)
 			if err != nil {
 				return err
@@ -3071,13 +3081,14 @@ func (c *OpenChannel) RemoteRevocationStore() (shachain.Store, error) {
 // channel is not frozen, then 0 is returned.
 func (c *OpenChannel) AbsoluteThawHeight() (uint32, error) {
 	// Only frozen channels have a thaw height.
-	if !c.ChanType.IsFrozen() {
+	if !c.ChanType.IsFrozen() && !c.ChanType.HasLeaseExpiration() {
 		return 0, nil
 	}
 
-	// If the channel's thaw height is below the absolute threshold, then
-	// it's interpreted as a relative height to the chain's current height.
-	if c.ThawHeight < AbsoluteThawHeightThreshold {
+	// If the channel has the frozen bit set and it's thaw height is below
+	// the absolute threshold, then it's interpreted as a relative height to
+	// the chain's current height.
+	if c.ChanType.IsFrozen() && c.ThawHeight < AbsoluteThawHeightThreshold {
 		// We'll only known of the channel's short ID once it's
 		// confirmed.
 		if c.IsPending {
@@ -3086,6 +3097,7 @@ func (c *OpenChannel) AbsoluteThawHeight() (uint32, error) {
 		}
 		return c.ShortChannelID.BlockHeight + c.ThawHeight, nil
 	}
+
 	return c.ThawHeight, nil
 }
 

chanrestore.go

@@ -149,6 +149,12 @@ func (c *chanDBRestorer) openChannelShell(backup chanbackup.Single) (
 		chanType |= channeldb.AnchorOutputsBit
 		chanType |= channeldb.SingleFunderTweaklessBit
 
+	case chanbackup.ScriptEnforcedLeaseVersion:
+		chanType = channeldb.LeaseExpirationBit
+		chanType |= channeldb.ZeroHtlcTxFeeBit
+		chanType |= channeldb.AnchorOutputsBit
+		chanType |= channeldb.SingleFunderTweaklessBit
+
 	default:
 		return nil, fmt.Errorf("unknown Single version: %v", err)
 	}
@@ -172,6 +178,7 @@ func (c *chanDBRestorer) openChannelShell(backup chanbackup.Single) (
 			RemoteCurrentRevocation: backup.RemoteNodePub,
 			RevocationStore:         shachain.NewRevocationStore(),
 			RevocationProducer:      shaChainProducer,
+			ThawHeight:              backup.LeaseExpiry,
 		},
 	}
 

cmd/lncli/cmd_open_channel.go

@@ -57,6 +57,9 @@ Signed base64 encoded PSBT or hex encoded raw wire TX (or path to text file): `
 	// the user from choosing a large file by accident and running into out
 	// of memory issues or other weird errors.
 	psbtMaxFileSize = 1024 * 1024
+
+	channelTypeTweakless = "tweakless"
+	channelTypeAnchors   = "anchors"
 )
 
 // TODO(roasbeef): change default number of confirmations
@@ -200,6 +203,12 @@ var openChannelCommand = cli.Command{
 			Usage: "(optional) the maximum value in msat that " +
 				"can be pending within the channel at any given time",
 		},
+		cli.StringFlag{
+			Name: "channel_type",
+			Usage: fmt.Sprintf("(optional) the type of channel to "+
+				"propose to the remote peer (%q, %q)",
+				channelTypeTweakless, channelTypeAnchors),
+		},
 	},
 	Action: actionDecorator(openChannel),
 }
@@ -307,6 +316,19 @@ func openChannel(ctx *cli.Context) error {
 
 	req.Private = ctx.Bool("private")
 
+	// Parse the channel type and map it to its RPC representation.
+	channelType := ctx.String("channel_type")
+	switch channelType {
+	case "":
+		break
+	case channelTypeTweakless:
+		req.CommitmentType = lnrpc.CommitmentType_STATIC_REMOTE_KEY
+	case channelTypeAnchors:
+		req.CommitmentType = lnrpc.CommitmentType_ANCHORS
+	default:
+		return fmt.Errorf("unsupported channel type %v", channelType)
+	}
+
 	// PSBT funding is a more involved, interactive process that is too
 	// large to also fit into this already long function.
 	if ctx.Bool("psbt") {

contractcourt/anchor_resolver.go

@@ -192,6 +192,13 @@ func (c *anchorResolver) IsResolved() bool {
 	return c.resolved
 }
 
+// SupplementState allows the user of a ContractResolver to supplement it with
+// state required for the proper resolution of a contract.
+//
+// NOTE: Part of the ContractResolver interface.
+func (c *anchorResolver) SupplementState(_ *channeldb.OpenChannel) {
+}
+
 // report returns a report on the resolution state of the contract.
 func (c *anchorResolver) report() *ContractReport {
 	c.reportLock.Lock()

contractcourt/chain_arbitrator.go

@@ -350,6 +350,9 @@ func newActiveChannelArbitrator(channel *channeldb.OpenChannel,
 				report,
 			)
 		},
+		FetchHistoricalChannel: func() (*channeldb.OpenChannel, error) {
+			return c.chanSource.FetchHistoricalChannel(&chanPoint)
+		},
 	}
 
 	// The final component needed is an arbitrator log that the arbitrator
@@ -558,6 +561,9 @@ func (c *ChainArbitrator) Start() error {
 					tx, c.cfg.ChainHash, &chanPoint, report,
 				)
 			},
+			FetchHistoricalChannel: func() (*channeldb.OpenChannel, error) {
+				return c.chanSource.FetchHistoricalChannel(&chanPoint)
+			},
 		}
 		chanLog, err := newBoltArbitratorLog(
 			c.chanSource.Backend, arbCfg, c.cfg.ChainHash, chanPoint,