[WIP] Add HTLCs to channels (#251)

* Very preliminary woork

* OfferHTLC function and HashSig message

* Fewer RTTs by pre-sharing HTLC basepoints

* Generating commitment transactions containing HTLC outputs

* Generate our HTLCBase and finish building the commitment transaction and HTLC-failure/success transactions for a given state

* Sign their txs that they store

* Verify our txs that we store

* Remove TODO and fix comment

* Work so far compiles

* HTLC serialisation and deserialisation

* Save HTLCs in the database and reload them

* Exchange HTLC bases during channel fund

* Only add an InProgHTLC to the channel state if it's not nil

* Define HTLCBytes

* Missed PointRespMsg serialisation

* PointResp is 166 bytes

* StatCom is now a different size too

* More error messages

* Be sure to write false if there is no InProgHTLC

* Remove debugging prints

* Send and verify HTLCSigs with DeltaSig, GapSigRev and SigRev messages

* Add HashSigHandler

* Add AddHTLC RPC to litrpc and lit-af

* Lit knows how to decode a HashSig message now

* I guess slices don't work like that...

* It's a hashsig not a deltasig

* The Amt is 8 bytes

* Add some loggin during HTLC output build

* Add RHash to HashSigMsg

* buffer.Len() gives the unread buffer length

* Logging HTLC signatures

* Generate new privkey for each HTLC state using elkpoints

* Use an elkpoint we actually have

* Use elkrem point we have

* Print elkpoints being used for signing/verifying HTLC txs

* Try next elkpoint

* Print pkh output amt

* Only subtract HTLC balances if they're incoming

* Try calculating amounts this way instead

* Only reject REV if there's no inProgHTLC

* Those pesky slices again

* Work on output value calculation

* Give N2HTLCBase after signing

* InProgHTLC was already nil when calculating a new HTLCBase was required

* Progress on clearing HTLCs

* Add clear to litRPC and lit-af

* Check for error when building state tx in BuildJusticeSig

* Do not fail RevHandler if we're clearing an HTLC

* Check we're not clearing in SigRevHandler too

* Locktime check was backwards

* Only subtract uncleared HTLCs from channel value when calculating balances

* Only subtract uncleared HTLCs from channel value when calculating balances here too

* Give CTS after non-fatal clear HTLC errors

* Refactor balance calculation to its own function

* Fix compile

* Potentially fix segfault

* No need to check these things and fix some messages

* Don't allow coop close if there are uncleared HTLCs

* Check their close tx signature

* Allows connecting to hostnames (again)

* Added extra logging, fixed compatibility with master

* Detect and ignore HTLC outputs from GetCloseTxos

* Store and monitor HTLC Outpoints

* Store and monitor HTLC outpoints

* Restructuring of HTLC watching

* Added code to claim HTLC, work in progress

* Work in progress on claim TX

* Split generate script and output so we can fetch the script for spending

* Fixed witness program verification error

* Additional logging

* Added claim command to lit-af for testing purposes

* Succesful on-chain claim of HTLC Success TX

* Claim HTLCs when we see the preimage in an on-chain spend

* Add timeout UTXO to the wallit after claiming success htlc after break

* Claiming HTLC timeouts onchain

* This was good, presig stack was wrong.

* Fixes locktime problem

* Justice implementation

* Fixed refactoring bug

* Optimized logging

* Justice TXes working for HTLC

* Fixes broken unit tests for HTLC

* Adds configurable locktime

* Fix crashed caused by off-by-one error in argument passing code for HTLCs

* Fixes invalid memory address bug

* Ignore further processing if no HTLC is found

* Added separate boolean for tracking on-chain clearing of HTLC

* HLTC byte size is now 1 bigger too

* Bugfix in signature verification in PreimageSigHandler

* Correct log statements to use log.Printf in stead of fmt

* Unlock the channel on error, fetch the Qchan from the right place

* Height 0 should show as unconfirmed in lit-af

* Handling HashSig-HashSig collisions

* Manage DeltaSig-HashSig collisions

* Manage HashSig-PreimageSig collisions

* Manage PreimageSig-PreimageSig collisions

* Manage PreimageSig-DeltaSig collisions

* Fixes unit test for GapSigRev

* Try autoclearing after preimagesig

* Fix deadlock caused by holding RemoteMtx when blocking on OmniOut send

* Use the real Qchan when clearing

Author: metalicjames

.dockerignore

@@ -0,0 +1 @@
+webui/

cmd/lit-af/chancmds.go

@@ -96,6 +96,29 @@ var historyCommand = &Command{
 	ShortDescription: "Show all the metadata for justice txs.\n",
 }
 
+var addHTLCCommand = &Command{
+	Format: fmt.Sprintf("%s%s%s\n", lnutil.White("add"), lnutil.ReqColor("channel idx", "amount", "locktime", "RHash"), lnutil.OptColor("data")),
+	Description: fmt.Sprintf("%s\n%s\n",
+		"Add an HTLC of the given amount (in satoshis) to the given channel. Locktime specifies the number of blocks the HTLC stays active before timing out",
+		"Optionally, the push operation can be associated with a 32 byte value hex encoded."),
+	ShortDescription: "Add HTLC of the given amount (in satoshis) to the given channel.\n",
+}
+
+var clearHTLCCommand = &Command{
+	Format: fmt.Sprintf("%s%s%s\n", lnutil.White("clear"), lnutil.ReqColor("channel idx", "HTLC idx", "R"), lnutil.OptColor("data")),
+	Description: fmt.Sprintf("%s\n%s\n%s\n",
+		"Clear an HTLC of the given index from the given channel.",
+		"Optionally, the push operation can be associated with a 32 byte value hex encoded.",
+		"Set R to zero to timeout the HTLC"),
+	ShortDescription: "Clear HTLC of the given index from the given channel.\n",
+}
+
+var claimHTLCCommand = &Command{
+	Format:           fmt.Sprintf("%s%s\n", lnutil.White("claim"), lnutil.ReqColor("R")),
+	Description:      "Claim any on-chain HTLC that matches the given preimage. Use this to claim an HTLC after the channel is broken.\n",
+	ShortDescription: "Clear HTLC of the given index from the given channel.\n",
+}
+
 func (lc *litAfClient) History(textArgs []string) error {
 	if len(textArgs) > 0 && textArgs[0] == "-h" {
 		fmt.Fprintf(color.Output, historyCommand.Format)
@@ -436,3 +459,132 @@ func (lc *litAfClient) Watch(textArgs []string) error {
 
 	return nil
 }
+
+// Add is the shell command which calls AddHTLC
+func (lc *litAfClient) AddHTLC(textArgs []string) error {
+	stopEx, err := CheckHelpCommand(addHTLCCommand, textArgs, 3)
+
+	if err != nil || stopEx {
+		return err
+	}
+
+	args := new(litrpc.AddHTLCArgs)
+	reply := new(litrpc.AddHTLCReply)
+
+	// this stuff is all the same as in cclose, should put into a function...
+	cIdx, err := strconv.Atoi(textArgs[0])
+	if err != nil {
+		return err
+	}
+	amt, err := strconv.Atoi(textArgs[1])
+	if err != nil {
+		return err
+	}
+	locktime, err := strconv.Atoi(textArgs[2])
+	if err != nil {
+		return err
+	}
+
+	RHash, err := hex.DecodeString(textArgs[3])
+	if err != nil {
+		return err
+	}
+	copy(args.RHash[:], RHash[:])
+
+	if len(textArgs) > 4 {
+		data, err := hex.DecodeString(textArgs[4])
+		if err != nil {
+			// Wasn't valid hex, copy directly and truncate
+			copy(args.Data[:], textArgs[4])
+		} else {
+			copy(args.Data[:], data[:])
+		}
+	}
+
+	args.ChanIdx = uint32(cIdx)
+	args.Amt = int64(amt)
+	args.LockTime = uint32(locktime)
+
+	err = lc.Call("LitRPC.AddHTLC", args, reply)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(color.Output, "Added HTLC %s at state %s idx %s\n", lnutil.SatoshiColor(int64(amt)), lnutil.White(reply.StateIndex), lnutil.White(reply.HTLCIndex))
+
+	return nil
+}
+
+// Clear is the shell command which calls ClearHTLC
+func (lc *litAfClient) ClearHTLC(textArgs []string) error {
+	stopEx, err := CheckHelpCommand(clearHTLCCommand, textArgs, 3)
+	if err != nil || stopEx {
+		return err
+	}
+
+	args := new(litrpc.ClearHTLCArgs)
+	reply := new(litrpc.ClearHTLCReply)
+
+	// this stuff is all the same as in cclose, should put into a function...
+	cIdx, err := strconv.Atoi(textArgs[0])
+	if err != nil {
+		return err
+	}
+	HTLCIdx, err := strconv.Atoi(textArgs[1])
+	if err != nil {
+		return err
+	}
+
+	R, err := hex.DecodeString(textArgs[2])
+	if err != nil {
+		return err
+	}
+	copy(args.R[:], R[:])
+
+	if len(textArgs) > 3 {
+		data, err := hex.DecodeString(textArgs[3])
+		if err != nil {
+			// Wasn't valid hex, copy directly and truncate
+			copy(args.Data[:], textArgs[3])
+		} else {
+			copy(args.Data[:], data[:])
+		}
+	}
+
+	args.ChanIdx = uint32(cIdx)
+	args.HTLCIdx = uint32(HTLCIdx)
+
+	err = lc.Call("LitRPC.ClearHTLC", args, reply)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(color.Output, "Cleared HTLC %s at state %s\n", lnutil.White(HTLCIdx), lnutil.White(reply.StateIndex))
+
+	return nil
+}
+
+// Clear is the shell command which calls ClearHTLC
+func (lc *litAfClient) ClaimHTLC(textArgs []string) error {
+	stopEx, err := CheckHelpCommand(claimHTLCCommand, textArgs, 1)
+	if err != nil || stopEx {
+		return err
+	}
+
+	args := new(litrpc.ClaimHTLCArgs)
+	reply := new(litrpc.TxidsReply)
+
+	R, err := hex.DecodeString(textArgs[0])
+	if err != nil {
+		return err
+	}
+	copy(args.R[:], R[:])
+
+	err = lc.Call("LitRPC.ClaimHTLC", args, reply)
+	if err != nil {
+		return err
+	}
+	for _, txid := range reply.Txids {
+		fmt.Fprintf(color.Output, "Claimed HTLC with txid %s\n", lnutil.White(txid))
+	}
+
+	return nil
+}

cmd/lit-af/shell.go

@@ -108,6 +108,21 @@ func (lc *litAfClient) Shellparse(cmdslice []string) error {
 		return parseErr(err, "push")
 	}
 
+	if cmd == "add" {
+		err = lc.AddHTLC(args)
+		return parseErr(err, "add")
+	}
+
+	if cmd == "clear" {
+		err = lc.ClearHTLC(args)
+		return parseErr(err, "clear")
+	}
+
+	if cmd == "claim" {
+		err = lc.ClaimHTLC(args)
+		return parseErr(err, "claim")
+	}
+
 	if cmd == "con" { // connect to lnd host
 		err = lc.Connect(args)
 		return parseErr(err, "con")
@@ -275,7 +290,7 @@ func (lc *litAfClient) Ls(textArgs []string) error {
 	}
 
 	for _, c := range openChannels {
-		if c.Height == -1 {
+		if c.Height <= 0 {
 			c := color.New(color.FgGreen).Add(color.Underline)
 			c.Printf("Unconfirmed:")
 			fmt.Fprintf(color.Output, lnutil.Green("  "))
@@ -398,15 +413,15 @@ func printHelp(commands []*Command) {
 func printCointypes() {
 	for k, v := range coinparam.RegisteredNets {
 		fmt.Fprintf(color.Output, "CoinType: %s\n", strconv.Itoa(int(k)))
-		fmt.Fprintf(color.Output, "└────── Name: %-13sBech32Prefix: %s\n\n", v.Name + ",", v.Bech32Prefix)
+		fmt.Fprintf(color.Output, "└────── Name: %-13sBech32Prefix: %s\n\n", v.Name+",", v.Bech32Prefix)
 	}
 }
 
 func (lc *litAfClient) Help(textArgs []string) error {
 	if len(textArgs) == 0 {
 
 		fmt.Fprintf(color.Output, lnutil.Header("Commands:\n"))
-		listofCommands := []*Command{helpCommand, sayCommand, lsCommand, addressCommand, sendCommand, fanCommand, sweepCommand, lisCommand, conCommand, dlcCommand, fundCommand, dualFundCommand, watchCommand, pushCommand, closeCommand, breakCommand, historyCommand, offCommand, exitCommand}
+		listofCommands := []*Command{helpCommand, sayCommand, lsCommand, addressCommand, sendCommand, fanCommand, sweepCommand, lisCommand, conCommand, dlcCommand, fundCommand, dualFundCommand, watchCommand, pushCommand, closeCommand, breakCommand, addHTLCCommand, clearHTLCCommand, historyCommand, offCommand, exitCommand}
 		printHelp(listofCommands)
 		fmt.Fprintf(color.Output, "\n\n")
 		fmt.Fprintf(color.Output, lnutil.Header("Coins:\n"))

consts/consts.go

@@ -11,4 +11,5 @@ const (
 	MinOutput       = 100000           // minOutput is the minimum output amt, post fee. This (plus fees) is also the minimum channel balance
 	MinSendAmt      = 10000            // minimum amount that can be sent through a chan
 	MaxTxLen        = 100000           // maximum number of tx's that can be ingested at once
+	DefaultLockTime = 500
 )

litrpc/chancmds.go

@@ -450,3 +450,136 @@ func (r *LitRPC) DumpPrivs(args NoArgs, reply *DumpReply) error {
 
 	return nil
 }
+
+// ------------------------- HTLCs
+type AddHTLCArgs struct {
+	ChanIdx  uint32
+	Amt      int64
+	LockTime uint32
+	RHash    [32]byte
+	Data     [32]byte
+}
+type AddHTLCReply struct {
+	StateIndex uint64
+	HTLCIndex  uint32
+}
+
+func (r *LitRPC) AddHTLC(args AddHTLCArgs, reply *AddHTLCReply) error {
+	if args.Amt > consts.MaxChanCapacity || args.Amt < consts.MinOutput {
+		return fmt.Errorf(
+			"can't add HTLC %d max is 1 coin (100000000), min is %d", args.Amt, consts.MinOutput)
+	}
+
+	log.Printf("add HTLC %d to chan %d with data %x and RHash %x\n", args.Amt, args.ChanIdx, args.Data, args.RHash)
+
+	// load the whole channel from disk just to see who the peer is
+	// (pretty inefficient)
+	dummyqc, err := r.Node.GetQchanByIdx(args.ChanIdx)
+	if err != nil {
+		return err
+	}
+	// see if channel is closed and error early
+	if dummyqc.CloseData.Closed {
+		return fmt.Errorf("Can't push; channel %d closed", args.ChanIdx)
+	}
+
+	// but we want to reference the qc that's already in ram
+	// first see if we're connected to that peer
+
+	// map read, need mutex...?
+	r.Node.RemoteMtx.Lock()
+	peer, ok := r.Node.RemoteCons[dummyqc.Peer()]
+	r.Node.RemoteMtx.Unlock()
+	if !ok {
+		return fmt.Errorf("not connected to peer %d for channel %d",
+			dummyqc.Peer(), dummyqc.Idx())
+	}
+	qc, ok := peer.QCs[dummyqc.Idx()]
+	if !ok {
+		return fmt.Errorf("peer %d doesn't have channel %d",
+			dummyqc.Peer(), dummyqc.Idx())
+	}
+
+	log.Printf("channel %s\n", qc.Op.String())
+
+	if qc.CloseData.Closed {
+		return fmt.Errorf("Channel %d already closed by tx %s",
+			args.ChanIdx, qc.CloseData.CloseTxid.String())
+	}
+
+	// TODO this is a bad place to put it -- litRPC should be a thin layer
+	// to the Node.Func() calls.  For now though, set the height here...
+	qc.Height = dummyqc.Height
+	curHeight := uint32(r.Node.SubWallet[qc.Coin()].CurrentHeight())
+	curHeight += args.LockTime
+
+	err = r.Node.OfferHTLC(qc, uint32(args.Amt), args.RHash, curHeight, args.Data)
+	if err != nil {
+		return err
+	}
+
+	reply.StateIndex = qc.State.StateIdx
+	reply.HTLCIndex = qc.State.HTLCIdx - 1
+	return nil
+}
+
+type ClearHTLCArgs struct {
+	ChanIdx uint32
+	HTLCIdx uint32
+	R       [16]byte
+	Data    [32]byte
+}
+type ClearHTLCReply struct {
+	StateIndex uint64
+}
+
+func (r *LitRPC) ClearHTLC(args ClearHTLCArgs, reply *ClearHTLCReply) error {
+	log.Printf("clear HTLC %d from chan %d with data %x and preimage %x\n", args.HTLCIdx, args.ChanIdx, args.Data, args.R)
+
+	// load the whole channel from disk just to see who the peer is
+	// (pretty inefficient)
+	dummyqc, err := r.Node.GetQchanByIdx(args.ChanIdx)
+	if err != nil {
+		return err
+	}
+	// see if channel is closed and error early
+	if dummyqc.CloseData.Closed {
+		return fmt.Errorf("Can't clear; channel %d closed", args.ChanIdx)
+	}
+
+	// but we want to reference the qc that's already in ram
+	// first see if we're connected to that peer
+
+	// map read, need mutex...?
+	r.Node.RemoteMtx.Lock()
+	peer, ok := r.Node.RemoteCons[dummyqc.Peer()]
+	r.Node.RemoteMtx.Unlock()
+	if !ok {
+		return fmt.Errorf("not connected to peer %d for channel %d",
+			dummyqc.Peer(), dummyqc.Idx())
+	}
+	qc, ok := peer.QCs[dummyqc.Idx()]
+	if !ok {
+		return fmt.Errorf("peer %d doesn't have channel %d",
+			dummyqc.Peer(), dummyqc.Idx())
+	}
+
+	log.Printf("channel %s\n", qc.Op.String())
+
+	if qc.CloseData.Closed {
+		return fmt.Errorf("Channel %d already closed by tx %s",
+			args.ChanIdx, qc.CloseData.CloseTxid.String())
+	}
+
+	// TODO this is a bad place to put it -- litRPC should be a thin layer
+	// to the Node.Func() calls.  For now though, set the height here...
+	qc.Height = dummyqc.Height
+
+	err = r.Node.ClearHTLC(qc, args.R, args.HTLCIdx, args.Data)
+	if err != nil {
+		return err
+	}
+
+	reply.StateIndex = qc.State.StateIdx
+	return nil
+}

litrpc/walletcmds.go

@@ -3,11 +3,12 @@ package litrpc
 import (
 	"fmt"
 	"log"
+
 	"github.com/mit-dci/lit/bech32"
-	"github.com/mit-dci/lit/wire"
 	"github.com/mit-dci/lit/consts"
 	"github.com/mit-dci/lit/lnutil"
 	"github.com/mit-dci/lit/portxo"
+	"github.com/mit-dci/lit/wire"
 )
 
 type TxidsReply struct {
@@ -413,3 +414,21 @@ func (r *LitRPC) Address(args *AddressArgs, reply *AddressReply) error {
 //	}
 //	return base58.CheckEncode(pkHash, netID), nil
 //}
+
+type ClaimHTLCArgs struct {
+	R [16]byte
+}
+
+func (r *LitRPC) ClaimHTLC(args *ClaimHTLCArgs, reply *TxidsReply) error {
+	txids, err := r.Node.ClaimHTLC(args.R)
+	if err != nil {
+		return err
+	}
+
+	reply.Txids = make([]string, 0)
+	for _, txid := range txids {
+		reply.Txids = append(reply.Txids, fmt.Sprintf("%x", txid))
+	}
+
+	return nil
+}