e762d328fa
* Final workflow has been greatly simplified. * Interaction is now: * init * add contribution * complete
368 lines
9.7 KiB
Go
368 lines
9.7 KiB
Go
package lnwallet
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
// ChannelContribution...
|
|
type ChannelContribution struct {
|
|
// Amount of funds contributed to the funding transaction.
|
|
FundingAmount btcutil.Amount
|
|
|
|
// Inputs to the funding transaction.
|
|
Inputs []*wire.TxIn
|
|
|
|
// Outputs to be used in the case that the total value of the fund
|
|
// ing inputs is greather than the total potential channel capacity.
|
|
ChangeOutputs []*wire.TxOut
|
|
|
|
// The key to be used for the funding transaction's P2SH multi-sig
|
|
// 2-of-2 output.
|
|
MultiSigKey *btcec.PublicKey
|
|
|
|
// The key to be used for this party's version of the commitment
|
|
// transaction.
|
|
CommitKey *btcec.PublicKey
|
|
|
|
// Address to be used for delivery of cleared channel funds in the scenario
|
|
// of a cooperative channel closure.
|
|
DeliveryAddress btcutil.Address
|
|
|
|
// Hash to be used as the revocation for the initial version of this
|
|
// party's commitment transaction.
|
|
RevocationHash [wire.HashSize]byte
|
|
|
|
// The delay (in blocks) to be used for the pay-to-self output in this
|
|
// party's version of the commitment transaction.
|
|
CsvDelay int64
|
|
}
|
|
|
|
// ChannelReservation...
|
|
type ChannelReservation struct {
|
|
fundingType FundingType
|
|
|
|
// This mutex MUST be held when either reading or modifying any of the
|
|
// fields below.
|
|
sync.RWMutex
|
|
|
|
// For CLTV it is nLockTime, for CSV it's nSequence, for segwit it's
|
|
// not needed
|
|
fundingLockTime int64
|
|
|
|
// In order of sorted inputs. Sorting is done in accordance
|
|
// to BIP-69: https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki.
|
|
ourFundingSigs [][]byte
|
|
theirFundingSigs [][]byte
|
|
|
|
// Our signature for their version of the commitment transaction.
|
|
ourCommitmentSig []byte
|
|
|
|
ourContribution *ChannelContribution
|
|
theirContribution *ChannelContribution
|
|
|
|
partialState *OpenChannelState
|
|
|
|
// The ID of this reservation, used to uniquely track the reservation
|
|
// throughout its lifetime.
|
|
reservationID uint64
|
|
|
|
// A channel which 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.
|
|
chanOpen chan *LightningChannel
|
|
|
|
wallet *LightningWallet
|
|
}
|
|
|
|
// newChannelReservation...
|
|
func newChannelReservation(t FundingType, fundingAmt btcutil.Amount,
|
|
minFeeRate btcutil.Amount, wallet *LightningWallet, id uint64) *ChannelReservation {
|
|
// TODO(roasbeef): CSV here, or on delay?
|
|
return &ChannelReservation{
|
|
fundingType: t,
|
|
ourContribution: &ChannelContribution{
|
|
FundingAmount: fundingAmt,
|
|
},
|
|
theirContribution: &ChannelContribution{
|
|
FundingAmount: fundingAmt,
|
|
},
|
|
partialState: &OpenChannelState{
|
|
// TODO(roasbeef): assumes balanced symmetric channels.
|
|
capacity: fundingAmt * 2,
|
|
minFeePerKb: minFeeRate,
|
|
},
|
|
reservationID: id,
|
|
wallet: wallet,
|
|
}
|
|
}
|
|
|
|
// OurContribution...
|
|
// NOTE: This SHOULD NOT be modified.
|
|
func (r *ChannelReservation) OurContribution() *ChannelContribution {
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
return r.ourContribution
|
|
}
|
|
|
|
// ProcessContribution...
|
|
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
|
|
}
|
|
|
|
func (r *ChannelReservation) TheirContribution() *ChannelContribution {
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
return r.theirContribution
|
|
}
|
|
|
|
// OurSignatures...
|
|
func (r *ChannelReservation) OurSignatures() ([][]byte, []byte) {
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
return r.ourFundingSigs, r.ourCommitmentSig
|
|
}
|
|
|
|
// CompleteFundingReservation...
|
|
// TODO(roasbeef): add commit sig also
|
|
func (r *ChannelReservation) CompleteReservation(fundingSigs [][]byte, commitmentSig []byte) error {
|
|
errChan := make(chan error, 1)
|
|
|
|
r.wallet.msgChan <- &addCounterPartySigsMsg{
|
|
pendingFundingID: r.reservationID,
|
|
theirFundingSigs: fundingSigs,
|
|
theirCommitmentSig: commitmentSig,
|
|
err: errChan,
|
|
}
|
|
|
|
return <-errChan
|
|
}
|
|
|
|
// OurSignatures...
|
|
func (r *ChannelReservation) TheirSignatures() ([][]byte, []byte) {
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
return r.theirFundingSigs, r.partialState.theirCommitSig
|
|
}
|
|
|
|
// FinalFundingTransaction...
|
|
func (r *ChannelReservation) FinalFundingTx() *wire.MsgTx {
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
return r.partialState.fundingTx
|
|
}
|
|
|
|
// RequestFundingReserveCancellation...
|
|
// TODO(roasbeef): also return mutated state?
|
|
func (r *ChannelReservation) Cancel() error {
|
|
errChan := make(chan error, 1)
|
|
r.wallet.msgChan <- &fundingReserveCancelMsg{
|
|
pendingFundingID: r.reservationID,
|
|
err: errChan,
|
|
}
|
|
|
|
return <-errChan
|
|
}
|
|
|
|
// WaitForChannelOpen...
|
|
func (r *ChannelReservation) WaitForChannelOpen() *LightningChannel {
|
|
return nil
|
|
}
|
|
|
|
/*//FundRequest serialize
|
|
//(reading from ChannelReservation directly to reduce the amount of copies)
|
|
//We can move this stuff to another file too if it's too big...
|
|
func (r *ChannelReservation) SerializeFundRequest() ([]byte, error) {
|
|
var err error
|
|
|
|
//Buffer to dump in the serialized data
|
|
b := new(bytes.Buffer)
|
|
|
|
//Fund Request
|
|
err = b.WriteByte(0x30)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//ChannelType (1)
|
|
//Default to current type
|
|
err = b.WriteByte(uint8(0))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//RequesterFundingAmount - The amount we are going to fund (8)
|
|
//check for positive values
|
|
err = binary.Write(b, binary.BigEndian, r.FundingAmount)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//RequesterChannelMinCapacity (8)
|
|
//The amount needed to accept and sign the channel commit later
|
|
err = binary.Write(b, binary.BigEndian, r.MinTotalFundingAmount)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//RevocationHash (20)
|
|
//Our revocation hash being contributed (for CLTV/CSV)
|
|
_, err = b.Write(btcutil.Hash160(r.ourRevocation))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//CommitPubkey (33)
|
|
//Our public key being used for the commitment
|
|
ourPubKey := r.ourKey.PubKey().SerializeCompressed()
|
|
if len(ourPubKey) != 33 { //validation, can remove later? (NO UNCOMPRESSED KEYS!)
|
|
return nil, fmt.Errorf("Serialize FundReq: our Pubkey length incorrect")
|
|
}
|
|
_, err = b.Write(ourPubKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//DeliveryPkHash (20)
|
|
//For now it's a P2PKH, but we will add an extra byte later for the
|
|
//option for P2SH
|
|
//This is the address to send funds to when complete or refunded
|
|
_, err = b.Write(r.ourDeliveryAddress)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//ReserveAmount (8)
|
|
//Our own reserve amount
|
|
err = binary.Write(b, binary.BigEndian, r.ReserveAmount)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//Minimum transaction fee per kb (8)
|
|
err = binary.Write(b, binary.BigEndian, r.MinFeePerKb)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//LockTime (4)
|
|
err = binary.Write(b, binary.BigEndian, r.FundingLockTime)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//Fee payer (default to split currently) (1)
|
|
err = binary.Write(b, binary.BigEndian, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//ChangePkScript
|
|
//Length (1)
|
|
changeScriptLength := len(r.ourChange[0].PkScript)
|
|
if changeScriptLength > 255 {
|
|
return nil, fmt.Errorf("Your changeScriptLength is too long!")
|
|
}
|
|
err = binary.Write(b, binary.BigEndian, uint8(changeScriptLength))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
//For now it's a P2PKH, but we will add an extra byte later for the
|
|
//option for P2SH
|
|
//This is the address to send change to (only allow one)
|
|
//ChangePkScript (length of script)
|
|
_, err = b.Write(r.ourChange[0].PkScript)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//Append the unsigned(!!) txins
|
|
//First one byte for the amount of txins (1)
|
|
if len(r.ourInputs) > 127 {
|
|
return nil, fmt.Errorf("Too many txins")
|
|
}
|
|
err = b.WriteByte(uint8(len(r.ourInputs)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
//Append the actual Txins (NumOfTxins * 36)
|
|
//Do not include the sequence number to eliminate funny business
|
|
for _, in := range r.ourInputs {
|
|
//Hash
|
|
_, err = b.Write(in.PreviousOutPoint.Hash.Bytes())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
//Index
|
|
err = binary.Write(b, binary.BigEndian, in.PreviousOutPoint.Index)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return b.Bytes(), err
|
|
}
|
|
|
|
func (r *ChannelReservation) DeserializeFundRequest(wireMsg []byte) error {
|
|
//Make sure we're not overwriting stuff...
|
|
//Update the channelState to 1 before progressing if you want to re-do it.
|
|
//Assumes only one thread is writing at a time
|
|
if r.channelState > 1 {
|
|
return fmt.Errorf("FundRequest: Channel State Mismatch")
|
|
}
|
|
|
|
var err error
|
|
|
|
b := bytes.NewBuffer(wireMsg)
|
|
msgid, _ := b.ReadByte()
|
|
if msgid != 0x30 {
|
|
return fmt.Errorf("Cannot deserialize: not a funding request")
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
//Update the channel state as complete
|
|
r.channelState = 2
|
|
|
|
return nil
|
|
}
|
|
|
|
//Validation on the data being supplied from the fund request
|
|
func (r *ChannelReservation) ValidateFundRequest(wireMsg []byte) error {
|
|
return nil
|
|
}
|
|
|
|
//Serialize CSV Revocation
|
|
//After the Commitment Transaction has been created, send a message to revoke this tx
|
|
func (r *ChannelReservation) SerializeCSVRefundRevocation() ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
//Deserialize CSV Revocation
|
|
//Validate the revocation, after this step, the channel is fully set up
|
|
func (r *ChannelReservation) DeserializeCSVRefundRevocation() error {
|
|
return nil
|
|
}*/
|
|
|
|
// * finish reset of tests
|
|
// * comment out stuff that'll need a node.
|
|
// * start on commitment side
|
|
// * implement rusty's shachain
|
|
// * set up logic to get notification from node when funding tx gets 6 deep.
|
|
// * prob spawn into ChainNotifier struct
|
|
// * create builder for initial funding transaction
|
|
// * fascade through the wallet, for signing and such.
|
|
// * channel should have active namespace to it's bucket, query at that point fo past commits etc
|