2015-12-19 22:00:50 -08:00
|
|
|
package lnwallet
|
2015-11-12 18:43:32 -08:00
|
|
|
|
|
|
|
import (
|
2016-10-26 14:56:48 -07:00
|
|
|
"net"
|
2015-11-14 11:52:07 -08:00
|
|
|
"sync"
|
|
|
|
|
2016-01-16 10:45:54 -08:00
|
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
2016-05-15 07:17:44 -07:00
|
|
|
"github.com/roasbeef/btcd/btcec"
|
2017-07-29 18:58:55 -07:00
|
|
|
"github.com/roasbeef/btcd/chaincfg/chainhash"
|
2016-05-15 07:17:44 -07:00
|
|
|
"github.com/roasbeef/btcd/wire"
|
|
|
|
"github.com/roasbeef/btcutil"
|
2015-11-12 18:43:32 -08:00
|
|
|
)
|
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// ChannelContribution is the primary constituent of the funding workflow
|
|
|
|
// within lnwallet. Each side first exchanges their respective contributions
|
|
|
|
// along with channel specific parameters like the min fee/KB. Once
|
|
|
|
// contributions have been exchanged, each side will then produce signatures
|
|
|
|
// for all their inputs to the funding transactions, and finally a signature
|
|
|
|
// for the other party's version of the commitment transaction.
|
2015-12-22 20:30:11 -08:00
|
|
|
type ChannelContribution struct {
|
2016-06-30 12:02:45 -07:00
|
|
|
// FundingOutpoint is the amount of funds contributed to the funding
|
|
|
|
// transaction.
|
2015-12-22 20:30:11 -08:00
|
|
|
FundingAmount btcutil.Amount
|
2015-12-18 11:29:35 -08:00
|
|
|
|
2015-12-22 20:30:11 -08:00
|
|
|
// Inputs to the funding transaction.
|
|
|
|
Inputs []*wire.TxIn
|
|
|
|
|
2016-06-30 12:02:45 -07:00
|
|
|
// ChangeOutputs are the Outputs to be used in the case that the total
|
2016-10-15 16:02:09 -07:00
|
|
|
// value of the funding inputs is greater than the total potential
|
2016-06-30 12:02:45 -07:00
|
|
|
// channel capacity.
|
2015-12-22 20:30:11 -08:00
|
|
|
ChangeOutputs []*wire.TxOut
|
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// FirstCommitmentPoint is the first commitment point that will be used
|
|
|
|
// to create the revocation key in the first commitment transaction we
|
|
|
|
// send to the remote party.
|
|
|
|
FirstCommitmentPoint *btcec.PublicKey
|
2015-11-14 11:52:07 -08:00
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// ChannelConfig is the concrete contribution that this node is
|
|
|
|
// offering to the channel. This includes all the various constraints
|
|
|
|
// such as the min HTLC, and also all the keys which will be used for
|
|
|
|
// the duration of the channel.
|
|
|
|
*channeldb.ChannelConfig
|
|
|
|
}
|
2017-04-12 19:20:36 -07:00
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// toChanConfig returns the raw channel configuration generated by a node's
|
|
|
|
// contribution to the channel.
|
|
|
|
func (c *ChannelContribution) toChanConfig() channeldb.ChannelConfig {
|
|
|
|
return *c.ChannelConfig
|
2015-12-22 20:30:11 -08:00
|
|
|
}
|
|
|
|
|
2017-02-23 11:56:47 -08:00
|
|
|
// InputScript represents any script inputs required to redeem a previous
|
2016-05-03 19:46:53 -07:00
|
|
|
// output. This struct is used rather than just a witness, or scripSig in
|
2016-10-15 16:02:09 -07:00
|
|
|
// order to accommodate nested p2sh which utilizes both types of input scripts.
|
2016-05-03 19:46:53 -07:00
|
|
|
type InputScript struct {
|
|
|
|
Witness [][]byte
|
|
|
|
ScriptSig []byte
|
|
|
|
}
|
|
|
|
|
2016-01-02 12:09:31 -08:00
|
|
|
// ChannelReservation represents an intent to open a lightning payment channel
|
2017-07-29 18:58:55 -07:00
|
|
|
// a counterparty. The funding processes from reservation to channel opening is
|
|
|
|
// a 3-step process. In order to allow for full concurrency during the
|
2016-10-15 16:02:09 -07:00
|
|
|
// reservation workflow, resources consumed by a contribution are "locked"
|
|
|
|
// themselves. This prevents a number of race conditions such as two funding
|
|
|
|
// transactions double-spending the same input. A reservation can also be
|
|
|
|
// cancelled, which removes the resources from limbo, allowing another
|
|
|
|
// reservation to claim them.
|
2016-01-02 12:09:31 -08:00
|
|
|
//
|
|
|
|
// The reservation workflow consists of the following three steps:
|
|
|
|
// 1. lnwallet.InitChannelReservation
|
2016-10-15 16:02:09 -07:00
|
|
|
// * One requests the wallet to allocate the necessary resources for a
|
2016-01-02 12:09:31 -08:00
|
|
|
// channel reservation. These resources a put in limbo for the lifetime
|
|
|
|
// of a reservation.
|
|
|
|
// * Once completed the reservation will have the wallet's contribution
|
|
|
|
// accessible via the .OurContribution() method. This contribution
|
2016-10-15 16:02:09 -07:00
|
|
|
// contains the necessary items to allow the remote party to build both
|
2016-01-02 12:09:31 -08:00
|
|
|
// the funding, and commitment transactions.
|
2016-06-20 22:31:57 -07:00
|
|
|
// 2. ChannelReservation.ProcessContribution/ChannelReservation.ProcessSingleContribution
|
2016-01-02 12:09:31 -08:00
|
|
|
// * The counterparty presents their contribution to the payment channel.
|
|
|
|
// This allows us to build the funding, and commitment transactions
|
|
|
|
// ourselves.
|
|
|
|
// * We're now able to sign our inputs to the funding transactions, and
|
|
|
|
// the counterparty's version of the commitment transaction.
|
|
|
|
// * All signatures crafted by us, are now available via .OurSignatures().
|
2016-06-20 22:31:57 -07:00
|
|
|
// 3. ChannelReservation.CompleteReservation/ChannelReservation.CompleteReservationSingle
|
2016-01-02 12:09:31 -08:00
|
|
|
// * The final step in the workflow. The counterparty presents the
|
2016-10-15 16:02:09 -07:00
|
|
|
// signatures for all their inputs to the funding transaction, as well
|
2016-01-02 12:09:31 -08:00
|
|
|
// as a signature to our version of the commitment transaction.
|
|
|
|
// * We then verify the validity of all signatures before considering the
|
|
|
|
// channel "open".
|
2015-12-22 20:30:11 -08:00
|
|
|
type ChannelReservation struct {
|
|
|
|
// This mutex MUST be held when either reading or modifying any of the
|
|
|
|
// fields below.
|
|
|
|
sync.RWMutex
|
2015-11-12 18:43:32 -08:00
|
|
|
|
2016-06-20 22:31:57 -07:00
|
|
|
// fundingTx is the funding transaction for this pending channel.
|
|
|
|
fundingTx *wire.MsgTx
|
|
|
|
|
2015-11-12 18:43:32 -08:00
|
|
|
// In order of sorted inputs. Sorting is done in accordance
|
|
|
|
// to BIP-69: https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki.
|
2016-05-03 19:46:53 -07:00
|
|
|
ourFundingInputScripts []*InputScript
|
|
|
|
theirFundingInputScripts []*InputScript
|
2015-11-12 18:43:32 -08:00
|
|
|
|
2015-12-22 20:30:11 -08:00
|
|
|
// Our signature for their version of the commitment transaction.
|
2015-12-28 21:38:50 -08:00
|
|
|
ourCommitmentSig []byte
|
|
|
|
theirCommitmentSig []byte
|
2015-11-12 18:43:32 -08:00
|
|
|
|
2015-12-22 20:30:11 -08:00
|
|
|
ourContribution *ChannelContribution
|
|
|
|
theirContribution *ChannelContribution
|
|
|
|
|
2015-12-26 10:35:15 -08:00
|
|
|
partialState *channeldb.OpenChannel
|
2016-10-26 14:56:48 -07:00
|
|
|
nodeAddr *net.TCPAddr
|
2015-11-12 18:43:32 -08:00
|
|
|
|
2015-12-22 20:30:11 -08:00
|
|
|
// The ID of this reservation, used to uniquely track the reservation
|
|
|
|
// throughout its lifetime.
|
2015-11-12 18:43:32 -08:00
|
|
|
reservationID uint64
|
2015-12-15 13:22:18 -08:00
|
|
|
|
2017-01-09 17:24:13 -08:00
|
|
|
// pushSat the amount of satoshis that should be pushed to the
|
|
|
|
// responder of a single funding channel as part of the initial
|
|
|
|
// commitment state.
|
|
|
|
pushSat btcutil.Amount
|
|
|
|
|
2016-12-24 16:47:09 -08:00
|
|
|
// chanOpen houses a struct containing the channel and additional
|
|
|
|
// confirmation details will be sent on once the channel is considered
|
|
|
|
// 'open'. A channel is open once the funding transaction has reached a
|
|
|
|
// sufficient number of confirmations.
|
2017-01-22 15:06:28 -08:00
|
|
|
chanOpen chan *openChanDetails
|
|
|
|
chanOpenErr chan error
|
2015-12-22 20:30:11 -08:00
|
|
|
|
|
|
|
wallet *LightningWallet
|
2015-11-12 18:43:32 -08:00
|
|
|
}
|
|
|
|
|
2016-08-12 15:50:47 -07:00
|
|
|
// NewChannelReservation creates a new channel reservation. This function is
|
2017-01-09 17:24:13 -08:00
|
|
|
// used only internally by lnwallet. In order to concurrent safety, the
|
|
|
|
// creation of all channel reservations should be carried out via the
|
2016-01-02 12:09:31 -08:00
|
|
|
// lnwallet.InitChannelReservation interface.
|
2017-07-29 18:58:55 -07:00
|
|
|
func NewChannelReservation(capacity, fundingAmt, feePerKw btcutil.Amount,
|
|
|
|
wallet *LightningWallet, id uint64, pushSat btcutil.Amount,
|
|
|
|
chainHash *chainhash.Hash) *ChannelReservation {
|
2016-11-16 12:51:18 -08:00
|
|
|
|
|
|
|
var (
|
|
|
|
ourBalance btcutil.Amount
|
|
|
|
theirBalance btcutil.Amount
|
2017-01-16 20:28:30 -08:00
|
|
|
initiator bool
|
2016-11-16 12:51:18 -08:00
|
|
|
)
|
2016-06-20 22:31:57 -07:00
|
|
|
|
2017-05-16 18:55:22 -07:00
|
|
|
commitFee := (feePerKw * commitWeight) / 1000
|
2017-05-01 11:45:02 -07:00
|
|
|
|
2016-10-23 18:42:03 -07:00
|
|
|
// If we're the responder to a single-funder reservation, then we have
|
2017-01-09 17:24:13 -08:00
|
|
|
// no initial balance in the channel unless the remote party is pushing
|
|
|
|
// some funds to us within the first commitment state.
|
2016-06-20 22:31:57 -07:00
|
|
|
if fundingAmt == 0 {
|
2017-01-09 17:24:13 -08:00
|
|
|
ourBalance = pushSat
|
|
|
|
theirBalance = capacity - commitFee - pushSat
|
2017-01-16 20:28:30 -08:00
|
|
|
initiator = false
|
2016-06-20 22:31:57 -07:00
|
|
|
} else {
|
2016-09-12 19:05:56 -07:00
|
|
|
// TODO(roasbeef): need to rework fee structure in general and
|
|
|
|
// also when we "unlock" dual funder within the daemon
|
2016-10-23 18:42:03 -07:00
|
|
|
|
2017-05-01 11:45:02 -07:00
|
|
|
if capacity == fundingAmt {
|
2016-11-16 12:51:18 -08:00
|
|
|
// If we're initiating a single funder workflow, then
|
|
|
|
// we pay all the initial fees within the commitment
|
2017-01-09 17:24:13 -08:00
|
|
|
// transaction. We also deduct our balance by the
|
|
|
|
// amount pushed as part of the initial state.
|
|
|
|
ourBalance = capacity - commitFee - pushSat
|
2017-05-16 18:52:33 -07:00
|
|
|
theirBalance = pushSat
|
2016-09-12 19:05:56 -07:00
|
|
|
} else {
|
2016-11-16 12:51:18 -08:00
|
|
|
// Otherwise, this is a dual funder workflow where both
|
|
|
|
// slides split the amount funded and the commitment
|
|
|
|
// fee.
|
2017-05-01 11:45:02 -07:00
|
|
|
ourBalance = fundingAmt - (commitFee / 2)
|
|
|
|
theirBalance = capacity - fundingAmt -
|
|
|
|
(commitFee / 2) + pushSat
|
2016-09-12 19:05:56 -07:00
|
|
|
}
|
2016-10-23 18:42:03 -07:00
|
|
|
|
2017-01-16 20:28:30 -08:00
|
|
|
initiator = true
|
2016-06-20 22:31:57 -07:00
|
|
|
}
|
|
|
|
|
2017-01-16 20:28:30 -08:00
|
|
|
// Next we'll set the channel type based on what we can ascertain about
|
|
|
|
// the balances/push amount within the channel.
|
|
|
|
var chanType channeldb.ChannelType
|
2016-11-16 12:51:18 -08:00
|
|
|
|
2017-01-16 20:28:30 -08:00
|
|
|
// If either of the balances are zero at this point, or we have a
|
|
|
|
// non-zero push amt (there's no pushing for dual funder), then this is
|
|
|
|
// a single-funder channel.
|
|
|
|
if ourBalance == 0 || theirBalance == 0 || pushSat != 0 {
|
2016-11-16 12:51:18 -08:00
|
|
|
chanType = channeldb.SingleFunder
|
2017-01-16 20:28:30 -08:00
|
|
|
} else {
|
|
|
|
// Otherwise, this is a dual funder channel, and no side is
|
|
|
|
// technically the "initiator"
|
2016-11-16 12:51:18 -08:00
|
|
|
initiator = false
|
|
|
|
chanType = channeldb.DualFunder
|
|
|
|
}
|
|
|
|
|
2015-12-18 19:42:49 -08:00
|
|
|
return &ChannelReservation{
|
2015-12-22 20:30:11 -08:00
|
|
|
ourContribution: &ChannelContribution{
|
2016-06-20 22:31:57 -07:00
|
|
|
FundingAmount: ourBalance,
|
2017-07-29 18:58:55 -07:00
|
|
|
ChannelConfig: &channeldb.ChannelConfig{},
|
2015-12-22 20:30:11 -08:00
|
|
|
},
|
|
|
|
theirContribution: &ChannelContribution{
|
2016-06-20 22:31:57 -07:00
|
|
|
FundingAmount: theirBalance,
|
2017-07-29 18:58:55 -07:00
|
|
|
ChannelConfig: &channeldb.ChannelConfig{},
|
2015-12-22 20:30:11 -08:00
|
|
|
},
|
2015-12-26 10:35:15 -08:00
|
|
|
partialState: &channeldb.OpenChannel{
|
2017-07-29 18:58:55 -07:00
|
|
|
ChainHash: *chainHash,
|
|
|
|
Db: wallet.Cfg.Database,
|
|
|
|
Capacity: capacity,
|
|
|
|
IsInitiator: initiator,
|
|
|
|
IsPending: true,
|
|
|
|
ChanType: chanType,
|
|
|
|
LocalBalance: ourBalance,
|
|
|
|
RemoteBalance: theirBalance,
|
|
|
|
FeePerKw: feePerKw,
|
|
|
|
CommitFee: commitFee,
|
2015-12-18 19:42:49 -08:00
|
|
|
},
|
2017-07-29 18:58:55 -07:00
|
|
|
pushSat: pushSat,
|
|
|
|
reservationID: id,
|
|
|
|
chanOpen: make(chan *openChanDetails, 1),
|
|
|
|
chanOpenErr: make(chan error, 1),
|
|
|
|
wallet: wallet,
|
2015-12-22 20:30:11 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// SetNumConfsRequired sets the number of confirmations that are required for
|
|
|
|
// the ultimate funding transaction before the channel can be considered open.
|
|
|
|
// This is distinct from the main reservation workflow as it allows
|
|
|
|
// implementations a bit more flexibility w.r.t to if the responder of the
|
|
|
|
// initiator sets decides the number of confirmations needed.
|
|
|
|
func (r *ChannelReservation) SetNumConfsRequired(numConfs uint16) {
|
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
|
|
|
|
|
|
|
r.partialState.NumConfsRequired = numConfs
|
|
|
|
}
|
|
|
|
|
|
|
|
// RequireLocalDelay sets the mandatory CSV delay that MUST be used when
|
|
|
|
// creating the local commitment transaction. This is distinct from the normal
|
|
|
|
// reservation workflow as the remote party will dictate this value for us.
|
|
|
|
//
|
|
|
|
// TODO(roasbeef): abstract out dictation of params remote side gives
|
|
|
|
func (r *ChannelReservation) RequireLocalDelay(csvDelay uint16) {
|
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
|
|
|
|
|
|
|
r.ourContribution.ChannelConfig.CsvDelay = csvDelay
|
|
|
|
}
|
|
|
|
|
2016-01-02 12:09:31 -08:00
|
|
|
// OurContribution returns the wallet's fully populated contribution to the
|
|
|
|
// pending payment channel. See 'ChannelContribution' for further details
|
|
|
|
// regarding the contents of a contribution.
|
2017-07-29 18:58:55 -07:00
|
|
|
//
|
2015-12-22 20:30:11 -08:00
|
|
|
// NOTE: This SHOULD NOT be modified.
|
2016-01-02 12:09:31 -08:00
|
|
|
// TODO(roasbeef): make copy?
|
2015-12-22 20:30:11 -08:00
|
|
|
func (r *ChannelReservation) OurContribution() *ChannelContribution {
|
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
2017-07-29 18:58:55 -07:00
|
|
|
|
2015-12-22 20:30:11 -08:00
|
|
|
return r.ourContribution
|
|
|
|
}
|
|
|
|
|
2016-11-24 00:49:18 -08:00
|
|
|
// ProcessContribution verifies the counterparty's contribution to the pending
|
2016-01-02 12:09:31 -08:00
|
|
|
// payment channel. As a result of this incoming message, lnwallet is able to
|
|
|
|
// build the funding transaction, and both commitment transactions. Once this
|
|
|
|
// message has been processed, all signatures to inputs to the funding
|
|
|
|
// transaction belonging to the wallet are available. Additionally, the wallet
|
|
|
|
// will generate a signature to the counterparty's version of the commitment
|
|
|
|
// transaction.
|
2015-12-22 20:30:11 -08:00
|
|
|
func (r *ChannelReservation) ProcessContribution(theirContribution *ChannelContribution) error {
|
|
|
|
errChan := make(chan error, 1)
|
|
|
|
|
|
|
|
r.wallet.msgChan <- &addContributionMsg{
|
|
|
|
pendingFundingID: r.reservationID,
|
|
|
|
contribution: theirContribution,
|
|
|
|
err: errChan,
|
|
|
|
}
|
|
|
|
|
|
|
|
return <-errChan
|
|
|
|
}
|
|
|
|
|
2016-06-20 22:31:57 -07:00
|
|
|
// ProcessSingleContribution verifies, and records the initiator's contribution
|
|
|
|
// to this pending single funder channel. Internally, no further action is
|
|
|
|
// taken other than recording the initiator's contribution to the single funder
|
|
|
|
// channel.
|
|
|
|
func (r *ChannelReservation) ProcessSingleContribution(theirContribution *ChannelContribution) error {
|
|
|
|
errChan := make(chan error, 1)
|
|
|
|
|
|
|
|
r.wallet.msgChan <- &addSingleContributionMsg{
|
|
|
|
pendingFundingID: r.reservationID,
|
|
|
|
contribution: theirContribution,
|
|
|
|
err: errChan,
|
|
|
|
}
|
|
|
|
|
|
|
|
return <-errChan
|
|
|
|
}
|
|
|
|
|
2016-01-02 12:09:31 -08:00
|
|
|
// TheirContribution returns the counterparty's pending contribution to the
|
2017-07-29 18:58:55 -07:00
|
|
|
// payment channel. See 'ChannelContribution' for further details regarding the
|
|
|
|
// contents of a contribution. This attribute will ONLY be available after a
|
|
|
|
// call to .ProcesContribution().
|
|
|
|
//
|
2016-01-02 12:09:31 -08:00
|
|
|
// NOTE: This SHOULD NOT be modified.
|
2015-12-22 20:30:11 -08:00
|
|
|
func (r *ChannelReservation) TheirContribution() *ChannelContribution {
|
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
|
|
|
return r.theirContribution
|
|
|
|
}
|
|
|
|
|
2016-01-02 12:09:31 -08:00
|
|
|
// OurSignatures retrieves the wallet's signatures to all inputs to the funding
|
|
|
|
// transaction belonging to itself, and also a signature for the counterparty's
|
|
|
|
// version of the commitment transaction. The signatures for the wallet's
|
|
|
|
// inputs to the funding transaction are returned in sorted order according to
|
|
|
|
// BIP-69: https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki.
|
2017-07-29 18:58:55 -07:00
|
|
|
//
|
2016-01-02 12:09:31 -08:00
|
|
|
// NOTE: These signatures will only be populated after a call to
|
|
|
|
// .ProcesContribution()
|
2016-05-03 19:46:53 -07:00
|
|
|
func (r *ChannelReservation) OurSignatures() ([]*InputScript, []byte) {
|
2015-12-22 20:30:11 -08:00
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
2016-05-03 19:46:53 -07:00
|
|
|
return r.ourFundingInputScripts, r.ourCommitmentSig
|
2015-12-22 20:30:11 -08:00
|
|
|
}
|
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// CompleteReservation finalizes the pending channel reservation, transitioning
|
|
|
|
// from a pending payment channel, to an open payment channel. All passed
|
|
|
|
// signatures to the counterparty's inputs to the funding transaction will be
|
|
|
|
// fully verified. Signatures are expected to be passed in sorted order
|
|
|
|
// according to BIP-69:
|
|
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki.
|
|
|
|
// Additionally, verification is performed in order to ensure that the
|
|
|
|
// counterparty supplied a valid signature to our version of the commitment
|
|
|
|
// transaction. Once this method returns, caller's should then call
|
|
|
|
// .WaitForChannelOpen() which will block until the funding transaction obtains
|
|
|
|
// the configured number of confirmations. Once the method unblocks, a
|
|
|
|
// LightningChannel instance is returned, marking the channel available for
|
|
|
|
// updates.
|
2016-05-03 19:46:53 -07:00
|
|
|
func (r *ChannelReservation) CompleteReservation(fundingInputScripts []*InputScript,
|
2017-01-23 18:19:54 -08:00
|
|
|
commitmentSig []byte) (*channeldb.OpenChannel, error) {
|
2015-12-28 21:58:06 -08:00
|
|
|
|
2016-06-20 22:31:57 -07:00
|
|
|
// TODO(roasbeef): add flag for watch or not?
|
2015-12-22 20:30:11 -08:00
|
|
|
errChan := make(chan error, 1)
|
2017-01-23 18:19:54 -08:00
|
|
|
completeChan := make(chan *channeldb.OpenChannel, 1)
|
2015-12-22 20:30:11 -08:00
|
|
|
|
|
|
|
r.wallet.msgChan <- &addCounterPartySigsMsg{
|
2016-05-03 19:46:53 -07:00
|
|
|
pendingFundingID: r.reservationID,
|
|
|
|
theirFundingInputScripts: fundingInputScripts,
|
|
|
|
theirCommitmentSig: commitmentSig,
|
2017-01-23 18:19:54 -08:00
|
|
|
completeChan: completeChan,
|
2016-05-03 19:46:53 -07:00
|
|
|
err: errChan,
|
2015-12-18 19:42:49 -08:00
|
|
|
}
|
2015-12-22 20:30:11 -08:00
|
|
|
|
2017-01-23 18:19:54 -08:00
|
|
|
return <-completeChan, <-errChan
|
2015-12-22 20:30:11 -08:00
|
|
|
}
|
|
|
|
|
2016-06-20 22:31:57 -07:00
|
|
|
// CompleteReservationSingle finalizes the pending single funder channel
|
2017-07-29 18:58:55 -07:00
|
|
|
// reservation. Using the funding outpoint of the constructed funding
|
|
|
|
// transaction, and the initiator's signature for our version of the commitment
|
|
|
|
// transaction, we are able to verify the correctness of our commitment
|
|
|
|
// transaction as crafted by the initiator. Once this method returns, our
|
|
|
|
// signature for the initiator's version of the commitment transaction is
|
|
|
|
// available via the .OurSignatures() method. As this method should only be
|
|
|
|
// called as a response to a single funder channel, only a commitment signature
|
|
|
|
// will be populated.
|
|
|
|
func (r *ChannelReservation) CompleteReservationSingle(fundingPoint *wire.OutPoint,
|
|
|
|
commitSig []byte) (*channeldb.OpenChannel, error) {
|
2016-11-16 12:54:27 -08:00
|
|
|
|
2016-06-20 22:31:57 -07:00
|
|
|
errChan := make(chan error, 1)
|
2017-01-23 18:19:54 -08:00
|
|
|
completeChan := make(chan *channeldb.OpenChannel, 1)
|
2016-06-20 22:31:57 -07:00
|
|
|
|
|
|
|
r.wallet.msgChan <- &addSingleFunderSigsMsg{
|
|
|
|
pendingFundingID: r.reservationID,
|
|
|
|
fundingOutpoint: fundingPoint,
|
|
|
|
theirCommitmentSig: commitSig,
|
2017-01-23 18:19:54 -08:00
|
|
|
completeChan: completeChan,
|
2016-06-20 22:31:57 -07:00
|
|
|
err: errChan,
|
|
|
|
}
|
|
|
|
|
2017-01-23 18:19:54 -08:00
|
|
|
return <-completeChan, <-errChan
|
2016-06-20 22:31:57 -07:00
|
|
|
}
|
|
|
|
|
2017-02-23 11:56:47 -08:00
|
|
|
// TheirSignatures returns the counterparty's signatures to all inputs to the
|
2016-01-02 12:09:31 -08:00
|
|
|
// funding transaction belonging to them, as well as their signature for the
|
|
|
|
// wallet's version of the commitment transaction. This methods is provided for
|
|
|
|
// additional verification, such as needed by tests.
|
2017-07-29 18:58:55 -07:00
|
|
|
//
|
2016-01-02 12:09:31 -08:00
|
|
|
// NOTE: These attributes will be unpopulated before a call to
|
|
|
|
// .CompleteReservation().
|
2016-05-03 19:46:53 -07:00
|
|
|
func (r *ChannelReservation) TheirSignatures() ([]*InputScript, []byte) {
|
2015-12-22 20:30:11 -08:00
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
2016-05-03 19:46:53 -07:00
|
|
|
return r.theirFundingInputScripts, r.theirCommitmentSig
|
2015-12-22 20:30:11 -08:00
|
|
|
}
|
|
|
|
|
2016-01-02 12:09:31 -08:00
|
|
|
// FinalFundingTx returns the finalized, fully signed funding transaction for
|
|
|
|
// this reservation.
|
2016-06-20 22:31:57 -07:00
|
|
|
//
|
|
|
|
// NOTE: If this reservation was created as the non-initiator to a single
|
|
|
|
// funding workflow, then the full funding transaction will not be available.
|
|
|
|
// Instead we will only have the final outpoint of the funding transaction.
|
2015-12-22 20:30:11 -08:00
|
|
|
func (r *ChannelReservation) FinalFundingTx() *wire.MsgTx {
|
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
2016-06-20 22:31:57 -07:00
|
|
|
return r.fundingTx
|
|
|
|
}
|
|
|
|
|
|
|
|
// FundingOutpoint returns the outpoint of the funding transaction.
|
|
|
|
//
|
|
|
|
// NOTE: The pointer returned will only be set once the .ProcesContribution()
|
|
|
|
// method is called in the case of the initiator of a single funder workflow,
|
|
|
|
// and after the .CompleteReservationSingle() method is called in the case of
|
|
|
|
// a responder to a single funder workflow.
|
|
|
|
func (r *ChannelReservation) FundingOutpoint() *wire.OutPoint {
|
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
2017-07-29 18:58:55 -07:00
|
|
|
return &r.partialState.FundingOutpoint
|
2016-11-16 12:54:27 -08:00
|
|
|
}
|
|
|
|
|
2016-01-02 12:09:31 -08:00
|
|
|
// Cancel abandons this channel reservation. This method should be called in
|
|
|
|
// the scenario that communications with the counterparty break down. Upon
|
|
|
|
// cancellation, all resources previously reserved for this pending payment
|
|
|
|
// channel are returned to the free pool, allowing subsequent reservations to
|
|
|
|
// utilize the now freed resources.
|
2015-12-22 20:30:11 -08:00
|
|
|
func (r *ChannelReservation) Cancel() error {
|
|
|
|
errChan := make(chan error, 1)
|
|
|
|
r.wallet.msgChan <- &fundingReserveCancelMsg{
|
|
|
|
pendingFundingID: r.reservationID,
|
|
|
|
err: errChan,
|
|
|
|
}
|
|
|
|
|
|
|
|
return <-errChan
|
|
|
|
}
|
|
|
|
|
2017-01-22 15:06:28 -08:00
|
|
|
// OpenChannelDetails wraps the finalized fully confirmed channel which
|
|
|
|
// resulted from a ChannelReservation instance with details concerning exactly
|
|
|
|
// _where_ in the chain the channel was ultimately opened.
|
|
|
|
type OpenChannelDetails struct {
|
|
|
|
// Channel is the active channel created by an instance of a
|
|
|
|
// ChannelReservation and the required funding workflow.
|
|
|
|
Channel *LightningChannel
|
|
|
|
|
2017-07-29 18:58:55 -07:00
|
|
|
// ConfirmationHeight is the block height within the chain that
|
|
|
|
// included the channel.
|
2017-01-22 15:06:28 -08:00
|
|
|
ConfirmationHeight uint32
|
|
|
|
|
|
|
|
// TransactionIndex is the index within the confirming block that the
|
|
|
|
// transaction resides.
|
|
|
|
TransactionIndex uint32
|
|
|
|
}
|