multi: move Input interface and related code

This commit is a step to split the lnwallet package. It puts the Input interface and implementations in a separate package along with all their dependencies from lnwallet.
2025-12-18 06:34:27 +01:00 · 2019-01-16 15:47:43 +01:00
parent 667474db75
commit 9e012ecc93
66 changed files with 811 additions and 689 deletions
--- a/lnwallet/channel.go
+++ b/lnwallet/channel.go
@@ -9,17 +9,18 @@ import (
 	"sync"

 	"github.com/btcsuite/btcd/blockchain"
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/davecgh/go-spew/spew"
-	"github.com/lightningnetwork/lnd/chainntnfs"
-	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/lnwire"
-
 	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
 	"github.com/btcsuite/btcutil/txsort"
+	"github.com/davecgh/go-spew/spew"
+
+	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/lnwire"
 )

 var zeroHash chainhash.Hash
@@ -967,16 +968,16 @@ func deriveCommitmentKeys(commitPoint *btcec.PublicKey, isOurCommit bool,
 	keyRing := &CommitmentKeyRing{
 		CommitPoint: commitPoint,

-		LocalCommitKeyTweak: SingleTweakBytes(
+		LocalCommitKeyTweak: input.SingleTweakBytes(
 			commitPoint, localChanCfg.PaymentBasePoint.PubKey,
 		),
-		LocalHtlcKeyTweak: SingleTweakBytes(
+		LocalHtlcKeyTweak: input.SingleTweakBytes(
 			commitPoint, localChanCfg.HtlcBasePoint.PubKey,
 		),
-		LocalHtlcKey: TweakPubKey(
+		LocalHtlcKey: input.TweakPubKey(
 			localChanCfg.HtlcBasePoint.PubKey, commitPoint,
 		),
-		RemoteHtlcKey: TweakPubKey(
+		RemoteHtlcKey: input.TweakPubKey(
 			remoteChanCfg.HtlcBasePoint.PubKey, commitPoint,
 		),
 	}
@@ -1003,9 +1004,9 @@ func deriveCommitmentKeys(commitPoint *btcec.PublicKey, isOurCommit bool,

 	// With the base points assigned, we can now derive the actual keys
 	// using the base point, and the current commitment tweak.
-	keyRing.DelayKey = TweakPubKey(delayBasePoint, commitPoint)
-	keyRing.NoDelayKey = TweakPubKey(noDelayBasePoint, commitPoint)
-	keyRing.RevocationKey = DeriveRevocationPubkey(
+	keyRing.DelayKey = input.TweakPubKey(delayBasePoint, commitPoint)
+	keyRing.NoDelayKey = input.TweakPubKey(noDelayBasePoint, commitPoint)
+	keyRing.RevocationKey = input.DeriveRevocationPubkey(
 		revocationBasePoint, commitPoint,
 	)

@@ -1285,11 +1286,11 @@ type LightningChannel struct {
 	// Signer is the main signer instances that will be responsible for
 	// signing any HTLC and commitment transaction generated by the state
 	// machine.
-	Signer Signer
+	Signer input.Signer

 	// signDesc is the primary sign descriptor that is capable of signing
 	// the commitment transaction that spends the multi-sig output.
-	signDesc *SignDescriptor
+	signDesc *input.SignDescriptor

 	channelEvents chainntnfs.ChainNotifier

@@ -1363,7 +1364,7 @@ type LightningChannel struct {
 // settled channel state. Throughout state transitions, then channel will
 // automatically persist pertinent state to the database in an efficient
 // manner.
-func NewLightningChannel(signer Signer, pCache PreimageCache,
+func NewLightningChannel(signer input.Signer, pCache PreimageCache,
 	state *channeldb.OpenChannel,
 	sigPool *SigPool) (*LightningChannel, error) {

@@ -1423,16 +1424,16 @@ func (lc *LightningChannel) createSignDesc() error {
 	localKey := lc.localChanCfg.MultiSigKey.PubKey.SerializeCompressed()
 	remoteKey := lc.remoteChanCfg.MultiSigKey.PubKey.SerializeCompressed()

-	multiSigScript, err := GenMultiSigScript(localKey, remoteKey)
+	multiSigScript, err := input.GenMultiSigScript(localKey, remoteKey)
 	if err != nil {
 		return err
 	}

-	fundingPkScript, err := WitnessScriptHash(multiSigScript)
+	fundingPkScript, err := input.WitnessScriptHash(multiSigScript)
 	if err != nil {
 		return err
 	}
-	lc.signDesc = &SignDescriptor{
+	lc.signDesc = &input.SignDescriptor{
 		KeyDesc:       lc.localChanCfg.MultiSigKey,
 		WitnessScript: multiSigScript,
 		Output: &wire.TxOut{
@@ -1616,7 +1617,7 @@ func (lc *LightningChannel) restoreCommitState(
 	if err != nil {
 		return err
 	}
-	localCommitPoint := ComputeCommitmentPoint(ourRevPreImage[:])
+	localCommitPoint := input.ComputeCommitmentPoint(ourRevPreImage[:])
 	remoteCommitPoint := lc.channelState.RemoteCurrentRevocation

 	// With the revocation state reconstructed, we can now convert the disk
@@ -1839,7 +1840,7 @@ type HtlcRetribution struct {
 	// SignDesc is a design descriptor capable of generating the necessary
 	// signatures to satisfy the revocation clause of the HTLC's public key
 	// script.
-	SignDesc SignDescriptor
+	SignDesc input.SignDescriptor

 	// OutPoint is the target outpoint of this HTLC pointing to the
 	// breached commitment transaction.
@@ -1895,7 +1896,7 @@ type BreachRetribution struct {
 	//
 	// NOTE: A nil value indicates that the local output is considered dust
 	// according to the remote party's dust limit.
-	LocalOutputSignDesc *SignDescriptor
+	LocalOutputSignDesc *input.SignDescriptor

 	// LocalOutpoint is the outpoint of the output paying to us (the local
 	// party) within the breach transaction.
@@ -1908,7 +1909,7 @@ type BreachRetribution struct {
 	//
 	// NOTE: A nil value indicates that the local output is considered dust
 	// according to the remote party's dust limit.
-	RemoteOutputSignDesc *SignDescriptor
+	RemoteOutputSignDesc *input.SignDescriptor

 	// RemoteOutpoint is the outpoint of the output paying to the remote
 	// party within the breach transaction.
@@ -1963,17 +1964,17 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	// number so we can have the proper witness script to sign and include
 	// within the final witness.
 	remoteDelay := uint32(chanState.RemoteChanCfg.CsvDelay)
-	remotePkScript, err := CommitScriptToSelf(
+	remotePkScript, err := input.CommitScriptToSelf(
 		remoteDelay, keyRing.DelayKey, keyRing.RevocationKey,
 	)
 	if err != nil {
 		return nil, err
 	}
-	remoteWitnessHash, err := WitnessScriptHash(remotePkScript)
+	remoteWitnessHash, err := input.WitnessScriptHash(remotePkScript)
 	if err != nil {
 		return nil, err
 	}
-	localPkScript, err := CommitScriptUnencumbered(keyRing.NoDelayKey)
+	localPkScript, err := input.CommitScriptUnencumbered(keyRing.NoDelayKey)
 	if err != nil {
 		return nil, err
 	}
@@ -1999,8 +2000,8 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	// commitment outputs. If either is considered dust using the remote
 	// party's dust limit, the respective sign descriptor will be nil.
 	var (
-		localSignDesc  *SignDescriptor
-		remoteSignDesc *SignDescriptor
+		localSignDesc  *input.SignDescriptor
+		remoteSignDesc *input.SignDescriptor
 	)

 	// Compute the local and remote balances in satoshis.
@@ -2010,7 +2011,7 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	// If the local balance exceeds the remote party's dust limit,
 	// instantiate the local sign descriptor.
 	if localAmt >= chanState.RemoteChanCfg.DustLimit {
-		localSignDesc = &SignDescriptor{
+		localSignDesc = &input.SignDescriptor{
 			SingleTweak:   keyRing.LocalCommitKeyTweak,
 			KeyDesc:       chanState.LocalChanCfg.PaymentBasePoint,
 			WitnessScript: localPkScript,
@@ -2025,7 +2026,7 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	// Similarly, if the remote balance exceeds the remote party's dust
 	// limit, assemble the remote sign descriptor.
 	if remoteAmt >= chanState.RemoteChanCfg.DustLimit {
-		remoteSignDesc = &SignDescriptor{
+		remoteSignDesc = &input.SignDescriptor{
 			KeyDesc:       chanState.LocalChanCfg.RevocationBasePoint,
 			DoubleTweak:   commitmentSecret,
 			WitnessScript: remotePkScript,
@@ -2061,7 +2062,7 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 		// as we'll need it if we're revoking an HTLC output on the
 		// remote commitment transaction, and *they* go to the second
 		// level.
-		secondLevelWitnessScript, err := secondLevelHtlcScript(
+		secondLevelWitnessScript, err := input.SecondLevelHtlcScript(
 			keyRing.RevocationKey, keyRing.DelayKey, remoteDelay,
 		)
 		if err != nil {
@@ -2072,7 +2073,7 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 		// the sender of the HTLC (relative to us). So we'll
 		// re-generate the sender HTLC script.
 		if htlc.Incoming {
-			htlcWitnessScript, err = senderHTLCScript(
+			htlcWitnessScript, err = input.SenderHTLCScript(
 				keyRing.RemoteHtlcKey, keyRing.LocalHtlcKey,
 				keyRing.RevocationKey, htlc.RHash[:],
 			)
@@ -2084,7 +2085,7 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 			// Otherwise, is this was an outgoing HTLC that we
 			// sent, then from the PoV of the remote commitment
 			// state, they're the receiver of this HTLC.
-			htlcWitnessScript, err = receiverHTLCScript(
+			htlcWitnessScript, err = input.ReceiverHTLCScript(
 				htlc.RefundTimeout, keyRing.LocalHtlcKey,
 				keyRing.RemoteHtlcKey, keyRing.RevocationKey,
 				htlc.RHash[:],
@@ -2094,13 +2095,13 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 			}
 		}

-		htlcPkScript, err := WitnessScriptHash(htlcWitnessScript)
+		htlcPkScript, err := input.WitnessScriptHash(htlcWitnessScript)
 		if err != nil {
 			return nil, err
 		}

 		htlcRetributions = append(htlcRetributions, HtlcRetribution{
-			SignDesc: SignDescriptor{
+			SignDesc: input.SignDescriptor{
 				KeyDesc:       chanState.LocalChanCfg.RevocationBasePoint,
 				DoubleTweak:   commitmentSecret,
 				WitnessScript: htlcWitnessScript,
@@ -2141,13 +2142,13 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 // htlcTimeoutFee returns the fee in satoshis required for an HTLC timeout
 // transaction based on the current fee rate.
 func htlcTimeoutFee(feePerKw SatPerKWeight) btcutil.Amount {
-	return feePerKw.FeeForWeight(HtlcTimeoutWeight)
+	return feePerKw.FeeForWeight(input.HtlcTimeoutWeight)
 }

 // htlcSuccessFee returns the fee in satoshis required for an HTLC success
 // transaction based on the current fee rate.
 func htlcSuccessFee(feePerKw SatPerKWeight) btcutil.Amount {
-	return feePerKw.FeeForWeight(HtlcSuccessWeight)
+	return feePerKw.FeeForWeight(input.HtlcSuccessWeight)
 }

 // htlcIsDust determines if an HTLC output is dust or not depending on two
@@ -2344,7 +2345,7 @@ func (lc *LightningChannel) createCommitmentTx(c *commitment,
 	// on its total weight. Once we have the total weight, we'll multiply
 	// by the current fee-per-kw, then divide by 1000 to get the proper
 	// fee.
-	totalCommitWeight := CommitWeight + (HtlcWeight * numHTLCs)
+	totalCommitWeight := input.CommitWeight + (input.HtlcWeight * numHTLCs)

 	// With the weight known, we can now calculate the commitment fee,
 	// ensuring that we account for any dust outputs trimmed above.
@@ -2793,7 +2794,7 @@ func genRemoteHtlcSigJobs(keyRing *CommitmentKeyRing,
 		// Finally, we'll generate a sign descriptor to generate a
 		// signature to give to the remote party for this commitment
 		// transaction. Note we use the raw HTLC amount.
-		sigJob.SignDesc = SignDescriptor{
+		sigJob.SignDesc = input.SignDescriptor{
 			KeyDesc:       localChanCfg.HtlcBasePoint,
 			SingleTweak:   keyRing.LocalHtlcKeyTweak,
 			WitnessScript: htlc.theirWitnessScript,
@@ -2844,7 +2845,7 @@ func genRemoteHtlcSigJobs(keyRing *CommitmentKeyRing,
 		// Finally, we'll generate a sign descriptor to generate a
 		// signature to give to the remote party for this commitment
 		// transaction. Note we use the raw HTLC amount.
-		sigJob.SignDesc = SignDescriptor{
+		sigJob.SignDesc = input.SignDescriptor{
 			KeyDesc:       localChanCfg.HtlcBasePoint,
 			SingleTweak:   keyRing.LocalHtlcKeyTweak,
 			WitnessScript: htlc.theirWitnessScript,
@@ -3539,7 +3540,7 @@ func ChanSyncMsg(c *channeldb.OpenChannel) (*lnwire.ChannelReestablish, error) {
 		NextLocalCommitHeight:  nextLocalCommitHeight,
 		RemoteCommitTailHeight: remoteChainTipHeight,
 		LastRemoteCommitSecret: lastCommitSecret,
-		LocalUnrevokedCommitPoint: ComputeCommitmentPoint(
+		LocalUnrevokedCommitPoint: input.ComputeCommitmentPoint(
 			currentCommitSecret[:],
 		),
 	}, nil
@@ -3607,7 +3608,7 @@ func (lc *LightningChannel) computeView(view *htlcView, remoteChain bool,
 			continue
 		}

-		totalHtlcWeight += HtlcWeight
+		totalHtlcWeight += input.HtlcWeight
 	}
 	for _, htlc := range filteredHTLCView.theirUpdates {
 		if htlcIsDust(!remoteChain, !remoteChain, feePerKw,
@@ -3615,10 +3616,10 @@ func (lc *LightningChannel) computeView(view *htlcView, remoteChain bool,
 			continue
 		}

-		totalHtlcWeight += HtlcWeight
+		totalHtlcWeight += input.HtlcWeight
 	}

-	totalCommitWeight := CommitWeight + totalHtlcWeight
+	totalCommitWeight := input.CommitWeight + totalHtlcWeight
 	return ourBalance, theirBalance, totalCommitWeight, filteredHTLCView
 }

@@ -4011,7 +4012,7 @@ func (lc *LightningChannel) ReceiveNewCommitment(commitSig lnwire.Sig,
 	if err != nil {
 		return err
 	}
-	commitPoint := ComputeCommitmentPoint(commitSecret[:])
+	commitPoint := input.ComputeCommitmentPoint(commitSecret[:])
 	keyRing := deriveCommitmentKeys(commitPoint, true, lc.localChanCfg,
 		lc.remoteChanCfg)

@@ -4238,7 +4239,7 @@ func (lc *LightningChannel) ReceiveRevocation(revMsg *lnwire.RevokeAndAck) (
 	// revealed secret to derive a revocation key with our revocation base
 	// point, then it matches the current revocation of the remote party.
 	currentCommitPoint := lc.channelState.RemoteCurrentRevocation
-	derivedCommitPoint := ComputeCommitmentPoint(revMsg.Revocation[:])
+	derivedCommitPoint := input.ComputeCommitmentPoint(revMsg.Revocation[:])
 	if !derivedCommitPoint.IsEqual(currentCommitPoint) {
 		return nil, nil, nil, fmt.Errorf("revocation key mismatch")
 	}
@@ -4476,7 +4477,7 @@ func (lc *LightningChannel) NextRevocationKey() (*btcec.PublicKey, error) {
 		return nil, err
 	}

-	return ComputeCommitmentPoint(revocation[:]), nil
+	return input.ComputeCommitmentPoint(revocation[:]), nil
 }

 // InitNextRevocation inserts the passed commitment point as the _next_
@@ -4852,7 +4853,7 @@ func genHtlcScript(isIncoming, ourCommit bool, timeout uint32, rHash [32]byte,
 	// transaction. So we need to use the receiver's version of HTLC the
 	// script.
 	case isIncoming && ourCommit:
-		witnessScript, err = receiverHTLCScript(timeout,
+		witnessScript, err = input.ReceiverHTLCScript(timeout,
 			keyRing.RemoteHtlcKey, keyRing.LocalHtlcKey,
 			keyRing.RevocationKey, rHash[:])

@@ -4860,21 +4861,21 @@ func genHtlcScript(isIncoming, ourCommit bool, timeout uint32, rHash [32]byte,
 	// being added to their commitment transaction, so we use the sender's
 	// version of the HTLC script.
 	case isIncoming && !ourCommit:
-		witnessScript, err = senderHTLCScript(keyRing.RemoteHtlcKey,
+		witnessScript, err = input.SenderHTLCScript(keyRing.RemoteHtlcKey,
 			keyRing.LocalHtlcKey, keyRing.RevocationKey, rHash[:])

 	// We're sending an HTLC which is being added to our commitment
 	// transaction. Therefore, we need to use the sender's version of the
 	// HTLC script.
 	case !isIncoming && ourCommit:
-		witnessScript, err = senderHTLCScript(keyRing.LocalHtlcKey,
+		witnessScript, err = input.SenderHTLCScript(keyRing.LocalHtlcKey,
 			keyRing.RemoteHtlcKey, keyRing.RevocationKey, rHash[:])

 	// Finally, we're paying the remote party via an HTLC, which is being
 	// added to their commitment transaction. Therefore, we use the
 	// receiver's version of the HTLC script.
 	case !isIncoming && !ourCommit:
-		witnessScript, err = receiverHTLCScript(timeout, keyRing.LocalHtlcKey,
+		witnessScript, err = input.ReceiverHTLCScript(timeout, keyRing.LocalHtlcKey,
 			keyRing.RemoteHtlcKey, keyRing.RevocationKey, rHash[:])
 	}
 	if err != nil {
@@ -4883,7 +4884,7 @@ func genHtlcScript(isIncoming, ourCommit bool, timeout uint32, rHash [32]byte,

 	// Now that we have the redeem scripts, create the P2WSH public key
 	// script for the output itself.
-	htlcP2WSH, err := WitnessScriptHash(witnessScript)
+	htlcP2WSH, err := input.WitnessScriptHash(witnessScript)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -4952,7 +4953,7 @@ func (lc *LightningChannel) getSignedCommitTx() (*wire.MsgTx, error) {
 	ourKey := lc.localChanCfg.MultiSigKey.PubKey.SerializeCompressed()
 	theirKey := lc.remoteChanCfg.MultiSigKey.PubKey.SerializeCompressed()

-	commitTx.TxIn[0].Witness = SpendMultiSig(
+	commitTx.TxIn[0].Witness = input.SpendMultiSig(
 		lc.signDesc.WitnessScript, ourKey,
 		ourSig, theirKey, theirSig,
 	)
@@ -4970,7 +4971,7 @@ type CommitOutputResolution struct {

 	// SelfOutputSignDesc is a fully populated sign descriptor capable of
 	// generating a valid signature to sweep the output paying to us.
-	SelfOutputSignDesc SignDescriptor
+	SelfOutputSignDesc input.SignDescriptor

 	// MaturityDelay is the relative time-lock, in blocks for all outputs
 	// that pay to the local party within the broadcast commitment
@@ -5026,7 +5027,7 @@ type UnilateralCloseSummary struct {
 // happen in case we have lost state) it should be set to an empty struct, in
 // which case we will attempt to sweep the non-HTLC output using the passed
 // commitPoint.
-func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
+func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer input.Signer,
 	pCache PreimageCache, commitSpend *chainntnfs.SpendDetail,
 	remoteCommit channeldb.ChannelCommitment,
 	commitPoint *btcec.PublicKey) (*UnilateralCloseSummary, error) {
@@ -5054,7 +5055,7 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
 	// Before we can generate the proper sign descriptor, we'll need to
 	// locate the output index of our non-delayed output on the commitment
 	// transaction.
-	selfP2WKH, err := CommitScriptUnencumbered(keyRing.NoDelayKey)
+	selfP2WKH, err := input.CommitScriptUnencumbered(keyRing.NoDelayKey)
 	if err != nil {
 		return nil, fmt.Errorf("unable to create self commit script: %v", err)
 	}
@@ -5083,7 +5084,7 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
 		localPayBase := chanState.LocalChanCfg.PaymentBasePoint
 		commitResolution = &CommitOutputResolution{
 			SelfOutPoint: *selfPoint,
-			SelfOutputSignDesc: SignDescriptor{
+			SelfOutputSignDesc: input.SignDescriptor{
 				KeyDesc:       localPayBase,
 				SingleTweak:   keyRing.LocalCommitKeyTweak,
 				WitnessScript: selfP2WKH,
@@ -5170,7 +5171,7 @@ type IncomingHtlcResolution struct {
 	// SweepSignDesc is a sign descriptor that has been populated with the
 	// necessary items required to spend the sole output of the above
 	// transaction.
-	SweepSignDesc SignDescriptor
+	SweepSignDesc input.SignDescriptor
 }

 // OutgoingHtlcResolution houses the information necessary to sweep any
@@ -5210,7 +5211,7 @@ type OutgoingHtlcResolution struct {
 	// SweepSignDesc is a sign descriptor that has been populated with the
 	// necessary items required to spend the sole output of the above
 	// transaction.
-	SweepSignDesc SignDescriptor
+	SweepSignDesc input.SignDescriptor
 }

 // HtlcResolutions contains the items necessary to sweep HTLC's on chain
@@ -5230,7 +5231,7 @@ type HtlcResolutions struct {
 // newOutgoingHtlcResolution generates a new HTLC resolution capable of
 // allowing the caller to sweep an outgoing HTLC present on either their, or
 // the remote party's commitment transaction.
-func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelConfig,
+func newOutgoingHtlcResolution(signer input.Signer, localChanCfg *channeldb.ChannelConfig,
 	commitHash chainhash.Hash, htlc *channeldb.HTLC, keyRing *CommitmentKeyRing,
 	feePerKw SatPerKWeight, dustLimit btcutil.Amount, csvDelay uint32, localCommit bool,
 ) (*OutgoingHtlcResolution, error) {
@@ -5246,14 +5247,14 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 	if !localCommit {
 		// First, we'll re-generate the script used to send the HTLC to
 		// the remote party within their commitment transaction.
-		htlcReceiverScript, err := receiverHTLCScript(htlc.RefundTimeout,
+		htlcReceiverScript, err := input.ReceiverHTLCScript(htlc.RefundTimeout,
 			keyRing.LocalHtlcKey, keyRing.RemoteHtlcKey,
 			keyRing.RevocationKey, htlc.RHash[:],
 		)
 		if err != nil {
 			return nil, err
 		}
-		htlcScriptHash, err := WitnessScriptHash(htlcReceiverScript)
+		htlcScriptHash, err := input.WitnessScriptHash(htlcReceiverScript)
 		if err != nil {
 			return nil, err
 		}
@@ -5263,7 +5264,7 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 		return &OutgoingHtlcResolution{
 			Expiry:        htlc.RefundTimeout,
 			ClaimOutpoint: op,
-			SweepSignDesc: SignDescriptor{
+			SweepSignDesc: input.SignDescriptor{
 				KeyDesc:       localChanCfg.HtlcBasePoint,
 				SingleTweak:   keyRing.LocalHtlcKeyTweak,
 				WitnessScript: htlcReceiverScript,
@@ -5298,12 +5299,12 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 	// With the transaction created, we can generate a sign descriptor
 	// that's capable of generating the signature required to spend the
 	// HTLC output using the timeout transaction.
-	htlcCreationScript, err := senderHTLCScript(keyRing.LocalHtlcKey,
+	htlcCreationScript, err := input.SenderHTLCScript(keyRing.LocalHtlcKey,
 		keyRing.RemoteHtlcKey, keyRing.RevocationKey, htlc.RHash[:])
 	if err != nil {
 		return nil, err
 	}
-	timeoutSignDesc := SignDescriptor{
+	timeoutSignDesc := input.SignDescriptor{
 		KeyDesc:       localChanCfg.HtlcBasePoint,
 		SingleTweak:   keyRing.LocalHtlcKeyTweak,
 		WitnessScript: htlcCreationScript,
@@ -5317,7 +5318,7 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon

 	// With the sign desc created, we can now construct the full witness
 	// for the timeout transaction, and populate it as well.
-	timeoutWitness, err := senderHtlcSpendTimeout(
+	timeoutWitness, err := input.SenderHtlcSpendTimeout(
 		htlc.Signature, signer, &timeoutSignDesc, timeoutTx,
 	)
 	if err != nil {
@@ -5328,18 +5329,18 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 	// Finally, we'll generate the script output that the timeout
 	// transaction creates so we can generate the signDesc required to
 	// complete the claim process after a delay period.
-	htlcSweepScript, err := secondLevelHtlcScript(
+	htlcSweepScript, err := input.SecondLevelHtlcScript(
 		keyRing.RevocationKey, keyRing.DelayKey, csvDelay,
 	)
 	if err != nil {
 		return nil, err
 	}
-	htlcScriptHash, err := WitnessScriptHash(htlcSweepScript)
+	htlcScriptHash, err := input.WitnessScriptHash(htlcSweepScript)
 	if err != nil {
 		return nil, err
 	}

-	localDelayTweak := SingleTweakBytes(
+	localDelayTweak := input.SingleTweakBytes(
 		keyRing.CommitPoint, localChanCfg.DelayBasePoint.PubKey,
 	)
 	return &OutgoingHtlcResolution{
@@ -5350,7 +5351,7 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 			Hash:  timeoutTx.TxHash(),
 			Index: 0,
 		},
-		SweepSignDesc: SignDescriptor{
+		SweepSignDesc: input.SignDescriptor{
 			KeyDesc:       localChanCfg.DelayBasePoint,
 			SingleTweak:   localDelayTweak,
 			WitnessScript: htlcSweepScript,
@@ -5370,7 +5371,7 @@ func newOutgoingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 // they can just sweep the output immediately with knowledge of the pre-image.
 //
 // TODO(roasbeef) consolidate code with above func
-func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelConfig,
+func newIncomingHtlcResolution(signer input.Signer, localChanCfg *channeldb.ChannelConfig,
 	commitHash chainhash.Hash, htlc *channeldb.HTLC, keyRing *CommitmentKeyRing,
 	feePerKw SatPerKWeight, dustLimit btcutil.Amount, csvDelay uint32,
 	localCommit bool, preimage [32]byte) (*IncomingHtlcResolution, error) {
@@ -5385,14 +5386,14 @@ func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 	if !localCommit {
 		// First, we'll re-generate the script the remote party used to
 		// send the HTLC to us in their commitment transaction.
-		htlcSenderScript, err := senderHTLCScript(
+		htlcSenderScript, err := input.SenderHTLCScript(
 			keyRing.RemoteHtlcKey, keyRing.LocalHtlcKey,
 			keyRing.RevocationKey, htlc.RHash[:],
 		)
 		if err != nil {
 			return nil, err
 		}
-		htlcScriptHash, err := WitnessScriptHash(htlcSenderScript)
+		htlcScriptHash, err := input.WitnessScriptHash(htlcSenderScript)
 		if err != nil {
 			return nil, err
 		}
@@ -5403,7 +5404,7 @@ func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 			Preimage:      preimage,
 			ClaimOutpoint: op,
 			CsvDelay:      csvDelay,
-			SweepSignDesc: SignDescriptor{
+			SweepSignDesc: input.SignDescriptor{
 				KeyDesc:       localChanCfg.HtlcBasePoint,
 				SingleTweak:   keyRing.LocalHtlcKeyTweak,
 				WitnessScript: htlcSenderScript,
@@ -5432,14 +5433,14 @@ func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon

 	// Once we've created the second-level transaction, we'll generate the
 	// SignDesc needed spend the HTLC output using the success transaction.
-	htlcCreationScript, err := receiverHTLCScript(htlc.RefundTimeout,
+	htlcCreationScript, err := input.ReceiverHTLCScript(htlc.RefundTimeout,
 		keyRing.RemoteHtlcKey, keyRing.LocalHtlcKey,
 		keyRing.RevocationKey, htlc.RHash[:],
 	)
 	if err != nil {
 		return nil, err
 	}
-	successSignDesc := SignDescriptor{
+	successSignDesc := input.SignDescriptor{
 		KeyDesc:       localChanCfg.HtlcBasePoint,
 		SingleTweak:   keyRing.LocalHtlcKeyTweak,
 		WitnessScript: htlcCreationScript,
@@ -5453,7 +5454,7 @@ func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon

 	// Next, we'll construct the full witness needed to satisfy the input
 	// of the success transaction.
-	successWitness, err := receiverHtlcSpendRedeem(
+	successWitness, err := input.ReceiverHtlcSpendRedeem(
 		htlc.Signature, preimage[:], signer, &successSignDesc, successTx,
 	)
 	if err != nil {
@@ -5464,18 +5465,18 @@ func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 	// Finally, we'll generate the script that the second-level transaction
 	// creates so we can generate the proper signDesc to sweep it after the
 	// CSV delay has passed.
-	htlcSweepScript, err := secondLevelHtlcScript(
+	htlcSweepScript, err := input.SecondLevelHtlcScript(
 		keyRing.RevocationKey, keyRing.DelayKey, csvDelay,
 	)
 	if err != nil {
 		return nil, err
 	}
-	htlcScriptHash, err := WitnessScriptHash(htlcSweepScript)
+	htlcScriptHash, err := input.WitnessScriptHash(htlcSweepScript)
 	if err != nil {
 		return nil, err
 	}

-	localDelayTweak := SingleTweakBytes(
+	localDelayTweak := input.SingleTweakBytes(
 		keyRing.CommitPoint, localChanCfg.DelayBasePoint.PubKey,
 	)
 	return &IncomingHtlcResolution{
@@ -5486,7 +5487,7 @@ func newIncomingHtlcResolution(signer Signer, localChanCfg *channeldb.ChannelCon
 			Hash:  successTx.TxHash(),
 			Index: 0,
 		},
-		SweepSignDesc: SignDescriptor{
+		SweepSignDesc: input.SignDescriptor{
 			KeyDesc:       localChanCfg.DelayBasePoint,
 			SingleTweak:   localDelayTweak,
 			WitnessScript: htlcSweepScript,
@@ -5527,7 +5528,7 @@ func (r *OutgoingHtlcResolution) HtlcPoint() wire.OutPoint {
 // the local key used when generating the HTLC scrips. This function is to be
 // used in two cases: force close, or a unilateral close.
 func extractHtlcResolutions(feePerKw SatPerKWeight, ourCommit bool,
-	signer Signer, htlcs []channeldb.HTLC, keyRing *CommitmentKeyRing,
+	signer input.Signer, htlcs []channeldb.HTLC, keyRing *CommitmentKeyRing,
 	localChanCfg, remoteChanCfg *channeldb.ChannelConfig,
 	commitHash chainhash.Hash, pCache PreimageCache) (*HtlcResolutions, error) {

@@ -5672,7 +5673,7 @@ func (lc *LightningChannel) ForceClose() (*LocalForceCloseSummary, error) {
 // NewLocalForceCloseSummary generates a LocalForceCloseSummary from the given
 // channel state.  The passed commitTx must be a fully signed commitment
 // transaction corresponding to localCommit.
-func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
+func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel, signer input.Signer,
 	pCache PreimageCache, commitTx *wire.MsgTx,
 	localCommit channeldb.ChannelCommitment) (*LocalForceCloseSummary, error) {

@@ -5687,15 +5688,15 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
 	if err != nil {
 		return nil, err
 	}
-	commitPoint := ComputeCommitmentPoint(revocation[:])
+	commitPoint := input.ComputeCommitmentPoint(revocation[:])
 	keyRing := deriveCommitmentKeys(commitPoint, true, &chanState.LocalChanCfg,
 		&chanState.RemoteChanCfg)
-	selfScript, err := CommitScriptToSelf(csvTimeout, keyRing.DelayKey,
+	selfScript, err := input.CommitScriptToSelf(csvTimeout, keyRing.DelayKey,
 		keyRing.RevocationKey)
 	if err != nil {
 		return nil, err
 	}
-	payToUsScriptHash, err := WitnessScriptHash(selfScript)
+	payToUsScriptHash, err := input.WitnessScriptHash(selfScript)
 	if err != nil {
 		return nil, err
 	}
@@ -5725,7 +5726,7 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
 	// nil.
 	var commitResolution *CommitOutputResolution
 	if len(delayScript) != 0 {
-		singleTweak := SingleTweakBytes(
+		singleTweak := input.SingleTweakBytes(
 			commitPoint, chanState.LocalChanCfg.DelayBasePoint.PubKey,
 		)
 		localBalance := localCommit.LocalBalance
@@ -5734,7 +5735,7 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel, signer Signer,
 				Hash:  commitTx.TxHash(),
 				Index: delayIndex,
 			},
-			SelfOutputSignDesc: SignDescriptor{
+			SelfOutputSignDesc: input.SignDescriptor{
 				KeyDesc:       chanState.LocalChanCfg.DelayBasePoint,
 				SingleTweak:   singleTweak,
 				WitnessScript: selfScript,
@@ -5896,7 +5897,7 @@ func (lc *LightningChannel) CompleteCooperativeClose(localSig, remoteSig []byte,
 	// pubkeys+sigs on the stack.
 	ourKey := lc.localChanCfg.MultiSigKey.PubKey.SerializeCompressed()
 	theirKey := lc.remoteChanCfg.MultiSigKey.PubKey.SerializeCompressed()
-	witness := SpendMultiSig(lc.signDesc.WitnessScript, ourKey,
+	witness := input.SpendMultiSig(lc.signDesc.WitnessScript, ourKey,
 		localSig, theirKey, remoteSig)
 	closeTx.TxIn[0].Witness = witness

@@ -6101,7 +6102,7 @@ func (lc *LightningChannel) generateRevocation(height uint64) (*lnwire.RevokeAnd
 		return nil, err
 	}

-	revocationMsg.NextRevocationKey = ComputeCommitmentPoint(nextCommitSecret[:])
+	revocationMsg.NextRevocationKey = input.ComputeCommitmentPoint(nextCommitSecret[:])
 	revocationMsg.ChanID = lnwire.NewChanIDFromOutPoint(
 		&lc.channelState.FundingOutpoint)

@@ -6122,19 +6123,19 @@ func CreateCommitTx(fundingOutput wire.TxIn,
 	// output after a relative block delay, or the remote node can claim
 	// the funds with the revocation key if we broadcast a revoked
 	// commitment transaction.
-	ourRedeemScript, err := CommitScriptToSelf(csvTimeout, keyRing.DelayKey,
+	ourRedeemScript, err := input.CommitScriptToSelf(csvTimeout, keyRing.DelayKey,
 		keyRing.RevocationKey)
 	if err != nil {
 		return nil, err
 	}
-	payToUsScriptHash, err := WitnessScriptHash(ourRedeemScript)
+	payToUsScriptHash, err := input.WitnessScriptHash(ourRedeemScript)
 	if err != nil {
 		return nil, err
 	}

 	// Next, we create the script paying to them. This is just a regular
 	// P2WPKH output, without any added CSV delay.
-	theirWitnessKeyHash, err := CommitScriptUnencumbered(keyRing.NoDelayKey)
+	theirWitnessKeyHash, err := input.CommitScriptUnencumbered(keyRing.NoDelayKey)
 	if err != nil {
 		return nil, err
 	}
@@ -6203,7 +6204,7 @@ func CreateCooperativeCloseTx(fundingTxIn wire.TxIn,
 // CalcFee returns the commitment fee to use for the given
 // fee rate (fee-per-kw).
 func (lc *LightningChannel) CalcFee(feeRate SatPerKWeight) btcutil.Amount {
-	return feeRate.FeeForWeight(CommitWeight)
+	return feeRate.FeeForWeight(input.CommitWeight)
 }

 // RemoteNextRevocation returns the channelState's RemoteNextRevocation.