2015-12-20 09:00:50 +03:00
|
|
|
package lnwallet
|
2015-10-28 01:50:30 +03:00
|
|
|
|
|
|
|
import (
|
2016-01-07 03:15:49 +03:00
|
|
|
"encoding/hex"
|
2015-10-28 01:50:30 +03:00
|
|
|
"errors"
|
2015-11-05 23:36:19 +03:00
|
|
|
"fmt"
|
2015-10-28 01:50:30 +03:00
|
|
|
"sync"
|
|
|
|
"sync/atomic"
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
"github.com/davecgh/go-spew/spew"
|
2016-08-04 08:31:20 +03:00
|
|
|
"github.com/lightningnetwork/lnd/chainntnfs"
|
2016-01-16 21:45:54 +03:00
|
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
2016-05-01 06:24:57 +03:00
|
|
|
"github.com/lightningnetwork/lnd/elkrem"
|
2016-08-13 01:50:47 +03:00
|
|
|
"github.com/roasbeef/btcd/chaincfg"
|
|
|
|
"github.com/roasbeef/btcutil/hdkeychain"
|
2015-12-21 02:13:14 +03:00
|
|
|
|
2016-05-15 17:17:44 +03:00
|
|
|
"github.com/roasbeef/btcd/btcec"
|
|
|
|
"github.com/roasbeef/btcd/txscript"
|
|
|
|
"github.com/roasbeef/btcd/wire"
|
|
|
|
"github.com/roasbeef/btcutil"
|
|
|
|
"github.com/roasbeef/btcutil/txsort"
|
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
|
2016-08-13 01:43:16 +03:00
|
|
|
|
|
|
|
// elkremRootIndex is the top level HD key index from which secrets
|
|
|
|
// used to generate elkrem roots should be derived from.
|
|
|
|
elkremRootIndex = hdkeychain.HardenedKeyStart + 1
|
2016-08-13 01:50:47 +03:00
|
|
|
|
|
|
|
// identityKeyIndex is the top level HD key index which is used to
|
|
|
|
// generate/rotate identity keys.
|
|
|
|
//
|
|
|
|
// TODO(roasbeef): should instead be child to make room for future
|
|
|
|
// rotations, etc.
|
|
|
|
identityKeyIndex = hdkeychain.HardenedKeyStart + 2
|
2016-09-13 05:05:56 +03:00
|
|
|
|
|
|
|
commitFee = 5000
|
2015-11-13 06:34:35 +03:00
|
|
|
)
|
|
|
|
|
2015-10-28 01:50:30 +03:00
|
|
|
var (
|
|
|
|
// Error types
|
2015-11-05 23:36:19 +03:00
|
|
|
ErrInsufficientFunds = errors.New("not enough available outputs to " +
|
|
|
|
"create funding transaction")
|
|
|
|
|
2015-12-26 21:35:15 +03:00
|
|
|
// Namespace bucket keys.
|
|
|
|
lightningNamespaceKey = []byte("ln-wallet")
|
|
|
|
waddrmgrNamespaceKey = []byte("waddrmgr")
|
|
|
|
wtxmgrNamespaceKey = []byte("wtxmgr")
|
2015-11-05 23:36:19 +03:00
|
|
|
)
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// initFundingReserveReq is the first message sent to initiate the workflow
|
|
|
|
// required to open a payment channel with a remote peer. The initial required
|
|
|
|
// paramters are configurable accross channels. These paramters are to be 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 periodically
|
|
|
|
// after a timeout period in order to avoid "exhaustion" attacks.
|
|
|
|
// NOTE: The workflow currently assumes fully balanced symmetric channels.
|
|
|
|
// Meaning both parties must encumber the same amount of funds.
|
|
|
|
// TODO(roasbeef): zombie reservation sweeper goroutine.
|
2015-11-05 23:36:19 +03:00
|
|
|
type initFundingReserveMsg struct {
|
2016-06-21 20:37:55 +03:00
|
|
|
// The number of confirmations required before the channel is considered
|
|
|
|
// open.
|
|
|
|
numConfs uint16
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// The amount of funds requested for this channel.
|
2015-10-28 01:50:30 +03:00
|
|
|
fundingAmount btcutil.Amount
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// The total capacity of the channel which includes the amount of funds
|
|
|
|
// the remote party contributes (if any).
|
|
|
|
capacity btcutil.Amount
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// The minimum accepted satoshis/KB fee for the funding transaction. In
|
|
|
|
// order to ensure timely confirmation, it is recomened that this fee
|
|
|
|
// should be generous, paying some multiple of the accepted base fee
|
|
|
|
// rate of the network.
|
|
|
|
// TODO(roasbeef): integrate fee estimation project...
|
|
|
|
minFeeRate btcutil.Amount
|
|
|
|
|
|
|
|
// The ID of the remote node we would like to open a channel with.
|
2016-06-21 20:37:55 +03:00
|
|
|
// TODO(roasbeef): switch to just reg pubkey?
|
2015-12-26 09:05:07 +03:00
|
|
|
nodeID [32]byte
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// The delay on the "pay-to-self" output(s) of the commitment transaction.
|
|
|
|
csvDelay uint32
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// A channel in which all errors will be sent accross. Will be nil if
|
|
|
|
// this initial set is succesful.
|
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// A ChannelReservation with our contributions filled in will be sent
|
|
|
|
// accross this channel in the case of a succesfully reservation
|
|
|
|
// initiation. In the case of an error, this will read a nil pointer.
|
|
|
|
// 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.
|
2016-05-04 05:49:58 +03:00
|
|
|
theirFundingInputScripts []*InputScript
|
2015-12-22 00:54:33 +03:00
|
|
|
|
|
|
|
// This should be 1/2 of the signatures needed to succesfully spend our
|
|
|
|
// version of the commitment transaction.
|
|
|
|
theirCommitmentSig []byte
|
2015-11-05 23:36:19 +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-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-06-30 22:13:46 +03:00
|
|
|
// revokeKey is the revocation public key derived by the remote node to
|
|
|
|
// be used within the initial version of the commitment transaction we
|
|
|
|
// construct for them.
|
|
|
|
revokeKey *btcec.PublicKey
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// This should be 1/2 of the signatures needed to succesfully spend our
|
|
|
|
// version of the commitment transaction.
|
|
|
|
theirCommitmentSig []byte
|
|
|
|
|
|
|
|
// NOTE: In order to avoid deadlocks, this channel MUST be buffered.
|
|
|
|
err chan error
|
|
|
|
}
|
|
|
|
|
|
|
|
// channelOpenMsg is the final message sent to finalize a single funder channel
|
|
|
|
// workflow to which we are the responder to. This message is sent once the
|
|
|
|
// remote peer deems the channel open, meaning it has reached a sufficient
|
|
|
|
// number of confirmations in the blockchain.
|
|
|
|
type channelOpenMsg struct {
|
|
|
|
pendingFundingID uint64
|
|
|
|
|
|
|
|
// TODO(roasbeef): move verification up to upper layer, yeh?
|
|
|
|
spvProof []byte
|
|
|
|
|
|
|
|
// 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
|
|
|
|
// within the Lightning Network, channel lifetimes, etc. However, it embedds a
|
|
|
|
// 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
|
|
|
|
// operations. Interaction has been designed independant of any peer-to-peer
|
|
|
|
// communication protocol, allowing the wallet to be self-contained and embeddable
|
|
|
|
// within future projects interacting with the Lightning Network.
|
|
|
|
// NOTE: At the moment the wallet requires a btcd full node, as it's dependant
|
|
|
|
// on btcd's websockets notifications as even triggers during the lifetime of
|
|
|
|
// a channel. However, once the chainntnfs package is complete, the wallet
|
|
|
|
// will be compatible with multiple RPC/notification services such as Electrum,
|
|
|
|
// Bitcoin Core + ZeroMQ, etc. Eventually, the wallet won't require a full-node
|
|
|
|
// at all, as SPV support is integrated inot btcwallet.
|
2015-10-28 01:50:30 +03:00
|
|
|
type LightningWallet struct {
|
2015-12-28 23:14:00 +03:00
|
|
|
// This mutex is to be held when generating external keys to be used
|
|
|
|
// as multi-sig, and commitment keys within the channel.
|
2016-08-13 01:50:47 +03:00
|
|
|
keyGenMtx sync.RWMutex
|
2015-10-28 01:50:30 +03:00
|
|
|
|
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
|
|
|
|
// double spend inputs accross each other.
|
|
|
|
coinSelectMtx sync.RWMutex
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-12-26 09:05:55 +03:00
|
|
|
// A wrapper around a namespace within boltdb reserved for ln-based
|
2015-12-28 23:14:00 +03:00
|
|
|
// wallet meta-data. See the 'channeldb' package for further
|
|
|
|
// information.
|
2016-08-13 01:50:47 +03:00
|
|
|
ChannelDB *channeldb.DB
|
2015-12-28 23:14:00 +03:00
|
|
|
|
2016-01-07 03:15:49 +03:00
|
|
|
// Used by in order to obtain notifications about funding transaction
|
|
|
|
// reaching a specified confirmation depth, and to catch
|
|
|
|
// counterparty's broadcasting revoked commitment states.
|
2016-08-04 08:31:20 +03:00
|
|
|
chainNotifier chainntnfs.ChainNotifier
|
2016-01-07 03:15:49 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// wallet is the the core wallet, all non Lightning Network specific
|
|
|
|
// interaction is proxied to the internal wallet.
|
|
|
|
WalletController
|
|
|
|
|
|
|
|
// Signer is the wallet's current Signer implementation. This Signer is
|
|
|
|
// used to generate signature for all inputs to potential funding
|
|
|
|
// transactions, as well as for spends from the funding transaction to
|
|
|
|
// update the commitment state.
|
|
|
|
Signer Signer
|
|
|
|
|
|
|
|
// chainIO is an instance of the BlockChainIO interface. chainIO is
|
|
|
|
// used to lookup the existance of outputs within the utxo set.
|
|
|
|
chainIO BlockChainIO
|
|
|
|
|
2016-08-13 01:43:16 +03:00
|
|
|
// rootKey is the root HD key dervied from a WalletController private
|
|
|
|
// key. This rootKey is used to derive all LN specific secrets.
|
|
|
|
rootKey *hdkeychain.ExtendedKey
|
2015-12-28 23:14:00 +03:00
|
|
|
|
|
|
|
// All messages to the wallet are to be sent accross 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.
|
|
|
|
fundingLimbo map[uint64]*ChannelReservation
|
|
|
|
nextFundingID uint64
|
|
|
|
limboMtx sync.RWMutex
|
2015-11-05 23:34:11 +03:00
|
|
|
// TODO(roasbeef): zombie garbage collection routine to solve
|
|
|
|
// lost-object/starvation problem/attack.
|
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{}
|
|
|
|
|
|
|
|
netParams *chaincfg.Params
|
2015-12-30 00:59:57 +03:00
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
started int32
|
2015-10-28 01:50:30 +03:00
|
|
|
shutdown int32
|
2015-12-28 23:14:00 +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.
|
2016-08-04 08:31:20 +03:00
|
|
|
//
|
|
|
|
// NOTE: The passed channeldb, and ChainNotifier should already be fully
|
|
|
|
// initialized/started before being passed as a function arugment.
|
2016-08-13 01:50:47 +03:00
|
|
|
func NewLightningWallet(cdb *channeldb.DB, notifier chainntnfs.ChainNotifier,
|
|
|
|
wallet WalletController, signer Signer, bio BlockChainIO,
|
|
|
|
netParams *chaincfg.Params) (*LightningWallet, error) {
|
2016-08-04 08:31:20 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// TODO(roasbeef): need a another wallet level config
|
2015-11-19 01:38:57 +03:00
|
|
|
|
2016-08-13 01:43:16 +03:00
|
|
|
// Fetch the root derivation key from the wallet's HD chain. We'll use
|
|
|
|
// this to generate specific Lightning related secrets on the fly.
|
|
|
|
rootKey, err := wallet.FetchRootKey()
|
2016-02-03 23:00:28 +03:00
|
|
|
if err != nil {
|
2016-03-23 04:48:18 +03:00
|
|
|
return nil, err
|
2016-02-03 23:00:28 +03:00
|
|
|
}
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// TODO(roasbeef): always re-derive on the fly?
|
|
|
|
rootKeyRaw := rootKey.Serialize()
|
|
|
|
rootMasterKey, err := hdkeychain.NewMaster(rootKeyRaw, netParams)
|
2016-02-25 09:17:23 +03:00
|
|
|
if err != nil {
|
2016-03-23 04:48:18 +03:00
|
|
|
return nil, err
|
2016-02-25 09:17:23 +03:00
|
|
|
}
|
2016-02-27 03:35:04 +03:00
|
|
|
|
2015-11-13 06:34:35 +03:00
|
|
|
return &LightningWallet{
|
2016-08-13 01:43:16 +03:00
|
|
|
rootKey: rootMasterKey,
|
2016-08-13 01:50:47 +03:00
|
|
|
chainNotifier: notifier,
|
|
|
|
Signer: signer,
|
|
|
|
WalletController: wallet,
|
|
|
|
chainIO: bio,
|
|
|
|
ChannelDB: cdb,
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// LockOutpoints returns a list of all currently locked outpoint.
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
// ResetReservations reset the volatile wallet state which trakcs all currently
|
|
|
|
// 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
|
|
|
|
// (non-cancalled) reservations.
|
|
|
|
func (l *LightningWallet) ActiveReservations() []*ChannelReservation {
|
|
|
|
reservations := make([]*ChannelReservation, 0, len(l.fundingLimbo))
|
|
|
|
for _, reservation := range l.fundingLimbo {
|
|
|
|
reservations = append(reservations, reservation)
|
|
|
|
}
|
|
|
|
|
|
|
|
return reservations
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetIdentitykey returns the identity private key of the wallet.
|
|
|
|
// TODO(roasbeef): should be moved elsewhere
|
|
|
|
func (l *LightningWallet) GetIdentitykey() (*btcec.PrivateKey, error) {
|
|
|
|
identityKey, err := l.rootKey.Child(identityKeyIndex)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return identityKey.ECPrivKey()
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// requestHandler is the primary goroutine(s) resposible for handling, and
|
|
|
|
// dispatching relies 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) {
|
2015-11-05 23:36:19 +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)
|
2016-06-21 20:37:55 +03:00
|
|
|
case *channelOpenMsg:
|
|
|
|
l.handleChannelOpen(msg)
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
case <-l.quit:
|
|
|
|
// TODO: do some clean up
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
l.wg.Done()
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// InitChannelReservation kicks off the 3-step workflow required to succesfully
|
|
|
|
// 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
|
|
|
|
// succesful, a ChannelReservation containing our completed contribution is
|
|
|
|
// returned. Our contribution contains all the items neccessary to allow the
|
|
|
|
// counter party to build the funding transaction, and both versions of the
|
|
|
|
// commitment transaction. Otherwise, an error occured a nil pointer along with
|
|
|
|
// an error are returned.
|
|
|
|
//
|
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
|
|
|
|
// transaction, and that the signature we records for our version of the
|
|
|
|
// commitment transaction is valid.
|
|
|
|
func (l *LightningWallet) InitChannelReservation(capacity,
|
|
|
|
ourFundAmt btcutil.Amount, theirID [32]byte, numConfs uint16,
|
|
|
|
csvDelay uint32) (*ChannelReservation, error) {
|
2015-12-28 23:14:00 +03:00
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
errChan := make(chan error, 1)
|
2015-11-13 05:43:32 +03:00
|
|
|
respChan := make(chan *ChannelReservation, 1)
|
2015-11-05 23:36:19 +03:00
|
|
|
|
|
|
|
l.msgChan <- &initFundingReserveMsg{
|
2016-06-21 20:37:55 +03:00
|
|
|
capacity: capacity,
|
|
|
|
numConfs: numConfs,
|
|
|
|
fundingAmount: ourFundAmt,
|
2015-12-28 23:14:00 +03:00
|
|
|
csvDelay: csvDelay,
|
2015-12-26 09:05:07 +03:00
|
|
|
nodeID: theirID,
|
2015-11-05 23:36:19 +03:00
|
|
|
err: errChan,
|
|
|
|
resp: respChan,
|
|
|
|
}
|
|
|
|
|
|
|
|
return <-respChan, <-errChan
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// handleFundingReserveRequest processes a message intending to create, and
|
|
|
|
// validate a funding reservation request.
|
2015-11-05 23:36:19 +03:00
|
|
|
func (l *LightningWallet) handleFundingReserveRequest(req *initFundingReserveMsg) {
|
2016-08-13 01:50:47 +03:00
|
|
|
id := atomic.AddUint64(&l.nextFundingID, 1)
|
2016-09-13 05:05:56 +03:00
|
|
|
totalCapacity := req.capacity + commitFee
|
|
|
|
reservation := NewChannelReservation(totalCapacity, req.fundingAmount,
|
2016-06-21 20:37:55 +03:00
|
|
|
req.minFeeRate, l, id, req.numConfs)
|
2015-10-28 01:50:30 +03:00
|
|
|
|
2015-11-14 22:52:07 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
2015-12-19 06:39:51 +03:00
|
|
|
reservation.Lock()
|
|
|
|
defer reservation.Unlock()
|
2015-11-14 22:52:07 +03:00
|
|
|
|
2015-12-26 09:05:07 +03:00
|
|
|
reservation.partialState.TheirLNID = req.nodeID
|
2015-12-23 07:31:17 +03:00
|
|
|
ourContribution := reservation.ourContribution
|
2015-12-28 23:14:00 +03:00
|
|
|
ourContribution.CsvDelay = req.csvDelay
|
2016-03-24 10:01:35 +03:00
|
|
|
reservation.partialState.LocalCsvDelay = req.csvDelay
|
2015-12-28 23:14:00 +03:00
|
|
|
|
2016-06-21 20:33:14 +03:00
|
|
|
// If we're on the receiving end of a single funder channel then we
|
|
|
|
// don't need to perform any coin selection. Otherwise, attempt to
|
|
|
|
// obtain enough coins to meet the required funding amount.
|
|
|
|
if req.fundingAmount != 0 {
|
2016-09-13 05:05:56 +03:00
|
|
|
// TODO(roasbeef): consult model for proper fee rate on funding
|
|
|
|
// tx
|
2016-08-13 01:35:33 +03:00
|
|
|
feeRate := uint64(10)
|
2016-09-13 05:05:56 +03:00
|
|
|
amt := req.fundingAmount + commitFee
|
|
|
|
err := l.selectCoinsAndChange(feeRate, amt, ourContribution)
|
|
|
|
if err != nil {
|
2015-10-28 01:50:30 +03:00
|
|
|
req.err <- err
|
2015-11-27 09:50:17 +03:00
|
|
|
req.resp <- nil
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-21 20:33:14 +03:00
|
|
|
// Grab two fresh keys from our HD chain, one will be used for the
|
2015-12-21 02:13:14 +03:00
|
|
|
// multi-sig funding transaction, and the other for the commitment
|
|
|
|
// transaction.
|
2016-08-13 01:50:47 +03:00
|
|
|
multiSigKey, err := l.NewRawKey()
|
2015-12-21 02:13:14 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
2016-08-13 01:50:47 +03:00
|
|
|
commitKey, err := l.NewRawKey()
|
2015-11-05 23:36:19 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
2015-11-27 09:50:17 +03:00
|
|
|
req.resp <- nil
|
2015-11-05 23:36:19 +03:00
|
|
|
return
|
|
|
|
}
|
2016-06-21 20:37:55 +03:00
|
|
|
reservation.partialState.OurMultiSigKey = multiSigKey
|
2016-08-13 01:50:47 +03:00
|
|
|
ourContribution.MultiSigKey = multiSigKey
|
2015-12-24 21:41:15 +03:00
|
|
|
reservation.partialState.OurCommitKey = commitKey
|
2016-08-13 01:50:47 +03:00
|
|
|
ourContribution.CommitKey = commitKey
|
2015-12-21 02:13:14 +03:00
|
|
|
|
|
|
|
// Generate a fresh address to be used in the case of a cooperative
|
|
|
|
// channel close.
|
2016-08-13 01:50:47 +03:00
|
|
|
deliveryAddress, err := l.NewAddress(WitnessPubKey, false)
|
2015-12-21 02:13:14 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
2016-03-24 10:01:35 +03:00
|
|
|
deliveryScript, err := txscript.PayToAddrScript(deliveryAddress)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
req.resp <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
reservation.partialState.OurDeliveryScript = deliveryScript
|
2016-01-07 03:15:49 +03:00
|
|
|
ourContribution.DeliveryAddress = deliveryAddress
|
2015-12-21 02:13:14 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
// Create a limbo and record entry for this newly pending funding
|
|
|
|
// request.
|
|
|
|
l.limboMtx.Lock()
|
|
|
|
l.fundingLimbo[id] = reservation
|
|
|
|
l.limboMtx.Unlock()
|
|
|
|
|
2015-10-28 01:50:30 +03:00
|
|
|
// Funding reservation request succesfully handled. The funding inputs
|
|
|
|
// will be marked as unavailable until the reservation is either
|
|
|
|
// completed, or cancecled.
|
2015-12-19 06:39:51 +03:00
|
|
|
req.resp <- reservation
|
2015-10-28 01:50:30 +03:00
|
|
|
req.err <- 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 {
|
|
|
|
// TODO(roasbeef): make new error, "unkown funding state" or something
|
|
|
|
req.err <- fmt.Errorf("attempted to cancel non-existant funding state")
|
|
|
|
return
|
2015-10-28 01:50:30 +03:00
|
|
|
}
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2015-11-14 22:52:07 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
// Mark all previously locked outpoints as usuable for future funding
|
|
|
|
// 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
|
|
|
}
|
|
|
|
|
2015-11-13 04:45:09 +03:00
|
|
|
// TODO(roasbeef): is it even worth it to keep track of unsed 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
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// handleFundingCounterPartyFunds 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) {
|
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 {
|
|
|
|
req.err <- fmt.Errorf("attempted to update non-existant funding state")
|
|
|
|
return
|
|
|
|
}
|
2015-11-05 23:32:15 +03:00
|
|
|
|
2015-11-14 22:52:07 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
|
|
|
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.
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.fundingTx = wire.NewMsgTx()
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
ourKey := pendingReservation.partialState.OurMultiSigKey
|
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)
|
2016-08-13 01:50:47 +03:00
|
|
|
redeemScript, multiSigOut, err := GenFundingPkScript(ourKey.SerializeCompressed(),
|
2015-12-22 00:53:34 +03:00
|
|
|
theirKey.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
|
|
|
}
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.partialState.FundingRedeemScript = redeemScript
|
2015-12-24 21:42:29 +03:00
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
// Sort the transaction. Since both side agree to a cannonical
|
|
|
|
// 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.
|
2016-05-04 05:49:58 +03:00
|
|
|
pendingReservation.ourFundingInputScripts = make([]*InputScript, 0, len(ourContribution.Inputs))
|
2016-08-13 01:50:47 +03:00
|
|
|
signDesc := SignDescriptor{
|
|
|
|
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
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
signDesc.Output = info
|
|
|
|
signDesc.InputIndex = i
|
2016-05-04 05:49:58 +03:00
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
inputScript, err := l.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
|
|
|
}
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
txIn.SignatureScript = inputScript.ScriptSig
|
|
|
|
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-08-13 01:50:47 +03:00
|
|
|
// since the outputs are cannonically 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.
|
|
|
|
fundingTxID := fundingTx.TxSha()
|
2016-08-13 01:50:47 +03:00
|
|
|
_, multiSigIndex := FindScriptOutputIndex(fundingTx, multiSigOut.PkScript)
|
2016-06-21 20:37:55 +03:00
|
|
|
fundingOutpoint := wire.NewOutPoint(&fundingTxID, multiSigIndex)
|
|
|
|
pendingReservation.partialState.FundingOutpoint = fundingOutpoint
|
|
|
|
|
2015-12-22 00:53:34 +03:00
|
|
|
// Initialize an empty sha-chain for them, tracking the current pending
|
|
|
|
// revocation hash (we don't yet know the pre-image so we can't add it
|
|
|
|
// to the chain).
|
2016-06-30 22:13:46 +03:00
|
|
|
e := &elkrem.ElkremReceiver{}
|
|
|
|
pendingReservation.partialState.RemoteElkrem = e
|
|
|
|
pendingReservation.partialState.TheirCurrentRevocation = theirContribution.RevocationKey
|
|
|
|
|
2016-08-13 01:43:16 +03:00
|
|
|
masterElkremRoot, err := l.deriveMasterElkremRoot()
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-06-30 22:13:46 +03:00
|
|
|
// Now that we have their commitment key, we can create the revocation
|
|
|
|
// key for the first version of our commitment transaction. To do so,
|
|
|
|
// we'll first create our elkrem root, then grab the first pre-iamge
|
|
|
|
// from it.
|
2016-08-13 01:43:16 +03:00
|
|
|
elkremRoot := deriveElkremRoot(masterElkremRoot, ourKey, theirKey)
|
2016-06-30 22:13:46 +03:00
|
|
|
elkremSender := elkrem.NewElkremSender(elkremRoot)
|
|
|
|
pendingReservation.partialState.LocalElkrem = elkremSender
|
|
|
|
firstPreimage, err := elkremSender.AtIndex(0)
|
|
|
|
if err != nil {
|
2016-06-21 20:37:55 +03:00
|
|
|
req.err <- err
|
2016-03-24 10:01:35 +03:00
|
|
|
return
|
|
|
|
}
|
2016-06-30 22:13:46 +03:00
|
|
|
theirCommitKey := theirContribution.CommitKey
|
2016-08-13 01:50:47 +03:00
|
|
|
ourRevokeKey := DeriveRevocationPubkey(theirCommitKey, firstPreimage[:])
|
2015-12-22 00:53:34 +03:00
|
|
|
|
2016-06-21 20:37:55 +03:00
|
|
|
// Create the txIn to our commitment transaction; required to construct
|
|
|
|
// the commitment transactions.
|
|
|
|
fundingTxIn := wire.NewTxIn(wire.NewOutPoint(&fundingTxID, multiSigIndex), nil, nil)
|
2015-12-22 00:53:34 +03:00
|
|
|
|
|
|
|
// With the funding tx complete, create both commitment transactions.
|
2016-06-21 20:37:55 +03:00
|
|
|
// TODO(roasbeef): much cleanup + de-duplication
|
2015-12-23 07:31:17 +03:00
|
|
|
pendingReservation.fundingLockTime = theirContribution.CsvDelay
|
2016-06-21 20:37:55 +03:00
|
|
|
ourBalance := ourContribution.FundingAmount
|
|
|
|
theirBalance := theirContribution.FundingAmount
|
2016-06-30 22:13:46 +03:00
|
|
|
ourCommitKey := ourContribution.CommitKey
|
2016-08-13 01:50:47 +03:00
|
|
|
ourCommitTx, err := CreateCommitTx(fundingTxIn, ourCommitKey, theirCommitKey,
|
2016-06-30 22:13:46 +03:00
|
|
|
ourRevokeKey, ourContribution.CsvDelay,
|
2016-06-21 20:37:55 +03:00
|
|
|
ourBalance, theirBalance)
|
2015-12-22 00:53:34 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
2016-08-13 01:50:47 +03:00
|
|
|
theirCommitTx, err := CreateCommitTx(fundingTxIn, theirCommitKey, ourCommitKey,
|
2016-06-30 22:13:46 +03:00
|
|
|
theirContribution.RevocationKey, theirContribution.CsvDelay,
|
2016-06-21 20:37:55 +03:00
|
|
|
theirBalance, ourBalance)
|
2015-12-22 00:53:34 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-12-31 09:36:01 +03:00
|
|
|
// Sort both transactions according to the agreed upon cannonical
|
|
|
|
// ordering. This lets us skip sending the entire transaction over,
|
|
|
|
// instead we'll just send signatures.
|
|
|
|
txsort.InPlaceSort(ourCommitTx)
|
|
|
|
txsort.InPlaceSort(theirCommitTx)
|
|
|
|
|
2016-03-24 10:01:35 +03:00
|
|
|
deliveryScript, err := txscript.PayToAddrScript(theirContribution.DeliveryAddress)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// Record newly available information witin the open channel state.
|
2016-03-24 10:01:35 +03:00
|
|
|
pendingReservation.partialState.RemoteCsvDelay = theirContribution.CsvDelay
|
|
|
|
pendingReservation.partialState.TheirDeliveryScript = deliveryScript
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.partialState.ChanID = fundingOutpoint
|
2015-12-24 21:41:15 +03:00
|
|
|
pendingReservation.partialState.TheirCommitKey = theirCommitKey
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.partialState.TheirMultiSigKey = theirContribution.MultiSigKey
|
2015-12-24 21:41:15 +03:00
|
|
|
pendingReservation.partialState.OurCommitTx = ourCommitTx
|
2016-06-30 22:13:46 +03:00
|
|
|
pendingReservation.ourContribution.RevocationKey = ourRevokeKey
|
2015-12-22 00:53:34 +03:00
|
|
|
|
|
|
|
// Generate a signature for their version of the initial commitment
|
|
|
|
// transaction.
|
2016-08-13 01:50:47 +03:00
|
|
|
signDesc = SignDescriptor{
|
|
|
|
RedeemScript: redeemScript,
|
|
|
|
PubKey: ourKey,
|
|
|
|
Output: multiSigOut,
|
|
|
|
HashType: txscript.SigHashAll,
|
|
|
|
SigHashes: txscript.NewTxSigHashes(theirCommitTx),
|
|
|
|
InputIndex: 0,
|
|
|
|
}
|
|
|
|
sigTheirCommit, err := l.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 {
|
|
|
|
req.err <- fmt.Errorf("attempted to update non-existant funding state")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
|
|
|
// 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
|
|
|
|
|
|
|
|
// Additionally, we can now also record the redeem script of the
|
|
|
|
// funding transaction.
|
|
|
|
// TODO(roasbeef): switch to proper pubkey derivation
|
2016-06-30 22:13:46 +03:00
|
|
|
ourKey := pendingReservation.partialState.OurMultiSigKey
|
2016-06-21 20:37:55 +03:00
|
|
|
theirKey := theirContribution.MultiSigKey
|
|
|
|
channelCapacity := int64(pendingReservation.partialState.Capacity)
|
2016-08-13 01:50:47 +03:00
|
|
|
redeemScript, _, err := GenFundingPkScript(ourKey.SerializeCompressed(),
|
2016-06-21 20:37:55 +03:00
|
|
|
theirKey.SerializeCompressed(), channelCapacity)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
pendingReservation.partialState.FundingRedeemScript = redeemScript
|
|
|
|
|
2016-08-13 01:43:16 +03:00
|
|
|
masterElkremRoot, err := l.deriveMasterElkremRoot()
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-06-30 22:13:46 +03:00
|
|
|
// Now that we know their commitment key, we can create the revocation
|
|
|
|
// key for our version of the initial commitment transaction.
|
2016-08-13 01:43:16 +03:00
|
|
|
elkremRoot := deriveElkremRoot(masterElkremRoot, ourKey, theirKey)
|
2016-06-30 22:13:46 +03:00
|
|
|
elkremSender := elkrem.NewElkremSender(elkremRoot)
|
|
|
|
firstPreimage, err := elkremSender.AtIndex(0)
|
|
|
|
if err != nil {
|
2016-06-21 20:37:55 +03:00
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
2016-06-30 22:13:46 +03:00
|
|
|
pendingReservation.partialState.LocalElkrem = elkremSender
|
|
|
|
theirCommitKey := theirContribution.CommitKey
|
2016-08-13 01:50:47 +03:00
|
|
|
ourRevokeKey := DeriveRevocationPubkey(theirCommitKey, firstPreimage[:])
|
2016-06-30 22:13:46 +03:00
|
|
|
|
|
|
|
// Initialize an empty sha-chain for them, tracking the current pending
|
|
|
|
// revocation hash (we don't yet know the pre-image so we can't add it
|
|
|
|
// to the chain).
|
|
|
|
remoteElkrem := &elkrem.ElkremReceiver{}
|
|
|
|
pendingReservation.partialState.RemoteElkrem = remoteElkrem
|
2016-06-21 20:37:55 +03:00
|
|
|
|
|
|
|
// Record the counterpaty's remaining contributions to the channel,
|
|
|
|
// converting their delivery address into a public key script.
|
|
|
|
deliveryScript, err := txscript.PayToAddrScript(theirContribution.DeliveryAddress)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
pendingReservation.partialState.RemoteCsvDelay = theirContribution.CsvDelay
|
|
|
|
pendingReservation.partialState.TheirDeliveryScript = deliveryScript
|
|
|
|
pendingReservation.partialState.TheirCommitKey = theirContribution.CommitKey
|
|
|
|
pendingReservation.partialState.TheirMultiSigKey = theirContribution.MultiSigKey
|
2016-06-30 22:13:46 +03:00
|
|
|
pendingReservation.ourContribution.RevocationKey = ourRevokeKey
|
2016-06-21 20:37:55 +03:00
|
|
|
|
|
|
|
req.err <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-12-28 23:14:00 +03:00
|
|
|
// handleFundingCounterPartySigs is the final step in the channel reservation
|
|
|
|
// workflow. During this setp, we validate *all* the received signatures for
|
|
|
|
// 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()
|
2015-11-05 23:36:19 +03:00
|
|
|
pendingReservation, 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 {
|
|
|
|
msg.err <- fmt.Errorf("attempted to update non-existant funding state")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-11-14 22:52:07 +03:00
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
2015-11-05 23:36:19 +03:00
|
|
|
// Now we can complete the funding transaction by adding their
|
|
|
|
// signatures to their inputs.
|
2016-05-04 05:49:58 +03:00
|
|
|
pendingReservation.theirFundingInputScripts = msg.theirFundingInputScripts
|
2016-06-21 20:37:55 +03:00
|
|
|
inputScripts := msg.theirFundingInputScripts
|
|
|
|
fundingTx := pendingReservation.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
|
|
|
|
txin.SignatureScript = inputScripts[sigIndex].ScriptSig
|
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.
|
|
|
|
prevOut := txin.PreviousOutPoint
|
2016-08-13 01:50:47 +03:00
|
|
|
output, err := l.chainIO.GetUtxo(&prevOut.Hash, prevOut.Index)
|
2016-01-07 03:15:49 +03:00
|
|
|
if output == nil {
|
|
|
|
msg.err <- fmt.Errorf("input to funding tx does not exist: %v", err)
|
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 {
|
|
|
|
// TODO(roasbeef): cancel at this stage if invalid sigs?
|
|
|
|
msg.err <- fmt.Errorf("cannot create script engine: %s", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if err = vm.Execute(); err != nil {
|
|
|
|
msg.err <- fmt.Errorf("cannot validate transaction: %s", err)
|
|
|
|
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.
|
2015-12-28 23:13:41 +03:00
|
|
|
pendingReservation.theirCommitmentSig = msg.theirCommitmentSig
|
|
|
|
commitTx := pendingReservation.partialState.OurCommitTx
|
|
|
|
theirKey := pendingReservation.theirContribution.MultiSigKey
|
|
|
|
|
|
|
|
// Re-generate both the redeemScript and p2sh output. We sign the
|
|
|
|
// redeemScript script, but include the p2sh output as the subscript
|
|
|
|
// for verification.
|
|
|
|
redeemScript := pendingReservation.partialState.FundingRedeemScript
|
|
|
|
|
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.
|
|
|
|
theirCommitSig := msg.theirCommitmentSig
|
2016-05-04 05:49:58 +03:00
|
|
|
channelValue := int64(pendingReservation.partialState.Capacity)
|
|
|
|
hashCache := txscript.NewTxSigHashes(commitTx)
|
2016-08-13 01:50:47 +03:00
|
|
|
sigHash, err := txscript.CalcWitnessSigHash(redeemScript, hashCache,
|
|
|
|
txscript.SigHashAll, commitTx, 0, channelValue)
|
2015-12-28 23:13:41 +03:00
|
|
|
if err != nil {
|
2016-08-13 01:50:47 +03:00
|
|
|
msg.err <- fmt.Errorf("counterparty's commitment signature is invalid: %v", err)
|
2015-12-28 23:13:41 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:50:47 +03:00
|
|
|
walletLog.Infof("sighash verify: %v", hex.EncodeToString(sigHash))
|
|
|
|
walletLog.Infof("initer verifying tx: %v", spew.Sdump(commitTx))
|
|
|
|
|
|
|
|
// Verify that we've received a valid signature from the remote party
|
|
|
|
// for our version of the commitment transaction.
|
|
|
|
sig, err := btcec.ParseSignature(theirCommitSig, btcec.S256())
|
2015-12-28 23:13:41 +03:00
|
|
|
if err != nil {
|
|
|
|
msg.err <- err
|
|
|
|
return
|
2016-08-13 01:50:47 +03:00
|
|
|
} else if !sig.Verify(sigHash, theirKey) {
|
|
|
|
msg.err <- fmt.Errorf("counterparty's commitment signature is invalid")
|
2015-12-28 23:13:41 +03:00
|
|
|
return
|
|
|
|
}
|
2016-07-06 02:53:55 +03:00
|
|
|
pendingReservation.partialState.OurCommitSig = theirCommitSig
|
|
|
|
|
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()
|
|
|
|
delete(l.fundingLimbo, pendingReservation.reservationID)
|
2015-12-19 06:39:51 +03:00
|
|
|
// TODO(roasbeef): unlock outputs here, Store.InsertTx will handle marking
|
|
|
|
// input in unconfirmed tx, so future coin selects don't pick it up
|
|
|
|
// * also record location of change address so can use AddCredit
|
2015-11-13 05:43:32 +03:00
|
|
|
l.limboMtx.Unlock()
|
2015-11-05 23:36:19 +03:00
|
|
|
|
2016-07-27 21:28:52 +03:00
|
|
|
walletLog.Infof("Broadcasting funding tx for ChannelPoint(%v): %v",
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.partialState.FundingOutpoint,
|
|
|
|
spew.Sdump(fundingTx))
|
|
|
|
|
|
|
|
// Broacast the finalized funding transaction to the network.
|
|
|
|
if err := l.PublishTransaction(fundingTx); err != nil {
|
|
|
|
msg.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-12-03 03:51:21 +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.
|
2016-03-24 10:01:35 +03:00
|
|
|
if err := pendingReservation.partialState.FullSync(); err != nil {
|
|
|
|
msg.err <- err
|
|
|
|
return
|
|
|
|
}
|
2015-12-03 03:51:21 +03:00
|
|
|
|
2016-01-07 03:17:18 +03:00
|
|
|
// Create a goroutine to watch the chain so we can open the channel once
|
|
|
|
// the funding tx has enough confirmations.
|
2016-06-21 20:37:55 +03:00
|
|
|
go l.openChannelAfterConfirmations(pendingReservation)
|
|
|
|
|
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 {
|
|
|
|
req.err <- fmt.Errorf("attempted to update non-existant funding state")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
|
|
|
pendingReservation.Lock()
|
|
|
|
defer pendingReservation.Unlock()
|
|
|
|
|
|
|
|
pendingReservation.partialState.FundingOutpoint = req.fundingOutpoint
|
2016-06-30 22:13:46 +03:00
|
|
|
pendingReservation.partialState.TheirCurrentRevocation = req.revokeKey
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.partialState.ChanID = req.fundingOutpoint
|
|
|
|
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.
|
|
|
|
ourCommitKey := pendingReservation.ourContribution.CommitKey
|
|
|
|
theirCommitKey := pendingReservation.theirContribution.CommitKey
|
|
|
|
ourBalance := pendingReservation.ourContribution.FundingAmount
|
|
|
|
theirBalance := pendingReservation.theirContribution.FundingAmount
|
2016-08-13 01:50:47 +03:00
|
|
|
ourCommitTx, err := CreateCommitTx(fundingTxIn, ourCommitKey, theirCommitKey,
|
2016-06-30 22:13:46 +03:00
|
|
|
pendingReservation.ourContribution.RevocationKey,
|
2016-06-21 20:37:55 +03:00
|
|
|
pendingReservation.ourContribution.CsvDelay, ourBalance, theirBalance)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
2016-08-13 01:50:47 +03:00
|
|
|
theirCommitTx, err := CreateCommitTx(fundingTxIn, theirCommitKey, ourCommitKey,
|
2016-06-30 22:13:46 +03:00
|
|
|
req.revokeKey, pendingReservation.theirContribution.CsvDelay,
|
|
|
|
theirBalance, ourBalance)
|
2016-06-21 20:37:55 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sort both transactions according to the agreed upon cannonical
|
|
|
|
// ordering. This ensures that both parties sign the same sighash
|
|
|
|
// without further synchronization.
|
|
|
|
txsort.InPlaceSort(ourCommitTx)
|
|
|
|
pendingReservation.partialState.OurCommitTx = ourCommitTx
|
|
|
|
txsort.InPlaceSort(theirCommitTx)
|
|
|
|
|
|
|
|
redeemScript := pendingReservation.partialState.FundingRedeemScript
|
|
|
|
channelValue := int64(pendingReservation.partialState.Capacity)
|
|
|
|
hashCache := txscript.NewTxSigHashes(ourCommitTx)
|
|
|
|
theirKey := pendingReservation.theirContribution.MultiSigKey
|
|
|
|
ourKey := pendingReservation.partialState.OurMultiSigKey
|
2016-08-13 01:50:47 +03:00
|
|
|
|
|
|
|
sigHash, err := txscript.CalcWitnessSigHash(redeemScript, hashCache,
|
|
|
|
txscript.SigHashAll, ourCommitTx, 0, channelValue)
|
2016-06-21 20:37:55 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
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
|
|
|
|
return
|
2016-08-13 01:50:47 +03:00
|
|
|
} else if !sig.Verify(sigHash, theirKey) {
|
|
|
|
req.err <- fmt.Errorf("counterparty's commitment signature is invalid")
|
2016-06-21 20:37:55 +03:00
|
|
|
return
|
|
|
|
}
|
2016-07-06 02:53:55 +03:00
|
|
|
pendingReservation.partialState.OurCommitSig = req.theirCommitmentSig
|
|
|
|
|
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.
|
2016-08-13 01:50:47 +03:00
|
|
|
p2wsh, err := witnessScriptHash(redeemScript)
|
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
signDesc := SignDescriptor{
|
|
|
|
RedeemScript: redeemScript,
|
|
|
|
PubKey: ourKey,
|
|
|
|
Output: &wire.TxOut{
|
|
|
|
PkScript: p2wsh,
|
|
|
|
Value: channelValue,
|
|
|
|
},
|
|
|
|
HashType: txscript.SigHashAll,
|
|
|
|
SigHashes: txscript.NewTxSigHashes(theirCommitTx),
|
|
|
|
InputIndex: 0,
|
|
|
|
}
|
|
|
|
sigTheirCommit, err := l.Signer.SignOutputRaw(theirCommitTx, &signDesc)
|
2016-06-21 20:37:55 +03:00
|
|
|
if err != nil {
|
|
|
|
req.err <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
pendingReservation.ourCommitmentSig = sigTheirCommit
|
|
|
|
|
|
|
|
req.err <- nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// handleChannelOpen completes a single funder reservation to which we are the
|
|
|
|
// responder. This method saves the channel state to disk, finally "opening"
|
|
|
|
// the channel by sending it over to the caller of the reservation via the
|
|
|
|
// channel dispatch channel.
|
|
|
|
func (l *LightningWallet) handleChannelOpen(req *channelOpenMsg) {
|
|
|
|
l.limboMtx.RLock()
|
|
|
|
res, ok := l.fundingLimbo[req.pendingFundingID]
|
|
|
|
l.limboMtx.RUnlock()
|
|
|
|
if !ok {
|
|
|
|
req.err <- fmt.Errorf("attempted to update non-existant funding state")
|
|
|
|
res.chanOpen <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Grab the mutex on the ChannelReservation to ensure thead-safety
|
|
|
|
res.Lock()
|
|
|
|
defer res.Unlock()
|
|
|
|
|
|
|
|
// Funding complete, this entry can be removed from limbo.
|
|
|
|
l.limboMtx.Lock()
|
|
|
|
delete(l.fundingLimbo, res.reservationID)
|
|
|
|
l.limboMtx.Unlock()
|
|
|
|
|
|
|
|
// Add the complete funding transaction to the DB, in it's open bucket
|
|
|
|
// which will be used for the lifetime of this channel.
|
|
|
|
if err := res.partialState.FullSync(); err != nil {
|
|
|
|
req.err <- err
|
|
|
|
res.chanOpen <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, create and officially open the payment channel!
|
|
|
|
// TODO(roasbeef): CreationTime once tx is 'open'
|
2016-09-12 22:33:22 +03:00
|
|
|
channel, _ := NewLightningChannel(l.Signer, l.chainIO, l.chainNotifier, res.partialState)
|
2016-06-21 20:37:55 +03:00
|
|
|
|
|
|
|
res.chanOpen <- channel
|
|
|
|
req.err <- nil
|
|
|
|
}
|
|
|
|
|
2016-01-07 03:17:18 +03:00
|
|
|
// openChannelAfterConfirmations creates, and opens a payment channel after
|
|
|
|
// the funding transaction created within the passed channel reservation
|
|
|
|
// obtains the specified number of confirmations.
|
2016-06-21 20:37:55 +03:00
|
|
|
func (l *LightningWallet) openChannelAfterConfirmations(res *ChannelReservation) {
|
2016-01-07 03:17:18 +03:00
|
|
|
// Register with the ChainNotifier for a notification once the funding
|
|
|
|
// transaction reaches `numConfs` confirmations.
|
2016-06-21 20:37:55 +03:00
|
|
|
txid := res.fundingTx.TxSha()
|
|
|
|
numConfs := uint32(res.numConfsToOpen)
|
2016-08-04 08:31:20 +03:00
|
|
|
confNtfn, _ := l.chainNotifier.RegisterConfirmationsNtfn(&txid, numConfs)
|
2016-06-21 20:37:55 +03:00
|
|
|
|
2016-07-27 21:28:52 +03:00
|
|
|
walletLog.Infof("Waiting for funding tx (txid: %v) to reach %v confirmations",
|
2016-06-21 20:37:55 +03:00
|
|
|
txid, numConfs)
|
2016-01-07 03:17:18 +03:00
|
|
|
|
2016-02-03 05:40:27 +03:00
|
|
|
// Wait until the specified number of confirmations has been reached,
|
|
|
|
// or the wallet signals a shutdown.
|
|
|
|
out:
|
|
|
|
select {
|
2016-07-15 02:17:01 +03:00
|
|
|
case _, ok := <-confNtfn.Confirmed:
|
|
|
|
// Reading a falsey value for the second parameter indicates that
|
|
|
|
// the notifier is in the process of shutting down. Therefore, we
|
|
|
|
// don't count this as the signal that the funding transaction has
|
|
|
|
// been confirmed.
|
|
|
|
if !ok {
|
|
|
|
res.chanOpen <- nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-02-03 05:40:27 +03:00
|
|
|
break out
|
|
|
|
case <-l.quit:
|
|
|
|
res.chanOpen <- nil
|
|
|
|
return
|
|
|
|
}
|
2016-01-07 03:17:18 +03:00
|
|
|
|
|
|
|
// Finally, create and officially open the payment channel!
|
|
|
|
// TODO(roasbeef): CreationTime once tx is 'open'
|
2016-09-12 22:33:22 +03:00
|
|
|
channel, _ := NewLightningChannel(l.Signer, l.chainIO, l.chainNotifier,
|
2016-01-07 03:17:18 +03:00
|
|
|
res.partialState)
|
|
|
|
res.chanOpen <- channel
|
|
|
|
}
|
|
|
|
|
2016-06-21 20:33:14 +03:00
|
|
|
// selectCoinsAndChange performs coin selection in order to obtain witness
|
|
|
|
// outputs which sum to at least 'numCoins' amount of satoshis. If coin
|
2016-09-13 05:05:56 +03:00
|
|
|
// selection is succesful/possible, then the selected coins are available
|
|
|
|
// within the passed contribution's inputs. If necessary, a change address will
|
|
|
|
// also be generated.
|
2016-06-21 20:33:14 +03:00
|
|
|
// TODO(roasbeef): remove hardcoded fees and req'd confs for outputs.
|
2016-08-13 01:35:33 +03:00
|
|
|
func (l *LightningWallet) selectCoinsAndChange(feeRate uint64, amt btcutil.Amount,
|
2016-06-21 20:33:14 +03:00
|
|
|
contribution *ChannelContribution) error {
|
|
|
|
|
|
|
|
// 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
|
|
|
|
// spends accross 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
|
|
|
|
|
|
|
// Find all unlocked unspent witness outputs with greater than 1
|
|
|
|
// confirmation.
|
|
|
|
// TODO(roasbeef): make num confs a configuration paramter
|
2016-08-13 01:35:33 +03:00
|
|
|
coins, err := l.ListUnspentWitness(1)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Peform 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.
|
2016-08-13 01:35:33 +03:00
|
|
|
selectedCoins, changeAmt, err := coinSelect(feeRate, amt, coins)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2016-08-13 01:35:33 +03:00
|
|
|
contribution.Inputs = make([]*wire.TxIn, len(selectedCoins))
|
|
|
|
for i, coin := range selectedCoins {
|
|
|
|
l.lockedOutPoints[*coin] = struct{}{}
|
|
|
|
l.LockOutpoint(*coin)
|
2016-06-21 20:33:14 +03:00
|
|
|
|
|
|
|
// Empty sig script, we'll actually sign if this reservation is
|
|
|
|
// queued up to be completed (the other side accepts).
|
2016-08-13 01:35:33 +03:00
|
|
|
contribution.Inputs[i] = wire.NewTxIn(coin, nil, nil)
|
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
|
|
|
|
// selection.
|
|
|
|
if changeAmt != 0 {
|
|
|
|
changeAddr, err := l.NewAddress(WitnessPubKey, true)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-08-13 01:35:33 +03:00
|
|
|
changeScript, err := txscript.PayToAddrScript(changeAddr)
|
2016-06-21 20:33:14 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:35:33 +03:00
|
|
|
contribution.ChangeOutputs = make([]*wire.TxOut, 1)
|
|
|
|
contribution.ChangeOutputs[0] = &wire.TxOut{
|
|
|
|
Value: int64(changeAmt),
|
|
|
|
PkScript: changeScript,
|
|
|
|
}
|
2016-06-21 20:33:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-08-13 01:43:16 +03:00
|
|
|
// deriveMasterElkremRoot derives the private key which serves as the master
|
|
|
|
// elkrem root. This master secret is used as the secret input to a HKDF to
|
|
|
|
// generate elkrem secrets based on random, but public data.
|
|
|
|
func (l *LightningWallet) deriveMasterElkremRoot() (*btcec.PrivateKey, error) {
|
|
|
|
masterElkremRoot, err := l.rootKey.Child(elkremRootIndex)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-03-24 10:01:35 +03:00
|
|
|
|
2016-08-13 01:43:16 +03:00
|
|
|
return masterElkremRoot.ECPrivKey()
|
2016-03-24 10:01:35 +03:00
|
|
|
}
|
|
|
|
|
2016-08-13 01:35:33 +03:00
|
|
|
// selectInputs selects a slice of inputs necessary to meet the specified
|
|
|
|
// selection amount. If input selectino is unable to suceed to to insuffcient
|
|
|
|
// 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.
|
|
|
|
func selectInputs(amt btcutil.Amount, coins []*Utxo) (btcutil.Amount, []*wire.OutPoint, error) {
|
|
|
|
var (
|
|
|
|
selectedUtxos []*wire.OutPoint
|
|
|
|
satSelected btcutil.Amount
|
|
|
|
)
|
|
|
|
|
|
|
|
i := 0
|
|
|
|
for satSelected < amt {
|
|
|
|
// If we're about to go past the number of available coins,
|
|
|
|
// then exit with an error.
|
|
|
|
if i > len(coins)-1 {
|
|
|
|
return 0, nil, ErrInsufficientFunds
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, collect this new coin as it may be used for final
|
|
|
|
// coin selection.
|
|
|
|
coin := coins[i]
|
|
|
|
utxo := &wire.OutPoint{
|
|
|
|
Hash: coin.Hash,
|
|
|
|
Index: coin.Index,
|
|
|
|
}
|
|
|
|
|
|
|
|
selectedUtxos = append(selectedUtxos, utxo)
|
|
|
|
satSelected += coin.Value
|
|
|
|
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
|
|
|
|
return satSelected, selectedUtxos, nil
|
2016-03-24 10:01:35 +03:00
|
|
|
}
|
|
|
|
|
2016-08-13 01:35:33 +03:00
|
|
|
// coinSelect attemps to select a sufficient amount of coins, including a
|
|
|
|
// change output to fund amt satoshis, adhearing to the specified fee rate. The
|
|
|
|
// specified fee rate should be expressed in sat/byte for coin selection to
|
|
|
|
// function properly.
|
|
|
|
func coinSelect(feeRate uint64, amt btcutil.Amount,
|
|
|
|
coins []*Utxo) ([]*wire.OutPoint, btcutil.Amount, error) {
|
|
|
|
|
|
|
|
const (
|
|
|
|
// txOverhead is the overhead of a transaction residing within
|
|
|
|
// the version number and lock time.
|
|
|
|
txOverhead = 8
|
|
|
|
|
|
|
|
// p2wkhSpendSize an estimate of the number of bytes it takes
|
|
|
|
// to spend a p2wkh output.
|
|
|
|
//
|
|
|
|
// (p2wkh witness) + txid + index + varint script size + sequence
|
|
|
|
// TODO(roasbeef): div by 3 due to witness size?
|
|
|
|
p2wkhSpendSize = (1 + 73 + 1 + 33) + 32 + 4 + 1 + 4
|
|
|
|
|
|
|
|
// p2wkhOutputSize is an estimate of the size of a regualr
|
|
|
|
// p2wkh output.
|
|
|
|
//
|
|
|
|
// 8 (output) + 1 (var int script) + 22 (p2wkh output)
|
|
|
|
p2wkhOutputSize = 8 + 1 + 22
|
|
|
|
|
|
|
|
// p2wkhOutputSize is an estimate of the p2wsh funding uotput.
|
|
|
|
p2wshOutputSize = 8 + 1 + 34
|
|
|
|
)
|
|
|
|
|
|
|
|
var estimatedSize int
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
// Based on the selected coins, estimate the size of the final
|
|
|
|
// fully signed transaction.
|
|
|
|
estimatedSize = ((len(selectedUtxos) * p2wkhSpendSize) +
|
|
|
|
p2wshOutputSize + txOverhead)
|
|
|
|
|
|
|
|
// The difference bteween the selected amount and the amount
|
|
|
|
// requested will be used to pay fees, and generate a change
|
|
|
|
// output with the remaining.
|
|
|
|
overShootAmt := totalSat - amtNeeded
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
requiredFee := btcutil.Amount(uint64(estimatedSize) * feeRate)
|
|
|
|
if overShootAmt < requiredFee {
|
|
|
|
amtNeeded += requiredFee
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the fee is sufficient, then calculate the size of the change output.
|
|
|
|
changeAmt := overShootAmt - requiredFee
|
|
|
|
|
|
|
|
return selectedUtxos, changeAmt, nil
|
|
|
|
}
|
2016-03-24 10:01:35 +03:00
|
|
|
}
|