2015-12-20 09:00:50 +03:00
|
|
|
package lnwallet
|
2015-10-28 01:50:30 +03:00
|
|
|
|
|
|
|
import (
|
2017-07-30 05:20:08 +03:00
|
|
|
"bytes"
|
2017-03-16 04:56:25 +03:00
|
|
|
"crypto/sha256"
|
2018-08-10 05:16:14 +03:00
|
|
|
"errors"
|
2015-11-05 23:36:19 +03:00
|
|
|
"fmt"
|
2018-10-28 17:55:18 +03:00
|
|
|
"math"
|
2016-10-27 00:56:48 +03:00
|
|
|
"net"
|
2015-10-28 01:50:30 +03:00
|
|
|
"sync"
|
|
|
|
"sync/atomic"
|
|
|
|
|
2018-07-18 05:20:05 +03:00
|
|
|
"github.com/btcsuite/btcd/blockchain"
|
2018-08-10 05:16:14 +03:00
|
|
|
"github.com/btcsuite/btcd/btcec"
|
2018-07-18 05:20:05 +03:00
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
2018-08-10 05:16:14 +03:00
|
|
|
"github.com/btcsuite/btcd/txscript"
|
|
|
|
"github.com/btcsuite/btcd/wire"
|
|
|
|
"github.com/btcsuite/btcutil"
|
|
|
|
"github.com/btcsuite/btcutil/txsort"
|
2016-06-21 20:37:55 +03:00
|
|
|
"github.com/davecgh/go-spew/spew"
|
2016-01-16 21:45:54 +03:00
|
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
2019-01-16 17:47:43 +03:00
|
|
|
"github.com/lightningnetwork/lnd/input"
|
2018-02-18 02:20:41 +03:00
|
|
|
"github.com/lightningnetwork/lnd/keychain"
|
2019-10-31 05:43:05 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
|
2019-10-01 05:59:10 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnwallet/chanvalidate"
|
2017-08-22 08:49:56 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
2018-07-18 05:20:05 +03:00
|
|
|
"github.com/lightningnetwork/lnd/shachain"
|
2015-10-28 01:50:30 +03:00
|
|
|
)
|
|
|
|
|
2015-11-13 06:34:35 +03:00
|
|
|
const (
|
2016-05-04 05:49:58 +03:00
|
|
|
// The size of the buffered queue of requests to the wallet from the
|
2015-12-28 23:14:00 +03:00
|
|
|
// outside word.
|
2015-11-13 06:34:35 +03:00
|
|
|
msgBufferSize = 100
|
2015-11-05 23:36:19 +03:00
|
|
|
)
|
|
|
|
|
2016-09-26 22:16:12 +03:00
|
|
|
// ErrInsufficientFunds is a type matching the error interface which is
|
|
|
|
// returned when coin selection for a new funding transaction fails to due
|
|
|
|
// having an insufficient amount of confirmed funds.
|
|
|
|
type ErrInsufficientFunds struct {
|
|
|
|
amountAvailable btcutil.Amount
|
|
|
|
amountSelected btcutil.Amount
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *ErrInsufficientFunds) Error() string {
|
2017-09-30 01:38:26 +03:00
|
|
|
return fmt.Sprintf("not enough witness outputs to create funding transaction,"+
|
2016-09-26 22:16:12 +03:00
|
|
|
" need %v only have %v available", e.amountAvailable,
|
|
|
|
e.amountSelected)
|
|
|
|
}
|
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// InitFundingReserveMsg is the first message sent to initiate the workflow
|
2015-12-28 23:14:00 +03:00
|
|
|
// required to open a payment channel with a remote peer. The initial required
|
2016-10-15 16:18:38 +03:00
|
|
|
// parameters are configurable across channels. These parameters are to be
|
2017-07-30 05:20:08 +03:00
|
|
|
// chosen depending on the fee climate within the network, and time value of
|
|
|
|
// funds to be locked up within the channel. Upon success a ChannelReservation
|
|
|
|
// will be created in order to track the lifetime of this pending channel.
|
|
|
|
// Outputs selected will be 'locked', making them unavailable, for any other
|
|
|
|
// pending reservations. Therefore, all channels in reservation limbo will be
|
2018-03-10 18:21:10 +03:00
|
|
|
// periodically timed out after an idle period in order to avoid "exhaustion"
|
|
|
|
// attacks.
|
2018-08-10 05:15:18 +03:00
|
|
|
type InitFundingReserveMsg struct {
|
|
|
|
// ChainHash denotes that chain to be used to ultimately open the
|
2017-07-30 05:20:08 +03:00
|
|
|
// target channel.
|
2018-08-10 05:15:18 +03:00
|
|
|
ChainHash *chainhash.Hash
|
2017-07-30 05:20:08 +03:00
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// NodeID is the ID of the remote node we would like to open a channel
|
2017-05-17 05:00:19 +03:00
|
|
|
// with.
|
2018-08-10 05:15:18 +03:00
|
|
|
NodeID *btcec.PublicKey
|
2016-10-27 00:56:48 +03:00
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// NodeAddr is the address port that we used to either establish or
|
2018-02-03 09:24:43 +03:00
|
|
|
// accept the connection which led to the negotiation of this funding
|
|
|
|
// workflow.
|
2018-08-10 05:15:18 +03:00
|
|
|
NodeAddr net.Addr
|
2016-10-27 00:56:48 +03:00
|
|
|
|
2019-07-11 14:14:37 +03:00
|
|
|
// SubtractFees should be set if we intend to spend exactly
|
|
|
|
// LocalFundingAmt when opening the channel, subtracting the fees from
|
|
|
|
// the funding output. This can be used for instance to use all our
|
|
|
|
// remaining funds to open the channel, since it will take fees into
|
|
|
|
// account.
|
|
|
|
SubtractFees bool
|
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
// LocalFundingAmt is the amount of funds requested from us for this
|
|
|
|
// channel.
|
|
|
|
LocalFundingAmt btcutil.Amount
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
// RemoteFundingAmnt is the amount of funds the remote will contribute
|
|
|
|
// to this channel.
|
|
|
|
RemoteFundingAmt btcutil.Amount
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// CommitFeePerKw is the starting accepted satoshis/Kw fee for the set
|
2017-11-23 09:30:57 +03:00
|
|
|
// of initial commitment transactions. In order to ensure timely
|
|
|
|
// confirmation, it is recommended that this fee should be generous,
|
|
|
|
// paying some multiple of the accepted base fee rate of the network.
|
2019-10-31 05:43:05 +03:00
|
|
|
CommitFeePerKw chainfee.SatPerKWeight
|
2017-11-23 09:30:57 +03:00
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// FundingFeePerKw is the fee rate in sat/kw to use for the initial
|
2018-07-28 04:27:51 +03:00
|
|
|
// funding transaction.
|
2019-10-31 05:43:05 +03:00
|
|
|
FundingFeePerKw chainfee.SatPerKWeight
|
2015-12-28 23:14:00 +03:00
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// PushMSat is the number of milli-satoshis that should be pushed over
|
2017-08-22 08:49:56 +03:00
|
|
|
// the responder as part of the initial channel creation.
|
2018-08-10 05:15:18 +03:00
|
|
|
PushMSat lnwire.MilliSatoshi
|
2017-01-10 04:24:13 +03:00
|
|
|
|
2018-08-10 05:15:18 +03:00
|
|
|
// Flags are the channel flags specified by the initiator in the
|
2017-11-14 04:15:27 +03:00
|
|
|
// open_channel message.
|
2018-08-10 05:15:18 +03:00
|
|
|
Flags lnwire.FundingFlag
|
2017-11-14 04:15:27 +03:00
|
|
|
|
2018-08-10 05:24:12 +03:00
|
|
|
// MinConfs indicates the minimum number of confirmations that each
|
|
|
|
// output selected to fund the channel should satisfy.
|
|
|
|
MinConfs int32
|
|
|
|
|
2019-08-01 06:16:52 +03:00
|
|
|
// Tweakless indicates if the channel should use the new tweakless
|
|
|
|
// commitment format or not.
|
|
|
|
Tweakless bool
|
|
|
|
|
2017-05-17 05:00:19 +03:00
|
|
|
// err is a channel in which all errors will be sent across. Will be
|
|
|
|
// nil if this initial set is successful.
|
|
|
|
//
|
2015-12-28 23:14:00 +03:00
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2017-05-17 05:00:19 +03:00
|
|
|
// resp is channel in which a ChannelReservation with our contributions
|
|
|
|
// filled in will be sent across this channel in the case of a
|
|
|
|
// successfully reservation initiation. In the case of an error, this
|
|
|
|
// will read a nil pointer.
|
|
|
|
//
|
2015-12-28 23:14:00 +03:00
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
resp chan *ChannelReservation
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// fundingReserveCancelMsg is a message reserved for cancelling an existing
|
|
|
|
// channel reservation identified by its reservation ID. Cancelling a reservation
|
|
|
|
// frees its locked outputs up, for inclusion within further reservations.
|
2015-11-05 23:36:19 +03:00
|
|
|
type fundingReserveCancelMsg struct {
|
|
|
|
pendingFundingID uint64
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
2015-12-16 23:40:44 +03:00
|
|
|
err chan error // Buffered
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// addContributionMsg represents a message executing the second phase of the
|
|
|
|
// channel reservation workflow. This message carries the counterparty's
|
|
|
|
// "contribution" to the payment channel. In the case that this message is
|
|
|
|
// processed without generating any errors, then channel reservation will then
|
|
|
|
// be able to construct the funding tx, both commitment transactions, and
|
|
|
|
// finally generate signatures for all our inputs to the funding transaction,
|
|
|
|
// and for the remote node's version of the commitment transaction.
|
2015-12-22 00:53:34 +03:00
|
|
|
type addContributionMsg struct {
|
2015-11-05 23:36:19 +03:00
|
|
|
pendingFundingID uint64
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
// TODO(roasbeef): Should also carry SPV proofs in we're in SPV mode
|
2015-12-23 07:31:17 +03:00
|
|
|
contribution *ChannelContribution
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// addSingleContributionMsg represents a message executing the second phase of
|
|
|
|
// a single funder channel reservation workflow. This messages carries the
|
|
|
|
// counterparty's "contribution" to the payment channel. As this message is
|
|
|
|
// sent when on the responding side to a single funder workflow, no further
|
|
|
|
// action apart from storing the provided contribution is carried out.
|
|
|
|
type addSingleContributionMsg struct {
|
|
|
|
pendingFundingID uint64
|
|
|
|
|
|
|
|
contribution *ChannelContribution
|
|
|
|
|
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// addCounterPartySigsMsg represents the final message required to complete,
|
|
|
|
// and 'open' a payment channel. This message carries the counterparty's
|
|
|
|
// signatures for each of their inputs to the funding transaction, and also a
|
|
|
|
// signature allowing us to spend our version of the commitment transaction.
|
|
|
|
// If we're able to verify all the signatures are valid, the funding transaction
|
|
|
|
// will be broadcast to the network. After the funding transaction gains a
|
|
|
|
// configurable number of confirmations, the channel is officially considered
|
|
|
|
// 'open'.
|
2015-11-05 23:36:19 +03:00
|
|
|
type addCounterPartySigsMsg struct {
|
|
|
|
pendingFundingID uint64
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// Should be order of sorted inputs that are theirs. Sorting is done
|
|
|
|
// in accordance to BIP-69:
|
|
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki.
|
2019-01-16 17:47:43 +03:00
|
|
|
theirFundingInputScripts []*input.Script
|
2015-12-22 00:54:33 +03:00
|
|
|
|
2018-02-07 06:11:11 +03:00
|
|
|
// This should be 1/2 of the signatures needed to successfully spend our
|
2015-12-22 00:54:33 +03:00
|
|
|
// version of the commitment transaction.
|
|
|
|
theirCommitmentSig []byte
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2017-01-24 05:19:54 +03:00
|
|
|
// This channel is used to return the completed channel after the wallet
|
|
|
|
// has completed all of its stages in the funding process.
|
|
|
|
completeChan chan *channeldb.OpenChannel
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// addSingleFunderSigsMsg represents the next-to-last message required to
|
|
|
|
// complete a single-funder channel workflow. Once the initiator is able to
|
|
|
|
// construct the funding transaction, they send both the outpoint and a
|
|
|
|
// signature for our version of the commitment transaction. Once this message
|
|
|
|
// is processed we (the responder) are able to construct both commitment
|
|
|
|
// transactions, signing the remote party's version.
|
|
|
|
type addSingleFunderSigsMsg struct {
|
|
|
|
pendingFundingID uint64
|
|
|
|
|
2016-06-30 22:13:46 +03:00
|
|
|
// fundingOutpoint is the outpoint of the completed funding
|
2016-06-21 20:37:55 +03:00
|
|
|
// transaction as assembled by the workflow initiator.
|
|
|
|
fundingOutpoint *wire.OutPoint
|
|
|
|
|
2016-11-16 23:54:27 +03:00
|
|
|
// theirCommitmentSig are the 1/2 of the signatures needed to
|
2018-02-07 06:11:11 +03:00
|
|
|
// successfully spend our version of the commitment transaction.
|
2016-06-21 20:37:55 +03:00
|
|
|
theirCommitmentSig []byte
|
|
|
|
|
2017-01-24 05:19:54 +03:00
|
|
|
// This channel is used to return the completed channel after the wallet
|
|
|
|
// has completed all of its stages in the funding process.
|
|
|
|
completeChan chan *channeldb.OpenChannel
|
2016-06-21 20:37:55 +03:00
|
|
|
|
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// LightningWallet is a domain specific, yet general Bitcoin wallet capable of
|
|
|
|
// executing workflow required to interact with the Lightning Network. It is
|
|
|
|
// domain specific in the sense that it understands all the fancy scripts used
|
2017-11-28 02:24:45 +03:00
|
|
|
// within the Lightning Network, channel lifetimes, etc. However, it embeds a
|
2017-07-30 05:02:38 +03:00
|
|
|
// general purpose Bitcoin wallet within it. Therefore, it is also able to
|
|
|
|
// serve as a regular Bitcoin wallet which uses HD keys. The wallet is highly
|
|
|
|
// concurrent internally. All communication, and requests towards the wallet
|
|
|
|
// are dispatched as messages over channels, ensuring thread safety across all
|
2017-01-13 08:01:50 +03:00
|
|
|
// operations. Interaction has been designed independent of any peer-to-peer
|
2017-07-30 05:02:38 +03:00
|
|
|
// communication protocol, allowing the wallet to be self-contained and
|
|
|
|
// embeddable within future projects interacting with the Lightning Network.
|
|
|
|
//
|
2017-01-13 08:01:50 +03:00
|
|
|
// NOTE: At the moment the wallet requires a btcd full node, as it's dependent
|
2017-11-28 02:24:45 +03:00
|
|
|
// on btcd's websockets notifications as event triggers during the lifetime of a
|
2017-07-30 05:02:38 +03:00
|
|
|
// channel. However, once the chainntnfs package is complete, the wallet will
|
|
|
|
// be compatible with multiple RPC/notification services such as Electrum,
|
2015-12-28 23:14:00 +03:00
|
|
|
// Bitcoin Core + ZeroMQ, etc. Eventually, the wallet won't require a full-node
|
2017-07-30 05:02:38 +03:00
|
|
|
// at all, as SPV support is integrated into btcwallet.
|
2015-10-28 01:50:30 +03:00
|
|
|
type LightningWallet struct {
|
2018-06-01 01:41:41 +03:00
|
|
|
started int32 // To be used atomically.
|
|
|
|
shutdown int32 // To be used atomically.
|
|
|
|
|
|
|
|
nextFundingID uint64 // To be used atomically.
|
|
|
|
|
2017-07-30 05:02:38 +03:00
|
|
|
// Cfg is the configuration struct that will be used by the wallet to
|
|
|
|
// access the necessary interfaces and default it needs to carry on its
|
|
|
|
// duties.
|
|
|
|
Cfg Config
|
|
|
|
|
|
|
|
// WalletController is the core wallet, all non Lightning Network
|
|
|
|
// specific interaction is proxied to the internal wallet.
|
|
|
|
WalletController
|
|
|
|
|
2018-02-18 02:20:41 +03:00
|
|
|
// SecretKeyRing is the interface we'll use to derive any keys related
|
|
|
|
// to our purpose within the network including: multi-sig keys, node
|
|
|
|
// keys, revocation keys, etc.
|
|
|
|
keychain.SecretKeyRing
|
|
|
|
|
2015-12-28 23:12:18 +03:00
|
|
|
// This mutex MUST be held when performing coin selection in order to
|
|
|
|
// avoid inadvertently creating multiple funding transaction which
|
2016-10-15 16:18:38 +03:00
|
|
|
// double spend inputs across each other.
|
2015-12-28 23:12:18 +03:00
|
|
|
coinSelectMtx sync.RWMutex
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2016-10-15 16:18:38 +03:00
|
|
|
// All messages to the wallet are to be sent across this channel.
|
2015-10-28 01:50:30 +03:00
|
|
|
msgChan chan interface{}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// Incomplete payment channels are stored in the map below. An intent
|
|
|
|
// to create a payment channel is tracked as a "reservation" within
|
|
|
|
// limbo. Once the final signatures have been exchanged, a reservation
|
|
|
|
// is removed from limbo. Each reservation is tracked by a unique
|
|
|
|
// monotonically integer. All requests concerning the channel MUST
|
|
|
|
// carry a valid, active funding ID.
|
2018-07-18 05:20:05 +03:00
|
|
|
fundingLimbo map[uint64]*ChannelReservation
|
|
|
|
limboMtx sync.RWMutex
|
2015-11-19 01:38:57 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// lockedOutPoints is a set of the currently locked outpoint. This
|
|
|
|
// information is kept in order to provide an easy way to unlock all
|
|
|
|
// the currently locked outpoints.
|
|
|
|
lockedOutPoints map[wire.OutPoint]struct{}
|
|
|
|
|
2018-07-18 05:20:05 +03:00
|
|
|
quit chan struct{}
|
2015-10-28 01:50:30 +03:00
|
|
|
|
|
|
|
wg sync.WaitGroup
|
2015-11-19 01:38:57 +03:00
|
|
|
|
|
|
|
// TODO(roasbeef): handle wallet lock/unlock
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// NewLightningWallet creates/opens and initializes a LightningWallet instance.
|
|
|
|
// If the wallet has never been created (according to the passed dataDir), first-time
|
|
|
|
// setup is executed.
|
2017-07-30 05:02:38 +03:00
|
|
|
func NewLightningWallet(Cfg Config) (*LightningWallet, error) {
|
2016-08-04 08:31:20 +03:00
|
|
|
|
2015-11-13 06:34:35 +03:00
|
|
|
return &LightningWallet{
|
2017-07-30 05:02:38 +03:00
|
|
|
Cfg: Cfg,
|
2018-02-18 02:20:41 +03:00
|
|
|
SecretKeyRing: Cfg.SecretKeyRing,
|
2017-07-30 05:02:38 +03:00
|
|
|
WalletController: Cfg.WalletController,
|
2016-08-13 01:50:47 +03:00
|
|
|
msgChan: make(chan interface{}, msgBufferSize),
|
|
|
|
nextFundingID: 0,
|
|
|
|
fundingLimbo: make(map[uint64]*ChannelReservation),
|
|
|
|
lockedOutPoints: make(map[wire.OutPoint]struct{}),
|
|
|
|
quit: make(chan struct{}),
|
2016-03-23 04:48:18 +03:00
|
|
|
}, nil
|
2015-11-05 23:34:11 +03:00
|
|
|
}
|
|
|
|
|
2015-12-29 21:44:59 +03:00
|
|
|
// Startup establishes a connection to the RPC source, and spins up all
|
2015-12-28 23:14:00 +03:00
|
|
|
// goroutines required to handle incoming messages.
|
2015-12-29 21:44:59 +03:00
|
|
|
func (l *LightningWallet) Startup() error {
|
2015-10-28 01:50:30 +03:00
|
|
|
// Already started?
|
|
|
|
if atomic.AddInt32(&l.started, 1) != 1 {
|
|
|
|
return nil
|
|
|
|
}
|
2015-11-27 09:48:42 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// Start the underlying wallet controller.
|
|
|
|
if err := l.Start(); err != nil {
|
2015-11-27 09:48:42 +03:00
|
|
|
return err
|
|
|
|
}
|
2015-10-28 01:50:30 +03:00
|
|
|
|
|
|
|
l.wg.Add(1)
|
2015-11-27 09:50:17 +03:00
|
|
|
// TODO(roasbeef): multiple request handlers?
|
2015-10-28 01:50:30 +03:00
|
|
|
go l.requestHandler()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-12-29 21:44:59 +03:00
|
|
|
// Shutdown gracefully stops the wallet, and all active goroutines.
|
|
|
|
func (l *LightningWallet) Shutdown() error {
|
2015-10-28 01:50:30 +03:00
|
|
|
if atomic.AddInt32(&l.shutdown, 1) != 1 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-04-24 22:39:43 +03:00
|
|
|
// Signal the underlying wallet controller to shutdown, waiting until
|
|
|
|
// all active goroutines have been shutdown.
|
2016-08-13 01:50:47 +03:00
|
|
|
if err := l.Stop(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2015-11-28 03:07:22 +03:00
|
|
|
|
2015-10-28 01:50:30 +03:00
|
|
|
close(l.quit)
|
|
|
|
l.wg.Wait()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-23 22:56:47 +03:00
|
|
|
// LockedOutpoints returns a list of all currently locked outpoint.
|
2016-08-13 01:50:47 +03:00
|
|
|
func (l *LightningWallet) LockedOutpoints() []*wire.OutPoint {
|
|
|
|
outPoints := make([]*wire.OutPoint, 0, len(l.lockedOutPoints))
|
|
|
|
for outPoint := range l.lockedOutPoints {
|
|
|
|
outPoints = append(outPoints, &outPoint)
|
|
|
|
}
|
|
|
|
|
|
|
|
return outPoints
|
|
|
|
}
|
|
|
|
|
2017-12-18 05:40:05 +03:00
|
|
|
// ResetReservations reset the volatile wallet state which tracks all currently
|
2016-08-13 01:50:47 +03:00
|
|
|
// active reservations.
|
|
|
|
func (l *LightningWallet) ResetReservations() {
|
|
|
|
l.nextFundingID = 0
|
|
|
|
l.fundingLimbo = make(map[uint64]*ChannelReservation)
|
|
|
|
|
|
|
|
for outpoint := range l.lockedOutPoints {
|
|
|
|
l.UnlockOutpoint(outpoint)
|
|
|
|
}
|
|
|
|
l.lockedOutPoints = make(map[wire.OutPoint]struct{})
|
|
|
|
}
|
|
|
|
|
|
|
|
// ActiveReservations returns a slice of all the currently active
|
2019-10-03 18:22:43 +03:00
|
|
|
// (non-canceled) reservations.
|
2016-08-13 01:50:47 +03:00
|
|
|
func (l *LightningWallet) ActiveReservations() []*ChannelReservation {
|
|
|
|
reservations := make([]*ChannelReservation, 0, len(l.fundingLimbo))
|
|
|
|
for _, reservation := range l.fundingLimbo {
|
|
|
|
reservations = append(reservations, reservation)
|
|
|
|
}
|
|
|
|
|
|
|
|
return reservations
|
|
|
|
}
|
|
|
|
|
2016-10-15 16:18:38 +03:00
|
|
|
// requestHandler is the primary goroutine(s) responsible for handling, and
|
2018-03-10 18:21:10 +03:00
|
|
|
// dispatching replies to all messages.
|
2015-10-28 01:50:30 +03:00
|
|
|
func (l *LightningWallet) requestHandler() {
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case m := <-l.msgChan:
|
|
|
|
switch msg := m.(type) {
|
2018-08-10 05:15:18 +03:00
|
|
|
case *InitFundingReserveMsg:
|
2015-10-28 01:50:30 +03:00
|
|
|
l.handleFundingReserveRequest(msg)
|
2015-11-05 23:36:19 +03:00
|
|
|
case *fundingReserveCancelMsg:
|
2015-10-28 01:50:30 +03:00
|
|
|
l.handleFundingCancelRequest(msg)
|
2016-06-21 20:37:55 +03:00
|
|
|
case *addSingleContributionMsg:
|
|
|
|
l.handleSingleContribution(msg)
|
2015-12-22 00:53:34 +03:00
|
|
|
case *addContributionMsg:
|
|
|
|
l.handleContributionMsg(msg)
|
2016-06-21 20:37:55 +03:00
|
|
|
case *addSingleFunderSigsMsg:
|
|
|
|
l.handleSingleFunderSigs(msg)
|
2015-11-05 23:36:19 +03:00
|
|
|
case *addCounterPartySigsMsg:
|
|
|
|
l.handleFundingCounterPartySigs(msg)
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
case <-l.quit:
|
|
|
|
// TODO: do some clean up
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
l.wg.Done()
|
|
|
|
}
|
|
|
|
|
2016-10-15 16:18:38 +03:00
|
|
|
// InitChannelReservation kicks off the 3-step workflow required to successfully
|
2015-12-28 23:14:00 +03:00
|
|
|
// open a payment channel with a remote node. As part of the funding
|
|
|
|
// reservation, the inputs selected for the funding transaction are 'locked'.
|
|
|
|
// This ensures that multiple channel reservations aren't double spending the
|
|
|
|
// same inputs in the funding transaction. If reservation initialization is
|
2016-10-15 16:18:38 +03:00
|
|
|
// successful, a ChannelReservation containing our completed contribution is
|
|
|
|
// returned. Our contribution contains all the items necessary to allow the
|
2017-01-13 08:01:50 +03:00
|
|
|
// counterparty to build the funding transaction, and both versions of the
|
2018-03-10 18:21:10 +03:00
|
|
|
// commitment transaction. Otherwise, an error occurred and a nil pointer along
|
|
|
|
// with an error are returned.
|
2015-12-28 23:14:00 +03:00
|
|
|
//
|
2016-06-21 20:37:55 +03:00
|
|
|
// Once a ChannelReservation has been obtained, two additional steps must be
|
|
|
|
// processed before a payment channel can be considered 'open'. The second step
|
|
|
|
// validates, and processes the counterparty's channel contribution. The third,
|
|
|
|
// and final step verifies all signatures for the inputs of the funding
|
2018-03-10 18:21:10 +03:00
|
|
|
// transaction, and that the signature we record for our version of the
|
2016-06-21 20:37:55 +03:00
|
|
|
// commitment transaction is valid.
|
2017-07-30 05:20:08 +03:00
|
|
|
func (l *LightningWallet) InitChannelReservation(
|
2018-08-10 05:16:14 +03:00
|
|
|
req *InitFundingReserveMsg) (*ChannelReservation, error) {
|
|
|
|
|
|
|
|
req.resp = make(chan *ChannelReservation, 1)
|
|
|
|
req.err = make(chan error, 1)
|
|
|
|
|
|
|
|
select {
|
|
|
|
case l.msgChan <- req:
|
|
|
|
case <-l.quit:
|
|
|
|
return nil, errors.New("wallet shutting down")
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
|
2018-08-10 05:16:14 +03:00
|
|
|
return <-req.resp, <-req.err
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// handleFundingReserveRequest processes a message intending to create, and
|
|
|
|
// validate a funding reservation request.
|
2018-08-10 05:15:18 +03:00
|
|
|
func (l *LightningWallet) handleFundingReserveRequest(req *InitFundingReserveMsg) {
|
2016-10-24 04:42:03 +03:00
|
|
|
// It isn't possible to create a channel with zero funds committed.
|
2019-07-11 14:14:36 +03:00
|
|
|
if req.LocalFundingAmt+req.RemoteFundingAmt == 0 {
|
2018-02-27 20:35:56 +03:00
|
|
|
err := ErrZeroCapacity()
|
|
|
|
req.err <- err
|
2016-10-24 04:42:03 +03:00
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// If the funding request is for a different chain than the one the
|
|
|
|
// wallet is aware of, then we'll reject the request.
|
2018-08-10 05:15:18 +03:00
|
|
|
if !bytes.Equal(l.Cfg.NetParams.GenesisHash[:], req.ChainHash[:]) {
|
|
|
|
err := ErrChainMismatch(
|
|
|
|
l.Cfg.NetParams.GenesisHash, req.ChainHash,
|
|
|
|
)
|
2018-02-27 20:35:56 +03:00
|
|
|
req.err <- err
|
2017-07-30 05:20:08 +03:00
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
localFundingAmt := req.LocalFundingAmt
|
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
var (
|
|
|
|
selected *coinSelection
|
|
|
|
err error
|
|
|
|
)
|
|
|
|
|
|
|
|
// If we're on the receiving end of a single funder channel then we
|
|
|
|
// don't need to perform any coin selection, and the remote contributes
|
|
|
|
// all funds. Otherwise, attempt to obtain enough coins to meet the
|
|
|
|
// required funding amount.
|
|
|
|
if req.LocalFundingAmt != 0 {
|
|
|
|
// Coin selection is done on the basis of sat/kw, so we'll use
|
|
|
|
// the fee rate passed in to perform coin selection.
|
|
|
|
var err error
|
|
|
|
selected, err = l.selectCoinsAndChange(
|
|
|
|
req.FundingFeePerKw, req.LocalFundingAmt, req.MinConfs,
|
2019-07-11 14:14:37 +03:00
|
|
|
req.SubtractFees,
|
2019-07-11 14:14:36 +03:00
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
2019-07-11 14:14:37 +03:00
|
|
|
|
|
|
|
localFundingAmt = selected.fundingAmt
|
2019-07-11 14:14:36 +03:00
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:37 +03:00
|
|
|
// The total channel capacity will be the size of the funding output we
|
|
|
|
// created plus the remote contribution.
|
|
|
|
capacity := localFundingAmt + req.RemoteFundingAmt
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
id := atomic.AddUint64(&l.nextFundingID, 1)
|
2018-08-10 05:15:18 +03:00
|
|
|
reservation, err := NewChannelReservation(
|
2019-07-11 14:14:36 +03:00
|
|
|
capacity, localFundingAmt, req.CommitFeePerKw, l, id,
|
2018-08-10 05:15:18 +03:00
|
|
|
req.PushMSat, l.Cfg.NetParams.GenesisHash, req.Flags,
|
2019-08-01 06:16:52 +03:00
|
|
|
req.Tweakless,
|
2018-08-10 05:15:18 +03:00
|
|
|
)
|
2017-11-26 22:32:57 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
selected.unlockCoins()
|
2017-11-26 22:32:57 +03:00
|
|
|
req.err <- err
|
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2019-07-11 14:14:37 +03:00
|
|
|
err = l.initOurContribution(
|
|
|
|
reservation, selected, req.NodeAddr, req.NodeID,
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
selected.unlockCoins()
|
|
|
|
req.err <- err
|
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a limbo and record entry for this newly pending funding
|
|
|
|
// request.
|
|
|
|
l.limboMtx.Lock()
|
|
|
|
l.fundingLimbo[id] = reservation
|
|
|
|
l.limboMtx.Unlock()
|
|
|
|
|
|
|
|
// Funding reservation request successfully handled. The funding inputs
|
|
|
|
// will be marked as unavailable until the reservation is either
|
2019-10-03 18:22:43 +03:00
|
|
|
// completed, or canceled.
|
2019-07-11 14:14:37 +03:00
|
|
|
req.resp <- reservation
|
|
|
|
req.err <- nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// initOurContribution initializes the given ChannelReservation with our coins
|
|
|
|
// and change reserved for the channel, and derives the keys to use for this
|
|
|
|
// channel.
|
|
|
|
func (l *LightningWallet) initOurContribution(reservation *ChannelReservation,
|
|
|
|
selected *coinSelection, nodeAddr net.Addr, nodeID *btcec.PublicKey) error {
|
|
|
|
|
2016-10-15 16:18:38 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thread-safety
|
2015-12-19 06:39:51 +03:00
|
|
|
reservation.Lock()
|
|
|
|
defer reservation.Unlock()
|
2015-11-14 22:52:07 +03:00
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
if selected != nil {
|
2019-07-11 14:14:36 +03:00
|
|
|
reservation.ourContribution.Inputs = selected.coins
|
|
|
|
reservation.ourContribution.ChangeOutputs = selected.change
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:37 +03:00
|
|
|
reservation.nodeAddr = nodeAddr
|
|
|
|
reservation.partialState.IdentityPub = nodeID
|
2019-07-11 14:14:36 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Next, we'll grab a series of keys from the wallet which will be used
|
|
|
|
// for the duration of the channel. The keys include: our multi-sig
|
2017-11-15 07:32:39 +03:00
|
|
|
// key, the base revocation key, the base htlc key,the base payment
|
|
|
|
// key, and the delayed payment key.
|
2018-01-19 00:45:30 +03:00
|
|
|
//
|
2018-02-18 02:20:41 +03:00
|
|
|
// TODO(roasbeef): "salt" each key as well?
|
2019-07-11 14:14:37 +03:00
|
|
|
var err error
|
2018-02-18 02:20:41 +03:00
|
|
|
reservation.ourContribution.MultiSigKey, err = l.DeriveNextKey(
|
|
|
|
keychain.KeyFamilyMultiSig,
|
|
|
|
)
|
2017-07-30 05:20:08 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2017-07-30 05:20:08 +03:00
|
|
|
}
|
2018-02-18 02:20:41 +03:00
|
|
|
reservation.ourContribution.RevocationBasePoint, err = l.DeriveNextKey(
|
|
|
|
keychain.KeyFamilyRevocationBase,
|
|
|
|
)
|
2017-07-30 05:20:08 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2017-07-30 05:20:08 +03:00
|
|
|
}
|
2018-02-18 02:20:41 +03:00
|
|
|
reservation.ourContribution.HtlcBasePoint, err = l.DeriveNextKey(
|
|
|
|
keychain.KeyFamilyHtlcBase,
|
|
|
|
)
|
2017-11-15 07:32:39 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2017-11-15 07:32:39 +03:00
|
|
|
}
|
2018-02-18 02:20:41 +03:00
|
|
|
reservation.ourContribution.PaymentBasePoint, err = l.DeriveNextKey(
|
|
|
|
keychain.KeyFamilyPaymentBase,
|
|
|
|
)
|
2015-12-21 02:13:14 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2015-12-21 02:13:14 +03:00
|
|
|
}
|
2018-02-18 02:20:41 +03:00
|
|
|
reservation.ourContribution.DelayBasePoint, err = l.DeriveNextKey(
|
|
|
|
keychain.KeyFamilyDelayBase,
|
|
|
|
)
|
2015-11-05 23:36:19 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
2017-07-30 05:20:08 +03:00
|
|
|
|
|
|
|
// With the above keys created, we'll also need to initialization our
|
2018-02-18 02:24:43 +03:00
|
|
|
// initial revocation tree state.
|
|
|
|
nextRevocationKeyDesc, err := l.DeriveNextKey(
|
|
|
|
keychain.KeyFamilyRevocationRoot,
|
|
|
|
)
|
2015-12-21 02:13:14 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2015-12-21 02:13:14 +03:00
|
|
|
}
|
2018-02-18 02:24:43 +03:00
|
|
|
revocationRoot, err := l.DerivePrivKey(nextRevocationKeyDesc)
|
2016-03-24 10:01:35 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2016-03-24 10:01:35 +03:00
|
|
|
}
|
2017-07-30 05:20:08 +03:00
|
|
|
|
|
|
|
// Once we have the root, we can then generate our shachain producer
|
|
|
|
// and from that generate the per-commitment point.
|
2018-02-18 02:24:43 +03:00
|
|
|
revRoot, err := chainhash.NewHash(revocationRoot.Serialize())
|
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2018-02-18 02:24:43 +03:00
|
|
|
}
|
|
|
|
producer := shachain.NewRevocationProducer(*revRoot)
|
2017-07-30 05:20:08 +03:00
|
|
|
firstPreimage, err := producer.AtIndex(0)
|
|
|
|
if err != nil {
|
2019-07-11 14:14:37 +03:00
|
|
|
return err
|
2017-07-30 05:20:08 +03:00
|
|
|
}
|
2019-01-16 17:47:43 +03:00
|
|
|
reservation.ourContribution.FirstCommitmentPoint = input.ComputeCommitmentPoint(
|
2017-07-30 05:20:08 +03:00
|
|
|
firstPreimage[:],
|
|
|
|
)
|
|
|
|
|
|
|
|
reservation.partialState.RevocationProducer = producer
|
|
|
|
reservation.ourContribution.ChannelConstraints = l.Cfg.DefaultConstraints
|
|
|
|
|
2019-07-11 14:14:37 +03:00
|
|
|
return nil
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// handleFundingReserveCancel cancels an existing channel reservation. As part
|
|
|
|
// of the cancellation, outputs previously selected as inputs for the funding
|
|
|
|
// transaction via coin selection are freed allowing future reservations to
|
|
|
|
// include them.
|
2015-11-05 23:36:19 +03:00
|
|
|
func (l *LightningWallet) handleFundingCancelRequest(req *fundingReserveCancelMsg) {
|
|
|
|
// TODO(roasbeef): holding lock too long
|
|
|
|
l.limboMtx.Lock()
|
|
|
|
defer l.limboMtx.Unlock()
|
|
|
|
|
|
|
|
pendingReservation, ok := l.fundingLimbo[req.pendingFundingID]
|
|
|
|
if !ok {
|
2017-12-14 04:15:36 +03:00
|
|
|
// TODO(roasbeef): make new error, "unknown funding state" or something
|
2017-09-25 21:25:58 +03:00
|
|
|
req.err <- fmt.Errorf("attempted to cancel non-existent funding state")
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2017-12-14 04:15:36 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thread-safety
|
2015-11-14 22:52:07 +03:00
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
2017-12-14 04:15:36 +03:00
|
|
|
// Mark all previously locked outpoints as useable for future funding
|
2015-11-05 23:36:19 +03:00
|
|
|
// requests.
|
2015-12-23 07:31:17 +03:00
|
|
|
for _, unusedInput := range pendingReservation.ourContribution.Inputs {
|
2016-08-13 01:50:47 +03:00
|
|
|
delete(l.lockedOutPoints, unusedInput.PreviousOutPoint)
|
2015-12-29 21:44:59 +03:00
|
|
|
l.UnlockOutpoint(unusedInput.PreviousOutPoint)
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
|
2017-12-14 04:15:36 +03:00
|
|
|
// TODO(roasbeef): is it even worth it to keep track of unused keys?
|
2015-11-05 23:36:19 +03:00
|
|
|
|
|
|
|
// TODO(roasbeef): Is it possible to mark the unused change also as
|
|
|
|
// available?
|
|
|
|
|
|
|
|
delete(l.fundingLimbo, req.pendingFundingID)
|
|
|
|
|
|
|
|
req.err <- nil
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2017-07-30 05:18:46 +03:00
|
|
|
// CreateCommitmentTxns is a helper function that creates the initial
|
|
|
|
// commitment transaction for both parties. This function is used during the
|
|
|
|
// initial funding workflow as both sides must generate a signature for the
|
|
|
|
// remote party's commitment transaction, and verify the signature for their
|
|
|
|
// version of the commitment transaction.
|
|
|
|
func CreateCommitmentTxns(localBalance, remoteBalance btcutil.Amount,
|
|
|
|
ourChanCfg, theirChanCfg *channeldb.ChannelConfig,
|
|
|
|
localCommitPoint, remoteCommitPoint *btcec.PublicKey,
|
2019-08-01 06:10:45 +03:00
|
|
|
fundingTxIn wire.TxIn,
|
|
|
|
tweaklessCommit bool) (*wire.MsgTx, *wire.MsgTx, error) {
|
2017-07-30 05:18:46 +03:00
|
|
|
|
2019-09-17 05:06:19 +03:00
|
|
|
localCommitmentKeys := DeriveCommitmentKeys(
|
2019-08-01 06:10:45 +03:00
|
|
|
localCommitPoint, true, tweaklessCommit, ourChanCfg,
|
|
|
|
theirChanCfg,
|
|
|
|
)
|
2019-09-17 05:06:19 +03:00
|
|
|
remoteCommitmentKeys := DeriveCommitmentKeys(
|
2019-08-01 06:10:45 +03:00
|
|
|
remoteCommitPoint, false, tweaklessCommit, ourChanCfg,
|
|
|
|
theirChanCfg,
|
|
|
|
)
|
2017-07-30 05:18:46 +03:00
|
|
|
|
2017-10-02 05:42:05 +03:00
|
|
|
ourCommitTx, err := CreateCommitTx(fundingTxIn, localCommitmentKeys,
|
2017-07-30 05:18:46 +03:00
|
|
|
uint32(ourChanCfg.CsvDelay), localBalance, remoteBalance,
|
|
|
|
ourChanCfg.DustLimit)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
otxn := btcutil.NewTx(ourCommitTx)
|
|
|
|
if err := blockchain.CheckTransactionSanity(otxn); err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
2017-10-02 05:42:05 +03:00
|
|
|
theirCommitTx, err := CreateCommitTx(fundingTxIn, remoteCommitmentKeys,
|
2017-07-30 05:18:46 +03:00
|
|
|
uint32(theirChanCfg.CsvDelay), remoteBalance, localBalance,
|
|
|
|
theirChanCfg.DustLimit)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
ttxn := btcutil.NewTx(theirCommitTx)
|
|
|
|
if err := blockchain.CheckTransactionSanity(ttxn); err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return ourCommitTx, theirCommitTx, nil
|
|
|
|
}
|
|
|
|
|
2016-10-24 04:42:03 +03:00
|
|
|
// handleContributionMsg processes the second workflow step for the lifetime of
|
|
|
|
// a channel reservation. Upon completion, the reservation will carry a
|
|
|
|
// completed funding transaction (minus the counterparty's input signatures),
|
|
|
|
// both versions of the commitment transaction, and our signature for their
|
|
|
|
// version of the commitment transaction.
|
2015-12-22 00:53:34 +03:00
|
|
|
func (l *LightningWallet) handleContributionMsg(req *addContributionMsg) {
|
2017-07-30 05:20:08 +03:00
|
|
|
|
2015-11-27 09:48:20 +03:00
|
|
|
l.limboMtx.Lock()
|
2015-11-05 23:36:19 +03:00
|
|
|
pendingReservation, ok := l.fundingLimbo[req.pendingFundingID]
|
2015-11-27 09:48:20 +03:00
|
|
|
l.limboMtx.Unlock()
|
2015-11-05 23:36:19 +03:00
|
|
|
if !ok {
|
2017-09-25 21:25:58 +03:00
|
|
|
req.err <- fmt.Errorf("attempted to update non-existent funding state")
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
|
|
|
}
|
2015-11-05 23:32:15 +03:00
|
|
|
|
2018-05-22 02:52:51 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thread-safety
|
2015-11-14 22:52:07 +03:00
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
// Create a blank, fresh transaction. Soon to be a complete funding
|
|
|
|
// transaction which will allow opening a lightning channel.
|
2017-01-06 00:56:27 +03:00
|
|
|
pendingReservation.fundingTx = wire.NewMsgTx(1)
|
2016-06-21 20:37:55 +03:00
|
|
|
fundingTx := pendingReservation.fundingTx
|
2015-12-23 07:31:17 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// Some temporary variables to cut down on the resolution verbosity.
|
2015-12-23 07:31:17 +03:00
|
|
|
pendingReservation.theirContribution = req.contribution
|
|
|
|
theirContribution := req.contribution
|
|
|
|
ourContribution := pendingReservation.ourContribution
|
2015-11-05 23:32:15 +03:00
|
|
|
|
2016-05-04 05:49:58 +03:00
|
|
|
// Add all multi-party inputs and outputs to the transaction.
|
2015-12-23 07:31:17 +03:00
|
|
|
for _, ourInput := range ourContribution.Inputs {
|
|
|
|
fundingTx.AddTxIn(ourInput)
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
2015-12-23 07:31:17 +03:00
|
|
|
for _, theirInput := range theirContribution.Inputs {
|
|
|
|
fundingTx.AddTxIn(theirInput)
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
2015-12-23 07:31:17 +03:00
|
|
|
for _, ourChangeOutput := range ourContribution.ChangeOutputs {
|
|
|
|
fundingTx.AddTxOut(ourChangeOutput)
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
2015-12-23 07:31:17 +03:00
|
|
|
for _, theirChangeOutput := range theirContribution.ChangeOutputs {
|
|
|
|
fundingTx.AddTxOut(theirChangeOutput)
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
ourKey := pendingReservation.ourContribution.MultiSigKey
|
2015-12-23 07:31:17 +03:00
|
|
|
theirKey := theirContribution.MultiSigKey
|
2015-12-21 02:11:21 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// Finally, add the 2-of-2 multi-sig output which will set up the lightning
|
|
|
|
// channel.
|
2015-12-24 21:41:15 +03:00
|
|
|
channelCapacity := int64(pendingReservation.partialState.Capacity)
|
2019-01-16 17:47:43 +03:00
|
|
|
witnessScript, multiSigOut, err := input.GenFundingPkScript(
|
2018-02-18 02:20:41 +03:00
|
|
|
ourKey.PubKey.SerializeCompressed(),
|
|
|
|
theirKey.PubKey.SerializeCompressed(), channelCapacity,
|
|
|
|
)
|
2015-10-28 01:50:30 +03:00
|
|
|
if err != nil {
|
2015-11-05 23:36:19 +03:00
|
|
|
req.err <- err
|
|
|
|
return
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
2015-12-24 21:42:29 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Sort the transaction. Since both side agree to a canonical ordering,
|
|
|
|
// by sorting we no longer need to send the entire transaction. Only
|
|
|
|
// signatures will be exchanged.
|
2016-06-21 20:37:55 +03:00
|
|
|
fundingTx.AddTxOut(multiSigOut)
|
|
|
|
txsort.InPlaceSort(pendingReservation.fundingTx)
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// Next, sign all inputs that are ours, collecting the signatures in
|
2015-11-05 23:36:19 +03:00
|
|
|
// order of the inputs.
|
2019-01-16 17:47:43 +03:00
|
|
|
pendingReservation.ourFundingInputScripts = make([]*input.Script, 0,
|
2017-07-30 05:20:08 +03:00
|
|
|
len(ourContribution.Inputs))
|
2019-01-16 17:47:43 +03:00
|
|
|
signDesc := input.SignDescriptor{
|
2016-08-13 01:50:47 +03:00
|
|
|
HashType: txscript.SigHashAll,
|
|
|
|
SigHashes: txscript.NewTxSigHashes(fundingTx),
|
|
|
|
}
|
2015-12-23 07:31:17 +03:00
|
|
|
for i, txIn := range fundingTx.TxIn {
|
2016-08-13 01:50:47 +03:00
|
|
|
info, err := l.FetchInputInfo(&txIn.PreviousOutPoint)
|
|
|
|
if err == ErrNotMine {
|
2015-11-05 23:36:19 +03:00
|
|
|
continue
|
2016-08-13 01:50:47 +03:00
|
|
|
} else if err != nil {
|
|
|
|
req.err <- err
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
|
|
|
}
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2019-08-20 00:26:36 +03:00
|
|
|
signDesc.Output = &wire.TxOut{
|
|
|
|
PkScript: info.PkScript,
|
|
|
|
Value: int64(info.Value),
|
|
|
|
}
|
2016-08-13 01:50:47 +03:00
|
|
|
signDesc.InputIndex = i
|
2016-05-04 05:49:58 +03:00
|
|
|
|
2018-11-18 07:46:51 +03:00
|
|
|
inputScript, err := l.Cfg.Signer.ComputeInputScript(
|
|
|
|
fundingTx, &signDesc,
|
|
|
|
)
|
2015-10-28 01:50:30 +03:00
|
|
|
if err != nil {
|
2016-08-13 01:50:47 +03:00
|
|
|
req.err <- err
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2018-11-18 07:46:51 +03:00
|
|
|
txIn.SignatureScript = inputScript.SigScript
|
2016-08-13 01:50:47 +03:00
|
|
|
txIn.Witness = inputScript.Witness
|
2016-05-04 05:49:58 +03:00
|
|
|
pendingReservation.ourFundingInputScripts = append(
|
|
|
|
pendingReservation.ourFundingInputScripts,
|
|
|
|
inputScript,
|
|
|
|
)
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// Locate the index of the multi-sig outpoint in order to record it
|
2016-10-16 02:02:09 +03:00
|
|
|
// since the outputs are canonically sorted. If this is a single funder
|
2016-06-21 20:37:55 +03:00
|
|
|
// workflow, then we'll also need to send this to the remote node.
|
2017-01-06 00:56:27 +03:00
|
|
|
fundingTxID := fundingTx.TxHash()
|
2019-01-16 17:47:43 +03:00
|
|
|
_, multiSigIndex := input.FindScriptOutputIndex(fundingTx, multiSigOut.PkScript)
|
2016-06-21 20:37:55 +03:00
|
|
|
fundingOutpoint := wire.NewOutPoint(&fundingTxID, multiSigIndex)
|
2017-07-30 05:20:08 +03:00
|
|
|
pendingReservation.partialState.FundingOutpoint = *fundingOutpoint
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2018-02-01 01:00:01 +03:00
|
|
|
walletLog.Debugf("Funding tx for ChannelPoint(%v) generated: %v",
|
|
|
|
fundingOutpoint, spew.Sdump(fundingTx))
|
|
|
|
|
2015-12-22 00:53:34 +03:00
|
|
|
// Initialize an empty sha-chain for them, tracking the current pending
|
2017-01-13 08:01:50 +03:00
|
|
|
// revocation hash (we don't yet know the preimage so we can't add it
|
2015-12-22 00:53:34 +03:00
|
|
|
// to the chain).
|
2016-12-14 17:01:48 +03:00
|
|
|
s := shachain.NewRevocationStore()
|
|
|
|
pendingReservation.partialState.RevocationStore = s
|
2016-08-13 01:43:16 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Store their current commitment point. We'll need this after the
|
|
|
|
// first state transition in order to verify the authenticity of the
|
|
|
|
// revocation.
|
|
|
|
chanState := pendingReservation.partialState
|
|
|
|
chanState.RemoteCurrentRevocation = theirContribution.FirstCommitmentPoint
|
2015-12-22 00:53:34 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Create the txin to our commitment transaction; required to construct
|
2016-06-21 20:37:55 +03:00
|
|
|
// the commitment transactions.
|
2017-12-22 21:26:16 +03:00
|
|
|
fundingTxIn := wire.TxIn{
|
2017-07-30 05:20:08 +03:00
|
|
|
PreviousOutPoint: wire.OutPoint{
|
|
|
|
Hash: fundingTxID,
|
|
|
|
Index: multiSigIndex,
|
|
|
|
},
|
|
|
|
}
|
2015-12-22 00:53:34 +03:00
|
|
|
|
|
|
|
// With the funding tx complete, create both commitment transactions.
|
2017-11-11 01:18:41 +03:00
|
|
|
localBalance := pendingReservation.partialState.LocalCommitment.LocalBalance.ToSatoshis()
|
|
|
|
remoteBalance := pendingReservation.partialState.LocalCommitment.RemoteBalance.ToSatoshis()
|
2019-08-01 06:10:45 +03:00
|
|
|
tweaklessCommits := pendingReservation.partialState.ChanType.IsTweakless()
|
2017-07-30 05:20:08 +03:00
|
|
|
ourCommitTx, theirCommitTx, err := CreateCommitmentTxns(
|
|
|
|
localBalance, remoteBalance, ourContribution.ChannelConfig,
|
|
|
|
theirContribution.ChannelConfig,
|
|
|
|
ourContribution.FirstCommitmentPoint,
|
|
|
|
theirContribution.FirstCommitmentPoint, fundingTxIn,
|
2019-08-01 06:10:45 +03:00
|
|
|
tweaklessCommits,
|
2017-07-30 05:20:08 +03:00
|
|
|
)
|
2015-12-22 00:53:34 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-11-16 23:54:27 +03:00
|
|
|
// With both commitment transactions constructed, generate the state
|
2017-09-25 21:25:58 +03:00
|
|
|
// obfuscator then use it to encode the current state number within
|
2017-07-30 05:20:08 +03:00
|
|
|
// both commitment transactions.
|
2017-09-25 21:25:58 +03:00
|
|
|
var stateObfuscator [StateHintSize]byte
|
2019-08-01 06:16:52 +03:00
|
|
|
if chanState.ChanType.IsSingleFunder() {
|
2018-01-19 00:45:30 +03:00
|
|
|
stateObfuscator = DeriveStateHintObfuscator(
|
2018-02-18 02:20:41 +03:00
|
|
|
ourContribution.PaymentBasePoint.PubKey,
|
|
|
|
theirContribution.PaymentBasePoint.PubKey,
|
2017-07-30 05:20:08 +03:00
|
|
|
)
|
|
|
|
} else {
|
2018-02-18 02:20:41 +03:00
|
|
|
ourSer := ourContribution.PaymentBasePoint.PubKey.SerializeCompressed()
|
|
|
|
theirSer := theirContribution.PaymentBasePoint.PubKey.SerializeCompressed()
|
2017-07-30 05:20:08 +03:00
|
|
|
switch bytes.Compare(ourSer, theirSer) {
|
|
|
|
case -1:
|
2018-01-19 00:45:30 +03:00
|
|
|
stateObfuscator = DeriveStateHintObfuscator(
|
2018-02-18 02:20:41 +03:00
|
|
|
ourContribution.PaymentBasePoint.PubKey,
|
|
|
|
theirContribution.PaymentBasePoint.PubKey,
|
2017-07-30 05:20:08 +03:00
|
|
|
)
|
|
|
|
default:
|
2018-01-19 00:45:30 +03:00
|
|
|
stateObfuscator = DeriveStateHintObfuscator(
|
2018-02-18 02:20:41 +03:00
|
|
|
theirContribution.PaymentBasePoint.PubKey,
|
|
|
|
ourContribution.PaymentBasePoint.PubKey,
|
2017-07-30 05:20:08 +03:00
|
|
|
)
|
2016-11-16 23:54:27 +03:00
|
|
|
}
|
|
|
|
}
|
2017-09-25 21:25:58 +03:00
|
|
|
err = initStateHints(ourCommitTx, theirCommitTx, stateObfuscator)
|
2016-11-16 23:54:27 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Sort both transactions according to the agreed upon canonical
|
2015-12-31 09:36:01 +03:00
|
|
|
// ordering. This lets us skip sending the entire transaction over,
|
|
|
|
// instead we'll just send signatures.
|
|
|
|
txsort.InPlaceSort(ourCommitTx)
|
|
|
|
txsort.InPlaceSort(theirCommitTx)
|
|
|
|
|
2018-02-01 01:00:01 +03:00
|
|
|
walletLog.Debugf("Local commit tx for ChannelPoint(%v): %v",
|
|
|
|
fundingOutpoint, spew.Sdump(ourCommitTx))
|
|
|
|
walletLog.Debugf("Remote commit tx for ChannelPoint(%v): %v",
|
|
|
|
fundingOutpoint, spew.Sdump(theirCommitTx))
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Record newly available information within the open channel state.
|
|
|
|
chanState.FundingOutpoint = *fundingOutpoint
|
2017-11-11 01:18:41 +03:00
|
|
|
chanState.LocalCommitment.CommitTx = ourCommitTx
|
|
|
|
chanState.RemoteCommitment.CommitTx = theirCommitTx
|
2015-12-22 00:53:34 +03:00
|
|
|
|
|
|
|
// Generate a signature for their version of the initial commitment
|
|
|
|
// transaction.
|
2019-01-16 17:47:43 +03:00
|
|
|
signDesc = input.SignDescriptor{
|
2016-10-16 02:02:09 +03:00
|
|
|
WitnessScript: witnessScript,
|
2018-02-18 02:20:41 +03:00
|
|
|
KeyDesc: ourKey,
|
2016-10-24 04:42:03 +03:00
|
|
|
Output: multiSigOut,
|
|
|
|
HashType: txscript.SigHashAll,
|
|
|
|
SigHashes: txscript.NewTxSigHashes(theirCommitTx),
|
|
|
|
InputIndex: 0,
|
2016-08-13 01:50:47 +03:00
|
|
|
}
|
2017-07-30 05:02:38 +03:00
|
|
|
sigTheirCommit, err := l.Cfg.Signer.SignOutputRaw(theirCommitTx, &signDesc)
|
2015-12-22 00:53:34 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
2015-12-23 07:31:17 +03:00
|
|
|
pendingReservation.ourCommitmentSig = sigTheirCommit
|
2015-12-22 00:53:34 +03:00
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
req.err <- nil
|
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// handleSingleContribution is called as the second step to a single funder
|
|
|
|
// workflow to which we are the responder. It simply saves the remote peer's
|
|
|
|
// contribution to the channel, as solely the remote peer will contribute any
|
|
|
|
// funds to the channel.
|
|
|
|
func (l *LightningWallet) handleSingleContribution(req *addSingleContributionMsg) {
|
|
|
|
l.limboMtx.Lock()
|
|
|
|
pendingReservation, ok := l.fundingLimbo[req.pendingFundingID]
|
|
|
|
l.limboMtx.Unlock()
|
|
|
|
if !ok {
|
2017-07-30 05:20:08 +03:00
|
|
|
req.err <- fmt.Errorf("attempted to update non-existent funding state")
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Grab the mutex on the channelReservation to ensure thread-safety.
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// TODO(roasbeef): verify sanity of remote party's parameters, fail if
|
|
|
|
// disagree
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// Simply record the counterparty's contribution into the pending
|
|
|
|
// reservation data as they'll be solely funding the channel entirely.
|
|
|
|
pendingReservation.theirContribution = req.contribution
|
|
|
|
theirContribution := pendingReservation.theirContribution
|
2017-07-30 05:20:08 +03:00
|
|
|
chanState := pendingReservation.partialState
|
2016-06-30 22:13:46 +03:00
|
|
|
|
|
|
|
// Initialize an empty sha-chain for them, tracking the current pending
|
2017-01-13 08:01:50 +03:00
|
|
|
// revocation hash (we don't yet know the preimage so we can't add it
|
2016-06-30 22:13:46 +03:00
|
|
|
// to the chain).
|
2016-12-14 17:01:48 +03:00
|
|
|
remotePreimageStore := shachain.NewRevocationStore()
|
2017-07-30 05:20:08 +03:00
|
|
|
chanState.RevocationStore = remotePreimageStore
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Now that we've received their first commitment point, we'll store it
|
|
|
|
// within the channel state so we can sync it to disk once the funding
|
|
|
|
// process is complete.
|
|
|
|
chanState.RemoteCurrentRevocation = theirContribution.FirstCommitmentPoint
|
2016-06-21 20:37:55 +03:00
|
|
|
|
|
|
|
req.err <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-12-25 03:47:09 +03:00
|
|
|
// openChanDetails contains a "finalized" channel which can be considered
|
|
|
|
// "open" according to the requested confirmation depth at reservation
|
|
|
|
// initialization. Additionally, the struct contains additional details
|
|
|
|
// pertaining to the exact location in the main chain in-which the transaction
|
|
|
|
// was confirmed.
|
|
|
|
type openChanDetails struct {
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// handleFundingCounterPartySigs is the final step in the channel reservation
|
2016-10-16 02:02:09 +03:00
|
|
|
// workflow. During this step, we validate *all* the received signatures for
|
2015-12-28 23:14:00 +03:00
|
|
|
// inputs to the funding transaction. If any of these are invalid, we bail,
|
|
|
|
// and forcibly cancel this funding request. Additionally, we ensure that the
|
|
|
|
// signature we received from the counterparty for our version of the commitment
|
|
|
|
// transaction allows us to spend from the funding output with the addition of
|
|
|
|
// our signature.
|
2015-11-05 23:36:19 +03:00
|
|
|
func (l *LightningWallet) handleFundingCounterPartySigs(msg *addCounterPartySigsMsg) {
|
2015-11-13 05:43:32 +03:00
|
|
|
l.limboMtx.RLock()
|
2016-10-27 00:56:48 +03:00
|
|
|
res, ok := l.fundingLimbo[msg.pendingFundingID]
|
2015-11-13 05:43:32 +03:00
|
|
|
l.limboMtx.RUnlock()
|
2015-11-05 23:36:19 +03:00
|
|
|
if !ok {
|
2017-07-30 05:20:08 +03:00
|
|
|
msg.err <- fmt.Errorf("attempted to update non-existent funding state")
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:02:38 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thread-safety
|
2016-10-27 00:56:48 +03:00
|
|
|
res.Lock()
|
|
|
|
defer res.Unlock()
|
2015-11-14 22:52:07 +03:00
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
// Now we can complete the funding transaction by adding their
|
|
|
|
// signatures to their inputs.
|
2016-10-27 00:56:48 +03:00
|
|
|
res.theirFundingInputScripts = msg.theirFundingInputScripts
|
2016-06-21 20:37:55 +03:00
|
|
|
inputScripts := msg.theirFundingInputScripts
|
2016-10-27 00:56:48 +03:00
|
|
|
fundingTx := res.fundingTx
|
2016-02-03 10:59:27 +03:00
|
|
|
sigIndex := 0
|
2016-05-04 05:49:58 +03:00
|
|
|
fundingHashCache := txscript.NewTxSigHashes(fundingTx)
|
2015-12-03 03:51:46 +03:00
|
|
|
for i, txin := range fundingTx.TxIn {
|
2016-06-21 20:37:55 +03:00
|
|
|
if len(inputScripts) != 0 && len(txin.Witness) == 0 {
|
2016-05-04 05:49:58 +03:00
|
|
|
// Attach the input scripts so we can verify it below.
|
|
|
|
txin.Witness = inputScripts[sigIndex].Witness
|
2018-11-18 07:46:51 +03:00
|
|
|
txin.SignatureScript = inputScripts[sigIndex].SigScript
|
2016-02-03 10:43:12 +03:00
|
|
|
|
2016-01-07 03:15:49 +03:00
|
|
|
// Fetch the alleged previous output along with the
|
2015-12-03 03:51:46 +03:00
|
|
|
// pkscript referenced by this input.
|
2018-07-18 05:20:05 +03:00
|
|
|
//
|
|
|
|
// TODO(roasbeef): when dual funder pass actual
|
|
|
|
// height-hint
|
2019-01-16 17:47:43 +03:00
|
|
|
pkScript, err := input.WitnessScriptHash(
|
2018-07-18 05:20:05 +03:00
|
|
|
txin.Witness[len(txin.Witness)-1],
|
|
|
|
)
|
|
|
|
if err != nil {
|
2019-03-22 10:41:46 +03:00
|
|
|
msg.err <- fmt.Errorf("cannot create script: "+
|
|
|
|
"%v", err)
|
|
|
|
msg.completeChan <- nil
|
|
|
|
return
|
2018-07-18 05:20:05 +03:00
|
|
|
}
|
2019-03-22 10:41:46 +03:00
|
|
|
|
2018-07-18 05:20:05 +03:00
|
|
|
output, err := l.Cfg.ChainIO.GetUtxo(
|
|
|
|
&txin.PreviousOutPoint,
|
2018-08-24 16:31:57 +03:00
|
|
|
pkScript, 0, l.quit,
|
2018-07-18 05:20:05 +03:00
|
|
|
)
|
2016-01-07 03:15:49 +03:00
|
|
|
if output == nil {
|
2017-04-14 10:46:31 +03:00
|
|
|
msg.err <- fmt.Errorf("input to funding tx "+
|
|
|
|
"does not exist: %v", err)
|
|
|
|
msg.completeChan <- nil
|
2015-12-03 03:51:46 +03:00
|
|
|
return
|
|
|
|
}
|
2016-05-04 05:49:58 +03:00
|
|
|
|
|
|
|
// Ensure that the witness+sigScript combo is valid.
|
2016-08-13 01:50:47 +03:00
|
|
|
vm, err := txscript.NewEngine(output.PkScript,
|
2016-05-04 05:49:58 +03:00
|
|
|
fundingTx, i, txscript.StandardVerifyFlags, nil,
|
2016-08-13 01:50:47 +03:00
|
|
|
fundingHashCache, output.Value)
|
2015-12-03 03:51:46 +03:00
|
|
|
if err != nil {
|
2017-04-14 10:46:31 +03:00
|
|
|
msg.err <- fmt.Errorf("cannot create script "+
|
|
|
|
"engine: %s", err)
|
|
|
|
msg.completeChan <- nil
|
2015-12-03 03:51:46 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if err = vm.Execute(); err != nil {
|
2017-04-14 10:46:31 +03:00
|
|
|
msg.err <- fmt.Errorf("cannot validate "+
|
|
|
|
"transaction: %s", err)
|
|
|
|
msg.completeChan <- nil
|
2015-12-03 03:51:46 +03:00
|
|
|
return
|
2016-01-07 03:15:49 +03:00
|
|
|
}
|
2016-02-03 10:59:27 +03:00
|
|
|
|
|
|
|
sigIndex++
|
2015-11-05 23:36:19 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:13:41 +03:00
|
|
|
// At this point, we can also record and verify their signature for our
|
2015-12-22 00:54:33 +03:00
|
|
|
// commitment transaction.
|
2016-10-27 00:56:48 +03:00
|
|
|
res.theirCommitmentSig = msg.theirCommitmentSig
|
2017-11-11 01:18:41 +03:00
|
|
|
commitTx := res.partialState.LocalCommitment.CommitTx
|
2017-07-30 05:20:08 +03:00
|
|
|
ourKey := res.ourContribution.MultiSigKey
|
2016-10-27 00:56:48 +03:00
|
|
|
theirKey := res.theirContribution.MultiSigKey
|
2015-12-28 23:13:41 +03:00
|
|
|
|
2016-10-16 02:02:09 +03:00
|
|
|
// Re-generate both the witnessScript and p2sh output. We sign the
|
|
|
|
// witnessScript script, but include the p2sh output as the subscript
|
2015-12-28 23:13:41 +03:00
|
|
|
// for verification.
|
2019-01-16 17:47:43 +03:00
|
|
|
witnessScript, _, err := input.GenFundingPkScript(
|
2018-02-18 02:20:41 +03:00
|
|
|
ourKey.PubKey.SerializeCompressed(),
|
|
|
|
theirKey.PubKey.SerializeCompressed(),
|
|
|
|
int64(res.partialState.Capacity),
|
|
|
|
)
|
2017-07-30 05:20:08 +03:00
|
|
|
if err != nil {
|
|
|
|
msg.err <- err
|
|
|
|
msg.completeChan <- nil
|
|
|
|
return
|
|
|
|
}
|
2015-12-28 23:13:41 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// Next, create the spending scriptSig, and then verify that the script
|
|
|
|
// is complete, allowing us to spend from the funding transaction.
|
2016-10-27 00:56:48 +03:00
|
|
|
channelValue := int64(res.partialState.Capacity)
|
2017-11-11 01:18:41 +03:00
|
|
|
hashCache := txscript.NewTxSigHashes(commitTx)
|
2016-10-16 02:02:09 +03:00
|
|
|
sigHash, err := txscript.CalcWitnessSigHash(witnessScript, hashCache,
|
2017-11-11 01:18:41 +03:00
|
|
|
txscript.SigHashAll, commitTx, 0, channelValue)
|
2015-12-28 23:13:41 +03:00
|
|
|
if err != nil {
|
2017-09-26 04:45:46 +03:00
|
|
|
msg.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
msg.completeChan <- nil
|
2015-12-28 23:13:41 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// Verify that we've received a valid signature from the remote party
|
|
|
|
// for our version of the commitment transaction.
|
2017-09-26 04:45:46 +03:00
|
|
|
theirCommitSig := msg.theirCommitmentSig
|
2016-08-13 01:50:47 +03:00
|
|
|
sig, err := btcec.ParseSignature(theirCommitSig, btcec.S256())
|
2015-12-28 23:13:41 +03:00
|
|
|
if err != nil {
|
|
|
|
msg.err <- err
|
2017-07-30 05:02:38 +03:00
|
|
|
msg.completeChan <- nil
|
2015-12-28 23:13:41 +03:00
|
|
|
return
|
2018-02-18 02:20:41 +03:00
|
|
|
} else if !sig.Verify(sigHash, theirKey.PubKey) {
|
2016-08-13 01:50:47 +03:00
|
|
|
msg.err <- fmt.Errorf("counterparty's commitment signature is invalid")
|
2017-04-14 10:46:31 +03:00
|
|
|
msg.completeChan <- nil
|
2015-12-28 23:13:41 +03:00
|
|
|
return
|
|
|
|
}
|
2017-11-11 01:18:41 +03:00
|
|
|
res.partialState.LocalCommitment.CommitSig = theirCommitSig
|
2016-07-06 02:53:55 +03:00
|
|
|
|
2015-12-19 06:39:51 +03:00
|
|
|
// Funding complete, this entry can be removed from limbo.
|
2015-11-13 05:43:32 +03:00
|
|
|
l.limboMtx.Lock()
|
2016-10-27 00:56:48 +03:00
|
|
|
delete(l.fundingLimbo, res.reservationID)
|
2015-11-13 05:43:32 +03:00
|
|
|
l.limboMtx.Unlock()
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2017-06-06 01:05:35 +03:00
|
|
|
// As we're about to broadcast the funding transaction, we'll take note
|
|
|
|
// of the current height for record keeping purposes.
|
|
|
|
//
|
|
|
|
// TODO(roasbeef): this info can also be piped into light client's
|
|
|
|
// basic fee estimation?
|
2017-07-30 05:02:38 +03:00
|
|
|
_, bestHeight, err := l.Cfg.ChainIO.GetBestBlock()
|
2017-06-06 01:05:35 +03:00
|
|
|
if err != nil {
|
|
|
|
msg.err <- err
|
|
|
|
msg.completeChan <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// As we've completed the funding process, we'll no convert the
|
|
|
|
// contribution structs into their underlying channel config objects to
|
|
|
|
// he stored within the database.
|
|
|
|
res.partialState.LocalChanCfg = res.ourContribution.toChanConfig()
|
|
|
|
res.partialState.RemoteChanCfg = res.theirContribution.toChanConfig()
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2018-03-11 04:28:17 +03:00
|
|
|
// We'll also record the finalized funding txn, which will allow us to
|
|
|
|
// rebroadcast on startup in case we fail.
|
|
|
|
res.partialState.FundingTxn = fundingTx
|
|
|
|
|
2018-02-07 06:13:07 +03:00
|
|
|
// Add the complete funding transaction to the DB, in its open bucket
|
2015-12-03 03:51:21 +03:00
|
|
|
// which will be used for the lifetime of this channel.
|
2016-10-27 00:56:48 +03:00
|
|
|
nodeAddr := res.nodeAddr
|
2017-06-06 01:05:35 +03:00
|
|
|
err = res.partialState.SyncPending(nodeAddr, uint32(bestHeight))
|
|
|
|
if err != nil {
|
2016-03-24 10:01:35 +03:00
|
|
|
msg.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
msg.completeChan <- nil
|
2016-03-24 10:01:35 +03:00
|
|
|
return
|
|
|
|
}
|
2015-12-03 03:51:21 +03:00
|
|
|
|
2017-01-24 05:19:54 +03:00
|
|
|
msg.completeChan <- res.partialState
|
2016-03-24 10:01:35 +03:00
|
|
|
msg.err <- nil
|
2015-11-13 05:43:32 +03:00
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// handleSingleFunderSigs is called once the remote peer who initiated the
|
|
|
|
// single funder workflow has assembled the funding transaction, and generated
|
|
|
|
// a signature for our version of the commitment transaction. This method
|
|
|
|
// progresses the workflow by generating a signature for the remote peer's
|
|
|
|
// version of the commitment transaction.
|
|
|
|
func (l *LightningWallet) handleSingleFunderSigs(req *addSingleFunderSigsMsg) {
|
|
|
|
l.limboMtx.RLock()
|
|
|
|
pendingReservation, ok := l.fundingLimbo[req.pendingFundingID]
|
|
|
|
l.limboMtx.RUnlock()
|
|
|
|
if !ok {
|
2017-09-25 21:25:58 +03:00
|
|
|
req.err <- fmt.Errorf("attempted to update non-existent funding state")
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:02:38 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thread-safety
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
chanState := pendingReservation.partialState
|
|
|
|
chanState.FundingOutpoint = *req.fundingOutpoint
|
2016-06-21 20:37:55 +03:00
|
|
|
fundingTxIn := wire.NewTxIn(req.fundingOutpoint, nil, nil)
|
|
|
|
|
|
|
|
// Now that we have the funding outpoint, we can generate both versions
|
|
|
|
// of the commitment transaction, and generate a signature for the
|
|
|
|
// remote node's commitment transactions.
|
2017-11-11 01:18:41 +03:00
|
|
|
localBalance := pendingReservation.partialState.LocalCommitment.LocalBalance.ToSatoshis()
|
|
|
|
remoteBalance := pendingReservation.partialState.LocalCommitment.RemoteBalance.ToSatoshis()
|
2019-08-01 06:10:45 +03:00
|
|
|
tweaklessCommits := pendingReservation.partialState.ChanType.IsTweakless()
|
2017-07-30 05:20:08 +03:00
|
|
|
ourCommitTx, theirCommitTx, err := CreateCommitmentTxns(
|
|
|
|
localBalance, remoteBalance,
|
|
|
|
pendingReservation.ourContribution.ChannelConfig,
|
|
|
|
pendingReservation.theirContribution.ChannelConfig,
|
|
|
|
pendingReservation.ourContribution.FirstCommitmentPoint,
|
|
|
|
pendingReservation.theirContribution.FirstCommitmentPoint,
|
2019-08-01 06:10:45 +03:00
|
|
|
*fundingTxIn, tweaklessCommits,
|
2017-07-30 05:20:08 +03:00
|
|
|
)
|
2017-12-15 01:04:30 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.completeChan <- nil
|
|
|
|
return
|
|
|
|
}
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// With both commitment transactions constructed, we can now use the
|
|
|
|
// generator state obfuscator to encode the current state number within
|
2016-11-16 23:54:27 +03:00
|
|
|
// both commitment transactions.
|
2018-01-19 00:45:30 +03:00
|
|
|
stateObfuscator := DeriveStateHintObfuscator(
|
2018-02-18 02:20:41 +03:00
|
|
|
pendingReservation.theirContribution.PaymentBasePoint.PubKey,
|
|
|
|
pendingReservation.ourContribution.PaymentBasePoint.PubKey,
|
|
|
|
)
|
2017-09-25 21:25:58 +03:00
|
|
|
err = initStateHints(ourCommitTx, theirCommitTx, stateObfuscator)
|
2016-11-16 23:54:27 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-11-16 23:54:27 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
// Sort both transactions according to the agreed upon canonical
|
2016-06-21 20:37:55 +03:00
|
|
|
// ordering. This ensures that both parties sign the same sighash
|
|
|
|
// without further synchronization.
|
|
|
|
txsort.InPlaceSort(ourCommitTx)
|
|
|
|
txsort.InPlaceSort(theirCommitTx)
|
2017-11-11 01:18:41 +03:00
|
|
|
chanState.LocalCommitment.CommitTx = ourCommitTx
|
|
|
|
chanState.RemoteCommitment.CommitTx = theirCommitTx
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2018-02-01 01:00:01 +03:00
|
|
|
walletLog.Debugf("Local commit tx for ChannelPoint(%v): %v",
|
|
|
|
req.fundingOutpoint, spew.Sdump(ourCommitTx))
|
|
|
|
walletLog.Debugf("Remote commit tx for ChannelPoint(%v): %v",
|
|
|
|
req.fundingOutpoint, spew.Sdump(theirCommitTx))
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
channelValue := int64(pendingReservation.partialState.Capacity)
|
|
|
|
hashCache := txscript.NewTxSigHashes(ourCommitTx)
|
|
|
|
theirKey := pendingReservation.theirContribution.MultiSigKey
|
2017-07-30 05:20:08 +03:00
|
|
|
ourKey := pendingReservation.ourContribution.MultiSigKey
|
2019-01-16 17:47:43 +03:00
|
|
|
witnessScript, _, err := input.GenFundingPkScript(
|
2018-02-18 02:20:41 +03:00
|
|
|
ourKey.PubKey.SerializeCompressed(),
|
|
|
|
theirKey.PubKey.SerializeCompressed(), channelValue,
|
|
|
|
)
|
2017-07-30 05:20:08 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.completeChan <- nil
|
|
|
|
return
|
|
|
|
}
|
2016-08-13 01:50:47 +03:00
|
|
|
|
2016-10-16 02:02:09 +03:00
|
|
|
sigHash, err := txscript.CalcWitnessSigHash(witnessScript, hashCache,
|
2016-08-13 01:50:47 +03:00
|
|
|
txscript.SigHashAll, ourCommitTx, 0, channelValue)
|
2016-06-21 20:37:55 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// Verify that we've received a valid signature from the remote party
|
|
|
|
// for our version of the commitment transaction.
|
|
|
|
sig, err := btcec.ParseSignature(req.theirCommitmentSig, btcec.S256())
|
2016-06-21 20:37:55 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
2018-02-18 02:20:41 +03:00
|
|
|
} else if !sig.Verify(sigHash, theirKey.PubKey) {
|
|
|
|
req.err <- fmt.Errorf("counterparty's commitment signature " +
|
|
|
|
"is invalid")
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
|
|
|
}
|
2017-11-11 01:18:41 +03:00
|
|
|
chanState.LocalCommitment.CommitSig = req.theirCommitmentSig
|
2016-07-06 02:53:55 +03:00
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// With their signature for our version of the commitment transactions
|
|
|
|
// verified, we can now generate a signature for their version,
|
|
|
|
// allowing the funding transaction to be safely broadcast.
|
2019-01-16 17:47:43 +03:00
|
|
|
p2wsh, err := input.WitnessScriptHash(witnessScript)
|
2016-08-13 01:50:47 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-08-13 01:50:47 +03:00
|
|
|
return
|
|
|
|
}
|
2019-01-16 17:47:43 +03:00
|
|
|
signDesc := input.SignDescriptor{
|
2016-10-16 02:02:09 +03:00
|
|
|
WitnessScript: witnessScript,
|
2018-02-18 02:20:41 +03:00
|
|
|
KeyDesc: ourKey,
|
2016-08-13 01:50:47 +03:00
|
|
|
Output: &wire.TxOut{
|
|
|
|
PkScript: p2wsh,
|
|
|
|
Value: channelValue,
|
|
|
|
},
|
|
|
|
HashType: txscript.SigHashAll,
|
|
|
|
SigHashes: txscript.NewTxSigHashes(theirCommitTx),
|
|
|
|
InputIndex: 0,
|
|
|
|
}
|
2017-07-30 05:20:08 +03:00
|
|
|
sigTheirCommit, err := l.Cfg.Signer.SignOutputRaw(theirCommitTx, &signDesc)
|
2016-06-21 20:37:55 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
pendingReservation.ourCommitmentSig = sigTheirCommit
|
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
_, bestHeight, err := l.Cfg.ChainIO.GetBestBlock()
|
2017-06-06 01:05:35 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.completeChan <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// Add the complete funding transaction to the DB, in it's open bucket
|
|
|
|
// which will be used for the lifetime of this channel.
|
2017-07-30 05:20:08 +03:00
|
|
|
chanState.LocalChanCfg = pendingReservation.ourContribution.toChanConfig()
|
|
|
|
chanState.RemoteChanCfg = pendingReservation.theirContribution.toChanConfig()
|
|
|
|
err = chanState.SyncPending(pendingReservation.nodeAddr, uint32(bestHeight))
|
2017-05-17 05:00:19 +03:00
|
|
|
if err != nil {
|
2017-01-23 02:06:28 +03:00
|
|
|
req.err <- err
|
2017-04-14 10:46:31 +03:00
|
|
|
req.completeChan <- nil
|
2017-01-23 02:06:28 +03:00
|
|
|
return
|
|
|
|
}
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2017-07-30 05:20:08 +03:00
|
|
|
req.completeChan <- chanState
|
2017-01-23 02:06:28 +03:00
|
|
|
req.err <- nil
|
2017-01-31 07:21:52 +03:00
|
|
|
|
|
|
|
l.limboMtx.Lock()
|
|
|
|
delete(l.fundingLimbo, req.pendingFundingID)
|
|
|
|
l.limboMtx.Unlock()
|
2016-01-07 03:17:18 +03:00
|
|
|
}
|
|
|
|
|
2018-11-18 08:06:59 +03:00
|
|
|
// WithCoinSelectLock will execute the passed function closure in a
|
|
|
|
// synchronized manner preventing any coin selection operations from proceeding
|
|
|
|
// while the closure if executing. This can be seen as the ability to execute a
|
|
|
|
// function closure under an exclusive coin selection lock.
|
|
|
|
func (l *LightningWallet) WithCoinSelectLock(f func() error) error {
|
|
|
|
l.coinSelectMtx.Lock()
|
|
|
|
defer l.coinSelectMtx.Unlock()
|
|
|
|
|
|
|
|
return f()
|
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
// coinSelection holds the result from selectCoinsAndChange.
|
|
|
|
type coinSelection struct {
|
|
|
|
coins []*wire.TxIn
|
|
|
|
change []*wire.TxOut
|
2019-07-11 14:14:37 +03:00
|
|
|
fundingAmt btcutil.Amount
|
2019-07-11 14:14:36 +03:00
|
|
|
unlockCoins func()
|
|
|
|
}
|
|
|
|
|
2016-06-21 20:33:14 +03:00
|
|
|
// selectCoinsAndChange performs coin selection in order to obtain witness
|
2019-07-11 14:14:36 +03:00
|
|
|
// outputs which sum to at least 'amt' amount of satoshis. If necessary,
|
|
|
|
// a change address will also be generated. If coin selection is
|
|
|
|
// successful/possible, then the selected coins and change outputs are
|
2019-07-11 14:14:37 +03:00
|
|
|
// returned, and the value of the resulting funding output. This method locks
|
|
|
|
// the selected outputs, and a function closure to unlock them in case of an
|
|
|
|
// error is returned.
|
2019-10-31 05:43:05 +03:00
|
|
|
func (l *LightningWallet) selectCoinsAndChange(feeRate chainfee.SatPerKWeight,
|
2019-07-11 14:14:37 +03:00
|
|
|
amt btcutil.Amount, minConfs int32, subtractFees bool) (
|
|
|
|
*coinSelection, error) {
|
2016-06-21 20:33:14 +03:00
|
|
|
|
|
|
|
// We hold the coin select mutex while querying for outputs, and
|
2016-09-13 05:05:56 +03:00
|
|
|
// performing coin selection in order to avoid inadvertent double
|
2016-10-16 02:02:09 +03:00
|
|
|
// spends across funding transactions.
|
2016-06-21 20:33:14 +03:00
|
|
|
l.coinSelectMtx.Lock()
|
2016-09-13 05:05:56 +03:00
|
|
|
defer l.coinSelectMtx.Unlock()
|
2016-06-21 20:33:14 +03:00
|
|
|
|
2017-11-23 09:30:57 +03:00
|
|
|
walletLog.Infof("Performing funding tx coin selection using %v "+
|
2018-07-28 04:27:51 +03:00
|
|
|
"sat/kw as fee rate", int64(feeRate))
|
2017-05-17 05:00:19 +03:00
|
|
|
|
2018-08-10 05:24:12 +03:00
|
|
|
// Find all unlocked unspent witness outputs that satisfy the minimum
|
|
|
|
// number of confirmations required.
|
2018-10-28 17:55:18 +03:00
|
|
|
coins, err := l.ListUnspentWitness(minConfs, math.MaxInt32)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:36 +03:00
|
|
|
return nil, err
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:37 +03:00
|
|
|
var (
|
|
|
|
selectedCoins []*Utxo
|
|
|
|
fundingAmt btcutil.Amount
|
|
|
|
changeAmt btcutil.Amount
|
|
|
|
)
|
|
|
|
|
2016-10-16 02:02:09 +03:00
|
|
|
// Perform coin selection over our available, unlocked unspent outputs
|
2016-09-13 05:05:56 +03:00
|
|
|
// in order to find enough coins to meet the funding amount
|
|
|
|
// requirements.
|
2019-07-11 14:14:37 +03:00
|
|
|
switch {
|
|
|
|
// In case this request want the fees subtracted from the local amount,
|
|
|
|
// we'll call the specialized method for that. This ensures that we
|
|
|
|
// won't deduct more that the specified balance from our wallet.
|
|
|
|
case subtractFees:
|
|
|
|
dustLimit := l.Cfg.DefaultConstraints.DustLimit
|
|
|
|
selectedCoins, fundingAmt, changeAmt, err = coinSelectSubtractFees(
|
|
|
|
feeRate, amt, dustLimit, coins,
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ótherwise do a normal coin selection where we target a given funding
|
|
|
|
// amount.
|
|
|
|
default:
|
|
|
|
fundingAmt = amt
|
|
|
|
selectedCoins, changeAmt, err = coinSelect(feeRate, amt, coins)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
|
|
|
|
2016-08-13 01:35:33 +03:00
|
|
|
// Record any change output(s) generated as a result of the coin
|
2018-02-01 01:07:42 +03:00
|
|
|
// selection, but only if the addition of the output won't lead to the
|
|
|
|
// creation of dust.
|
2019-07-11 14:14:36 +03:00
|
|
|
var changeOutputs []*wire.TxOut
|
2018-02-01 01:07:42 +03:00
|
|
|
if changeAmt != 0 && changeAmt > DefaultDustLimit() {
|
2016-08-13 01:35:33 +03:00
|
|
|
changeAddr, err := l.NewAddress(WitnessPubKey, true)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:36 +03:00
|
|
|
return nil, err
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
2016-08-13 01:35:33 +03:00
|
|
|
changeScript, err := txscript.PayToAddrScript(changeAddr)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
2019-07-11 14:14:36 +03:00
|
|
|
return nil, err
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
changeOutputs = make([]*wire.TxOut, 1)
|
|
|
|
changeOutputs[0] = &wire.TxOut{
|
2016-08-13 01:35:33 +03:00
|
|
|
Value: int64(changeAmt),
|
|
|
|
PkScript: changeScript,
|
|
|
|
}
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
|
|
|
|
2019-07-11 14:14:36 +03:00
|
|
|
// Lock the selected coins. These coins are now "reserved", this
|
|
|
|
// prevents concurrent funding requests from referring to and this
|
|
|
|
// double-spending the same set of coins.
|
|
|
|
inputs := make([]*wire.TxIn, len(selectedCoins))
|
|
|
|
for i, coin := range selectedCoins {
|
|
|
|
outpoint := &coin.OutPoint
|
|
|
|
l.lockedOutPoints[*outpoint] = struct{}{}
|
|
|
|
l.LockOutpoint(*outpoint)
|
|
|
|
|
|
|
|
// Empty sig script, we'll actually sign if this reservation is
|
|
|
|
// queued up to be completed (the other side accepts).
|
|
|
|
inputs[i] = wire.NewTxIn(outpoint, nil, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock := func() {
|
|
|
|
l.coinSelectMtx.Lock()
|
|
|
|
defer l.coinSelectMtx.Unlock()
|
|
|
|
|
|
|
|
for _, coin := range selectedCoins {
|
|
|
|
outpoint := &coin.OutPoint
|
|
|
|
delete(l.lockedOutPoints, *outpoint)
|
|
|
|
l.UnlockOutpoint(*outpoint)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return &coinSelection{
|
|
|
|
coins: inputs,
|
|
|
|
change: changeOutputs,
|
2019-07-11 14:14:37 +03:00
|
|
|
fundingAmt: fundingAmt,
|
2019-07-11 14:14:36 +03:00
|
|
|
unlockCoins: unlock,
|
|
|
|
}, nil
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
|
|
|
|
2018-01-19 00:45:30 +03:00
|
|
|
// DeriveStateHintObfuscator derives the bytes to be used for obfuscating the
|
2018-02-07 06:11:11 +03:00
|
|
|
// state hints from the root to be used for a new channel. The obfuscator is
|
2017-07-30 04:39:58 +03:00
|
|
|
// generated via the following computation:
|
|
|
|
//
|
2017-09-12 18:38:26 +03:00
|
|
|
// * sha256(initiatorKey || responderKey)[26:]
|
2017-07-30 04:39:58 +03:00
|
|
|
// * where both keys are the multi-sig keys of the respective parties
|
|
|
|
//
|
|
|
|
// The first 6 bytes of the resulting hash are used as the state hint.
|
2018-01-19 00:45:30 +03:00
|
|
|
func DeriveStateHintObfuscator(key1, key2 *btcec.PublicKey) [StateHintSize]byte {
|
2017-07-30 04:39:58 +03:00
|
|
|
h := sha256.New()
|
|
|
|
h.Write(key1.SerializeCompressed())
|
|
|
|
h.Write(key2.SerializeCompressed())
|
2016-11-16 23:54:27 +03:00
|
|
|
|
2017-07-30 04:39:58 +03:00
|
|
|
sha := h.Sum(nil)
|
2016-11-16 23:54:27 +03:00
|
|
|
|
2017-07-30 04:39:58 +03:00
|
|
|
var obfuscator [StateHintSize]byte
|
2017-09-12 18:38:26 +03:00
|
|
|
copy(obfuscator[:], sha[26:])
|
2016-11-16 23:54:27 +03:00
|
|
|
|
2017-07-30 04:39:58 +03:00
|
|
|
return obfuscator
|
2016-11-16 23:54:27 +03:00
|
|
|
}
|
|
|
|
|
2018-02-07 06:11:11 +03:00
|
|
|
// initStateHints properly sets the obfuscated state hints on both commitment
|
2017-09-25 21:25:58 +03:00
|
|
|
// transactions using the passed obfuscator.
|
2016-11-16 23:54:27 +03:00
|
|
|
func initStateHints(commit1, commit2 *wire.MsgTx,
|
2016-12-14 17:01:48 +03:00
|
|
|
obfuscator [StateHintSize]byte) error {
|
2016-11-16 23:54:27 +03:00
|
|
|
|
2016-12-14 17:01:48 +03:00
|
|
|
if err := SetStateNumHint(commit1, 0, obfuscator); err != nil {
|
2016-11-16 23:54:27 +03:00
|
|
|
return err
|
|
|
|
}
|
2016-12-14 17:01:48 +03:00
|
|
|
if err := SetStateNumHint(commit2, 0, obfuscator); err != nil {
|
2016-11-16 23:54:27 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:35:33 +03:00
|
|
|
// selectInputs selects a slice of inputs necessary to meet the specified
|
2018-04-18 05:03:27 +03:00
|
|
|
// selection amount. If input selection is unable to succeed due to insufficient
|
2016-08-13 01:35:33 +03:00
|
|
|
// funds, a non-nil error is returned. Additionally, the total amount of the
|
|
|
|
// selected coins are returned in order for the caller to properly handle
|
|
|
|
// change+fees.
|
2017-10-03 06:14:36 +03:00
|
|
|
func selectInputs(amt btcutil.Amount, coins []*Utxo) (btcutil.Amount, []*Utxo, error) {
|
|
|
|
satSelected := btcutil.Amount(0)
|
|
|
|
for i, coin := range coins {
|
2016-08-13 01:35:33 +03:00
|
|
|
satSelected += coin.Value
|
2017-10-03 06:14:36 +03:00
|
|
|
if satSelected >= amt {
|
|
|
|
return satSelected, coins[:i+1], nil
|
|
|
|
}
|
2016-08-13 01:35:33 +03:00
|
|
|
}
|
2017-10-03 06:14:36 +03:00
|
|
|
return 0, nil, &ErrInsufficientFunds{amt, satSelected}
|
2016-03-24 10:01:35 +03:00
|
|
|
}
|
|
|
|
|
2017-07-30 04:39:58 +03:00
|
|
|
// coinSelect attempts to select a sufficient amount of coins, including a
|
|
|
|
// change output to fund amt satoshis, adhering to the specified fee rate. The
|
2018-07-28 04:27:51 +03:00
|
|
|
// specified fee rate should be expressed in sat/kw for coin selection to
|
2016-08-13 01:35:33 +03:00
|
|
|
// function properly.
|
2019-10-31 05:43:05 +03:00
|
|
|
func coinSelect(feeRate chainfee.SatPerKWeight, amt btcutil.Amount,
|
2017-10-03 06:14:36 +03:00
|
|
|
coins []*Utxo) ([]*Utxo, btcutil.Amount, error) {
|
2016-08-13 01:35:33 +03:00
|
|
|
|
|
|
|
amtNeeded := amt
|
|
|
|
for {
|
|
|
|
// First perform an initial round of coin selection to estimate
|
|
|
|
// the required fee.
|
|
|
|
totalSat, selectedUtxos, err := selectInputs(amtNeeded, coins)
|
|
|
|
if err != nil {
|
|
|
|
return nil, 0, err
|
|
|
|
}
|
|
|
|
|
2019-01-16 17:47:43 +03:00
|
|
|
var weightEstimate input.TxWeightEstimator
|
2017-09-26 04:45:46 +03:00
|
|
|
|
2017-10-03 06:14:36 +03:00
|
|
|
for _, utxo := range selectedUtxos {
|
|
|
|
switch utxo.AddressType {
|
|
|
|
case WitnessPubKey:
|
|
|
|
weightEstimate.AddP2WKHInput()
|
|
|
|
case NestedWitnessPubKey:
|
|
|
|
weightEstimate.AddNestedP2WKHInput()
|
|
|
|
default:
|
2019-07-11 14:14:37 +03:00
|
|
|
return nil, 0, fmt.Errorf("unsupported address type: %v",
|
2017-10-03 06:14:36 +03:00
|
|
|
utxo.AddressType)
|
|
|
|
}
|
2017-09-26 04:45:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Channel funding multisig output is P2WSH.
|
|
|
|
weightEstimate.AddP2WSHOutput()
|
|
|
|
|
|
|
|
// Assume that change output is a P2WKH output.
|
2018-02-18 02:24:43 +03:00
|
|
|
//
|
|
|
|
// TODO: Handle wallets that generate non-witness change
|
|
|
|
// addresses.
|
2019-07-11 14:14:36 +03:00
|
|
|
// TODO(halseth): make coinSelect not estimate change output
|
|
|
|
// for dust change.
|
2017-09-26 04:45:46 +03:00
|
|
|
weightEstimate.AddP2WKHOutput()
|
2016-08-13 01:35:33 +03:00
|
|
|
|
2017-06-09 08:24:10 +03:00
|
|
|
// The difference between the selected amount and the amount
|
2016-08-13 01:35:33 +03:00
|
|
|
// requested will be used to pay fees, and generate a change
|
|
|
|
// output with the remaining.
|
2017-11-18 00:15:50 +03:00
|
|
|
overShootAmt := totalSat - amt
|
2016-08-13 01:35:33 +03:00
|
|
|
|
|
|
|
// Based on the estimated size and fee rate, if the excess
|
|
|
|
// amount isn't enough to pay fees, then increase the requested
|
|
|
|
// coin amount by the estimate required fee, performing another
|
|
|
|
// round of coin selection.
|
2018-07-28 04:27:51 +03:00
|
|
|
totalWeight := int64(weightEstimate.Weight())
|
|
|
|
requiredFee := feeRate.FeeForWeight(totalWeight)
|
2016-08-13 01:35:33 +03:00
|
|
|
if overShootAmt < requiredFee {
|
2017-09-26 04:45:46 +03:00
|
|
|
amtNeeded = amt + requiredFee
|
2016-08-13 01:35:33 +03:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2017-06-09 08:24:10 +03:00
|
|
|
// If the fee is sufficient, then calculate the size of the
|
|
|
|
// change output.
|
2016-08-13 01:35:33 +03:00
|
|
|
changeAmt := overShootAmt - requiredFee
|
|
|
|
|
|
|
|
return selectedUtxos, changeAmt, nil
|
|
|
|
}
|
2016-03-24 10:01:35 +03:00
|
|
|
}
|
2019-07-11 14:14:37 +03:00
|
|
|
|
|
|
|
// coinSelectSubtractFees attempts to select coins such that we'll spend up to
|
|
|
|
// amt in total after fees, adhering to the specified fee rate. The selected
|
|
|
|
// coins, the final output and change values are returned.
|
2019-10-31 05:43:05 +03:00
|
|
|
func coinSelectSubtractFees(feeRate chainfee.SatPerKWeight, amt,
|
2019-07-11 14:14:37 +03:00
|
|
|
dustLimit btcutil.Amount, coins []*Utxo) ([]*Utxo, btcutil.Amount,
|
|
|
|
btcutil.Amount, error) {
|
|
|
|
|
|
|
|
// First perform an initial round of coin selection to estimate
|
|
|
|
// the required fee.
|
|
|
|
totalSat, selectedUtxos, err := selectInputs(amt, coins)
|
|
|
|
if err != nil {
|
|
|
|
return nil, 0, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
var weightEstimate input.TxWeightEstimator
|
|
|
|
for _, utxo := range selectedUtxos {
|
|
|
|
switch utxo.AddressType {
|
|
|
|
case WitnessPubKey:
|
|
|
|
weightEstimate.AddP2WKHInput()
|
|
|
|
case NestedWitnessPubKey:
|
|
|
|
weightEstimate.AddNestedP2WKHInput()
|
|
|
|
default:
|
|
|
|
return nil, 0, 0, fmt.Errorf("unsupported "+
|
|
|
|
"address type: %v", utxo.AddressType)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Channel funding multisig output is P2WSH.
|
|
|
|
weightEstimate.AddP2WSHOutput()
|
|
|
|
|
|
|
|
// At this point we've got two possibilities, either create a
|
|
|
|
// change output, or not. We'll first try without creating a
|
|
|
|
// change output.
|
|
|
|
//
|
|
|
|
// Estimate the fee required for a transaction without a change
|
|
|
|
// output.
|
|
|
|
totalWeight := int64(weightEstimate.Weight())
|
|
|
|
requiredFee := feeRate.FeeForWeight(totalWeight)
|
|
|
|
|
|
|
|
// For a transaction without a change output, we'll let everything go
|
|
|
|
// to our multi-sig output after subtracting fees.
|
|
|
|
outputAmt := totalSat - requiredFee
|
|
|
|
changeAmt := btcutil.Amount(0)
|
|
|
|
|
|
|
|
// If the the output is too small after subtracting the fee, the coin
|
|
|
|
// selection cannot be performed with an amount this small.
|
|
|
|
if outputAmt <= dustLimit {
|
|
|
|
return nil, 0, 0, fmt.Errorf("output amount(%v) after "+
|
|
|
|
"subtracting fees(%v) below dust limit(%v)", outputAmt,
|
|
|
|
requiredFee, dustLimit)
|
|
|
|
}
|
|
|
|
|
|
|
|
// We were able to create a transaction with no change from the
|
|
|
|
// selected inputs. We'll remember the resulting values for
|
|
|
|
// now, while we try to add a change output. Assume that change output
|
|
|
|
// is a P2WKH output.
|
|
|
|
weightEstimate.AddP2WKHOutput()
|
|
|
|
|
|
|
|
// Now that we have added the change output, redo the fee
|
|
|
|
// estimate.
|
|
|
|
totalWeight = int64(weightEstimate.Weight())
|
|
|
|
requiredFee = feeRate.FeeForWeight(totalWeight)
|
|
|
|
|
|
|
|
// For a transaction with a change output, everything we don't spend
|
|
|
|
// will go to change.
|
|
|
|
newChange := totalSat - amt
|
|
|
|
newOutput := amt - requiredFee
|
|
|
|
|
|
|
|
// If adding a change output leads to both outputs being above
|
|
|
|
// the dust limit, we'll add the change output. Otherwise we'll
|
|
|
|
// go with the no change tx we originally found.
|
|
|
|
if newChange > dustLimit && newOutput > dustLimit {
|
|
|
|
outputAmt = newOutput
|
|
|
|
changeAmt = newChange
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sanity check the resulting output values to make sure we
|
|
|
|
// don't burn a great part to fees.
|
|
|
|
totalOut := outputAmt + changeAmt
|
|
|
|
fee := totalSat - totalOut
|
|
|
|
|
|
|
|
// Fail if more than 20% goes to fees.
|
|
|
|
// TODO(halseth): smarter fee limit. Make configurable or dynamic wrt
|
|
|
|
// total funding size?
|
|
|
|
if fee > totalOut/5 {
|
|
|
|
return nil, 0, 0, fmt.Errorf("fee %v on total output"+
|
|
|
|
"value %v", fee, totalOut)
|
|
|
|
}
|
|
|
|
|
|
|
|
return selectedUtxos, outputAmt, changeAmt, nil
|
|
|
|
}
|
2019-10-01 05:59:10 +03:00
|
|
|
|
|
|
|
// ValidateChannel will attempt to fully validate a newly mined channel, given
|
|
|
|
// its funding transaction and existing channel state. If this method returns
|
|
|
|
// an error, then the mined channel is invalid, and shouldn't be used.
|
|
|
|
func (l *LightningWallet) ValidateChannel(channelState *channeldb.OpenChannel,
|
|
|
|
fundingTx *wire.MsgTx) error {
|
|
|
|
|
|
|
|
// First, we'll obtain a fully signed commitment transaction so we can
|
|
|
|
// pass into it on the chanvalidate package for verification.
|
|
|
|
channel, err := NewLightningChannel(l.Cfg.Signer, channelState, nil)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
signedCommitTx, err := channel.getSignedCommitTx()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// We'll also need the multi-sig witness script itself so the
|
|
|
|
// chanvalidate package can check it for correctness against the
|
|
|
|
// funding transaction, and also commitment validity.
|
|
|
|
localKey := channelState.LocalChanCfg.MultiSigKey.PubKey
|
|
|
|
remoteKey := channelState.RemoteChanCfg.MultiSigKey.PubKey
|
|
|
|
witnessScript, err := input.GenMultiSigScript(
|
|
|
|
localKey.SerializeCompressed(),
|
|
|
|
remoteKey.SerializeCompressed(),
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
pkScript, err := input.WitnessScriptHash(witnessScript)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, we'll pass in all the necessary context needed to fully
|
|
|
|
// validate that this channel is indeed what we expect, and can be
|
|
|
|
// used.
|
|
|
|
_, err = chanvalidate.Validate(&chanvalidate.Context{
|
|
|
|
Locator: &chanvalidate.OutPointChanLocator{
|
|
|
|
ChanPoint: channelState.FundingOutpoint,
|
|
|
|
},
|
|
|
|
MultiSigPkScript: pkScript,
|
|
|
|
FundingTx: fundingTx,
|
|
|
|
CommitCtx: &chanvalidate.CommitmentContext{
|
|
|
|
Value: channel.Capacity,
|
|
|
|
FullySignedCommitTx: signedCommitTx,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|