mirror of
https://github.com/lightningnetwork/lnd.git
synced 2025-04-05 10:39:03 +02:00
Merge pull request #384 from cfromknecht/utxn-incubate-2nd-layer-htlcs
Utxo Nursery, adds outgoing 2nd-layer HTLC persistence
This commit is contained in:
Olaoluwa Osuntokun
GitHub
commit
caec23a236
748
lnd_test.go
748
lnd_test.go
@ -753,6 +753,13 @@ func testDisconnectingTargetPeer(net *networkHarness, t *harnessTest) {
|
||||
|
||||
// Check existing connection.
|
||||
assertNumConnections(ctxb, t, net.Alice, net.Bob, 1)
|
||||
|
||||
// Mine enough blocks to clear the force closed outputs from the UTXO
|
||||
// nursery.
|
||||
if _, err := net.Miner.Node.Generate(4); err != nil {
|
||||
t.Fatalf("unable to mine blocks: %v", err)
|
||||
}
|
||||
time.Sleep(300 * time.Millisecond)
|
||||
}
|
||||
|
||||
// testFundingPersistence is intended to ensure that the Funding Manager
|
||||
@ -962,57 +969,248 @@ func testChannelBalance(net *networkHarness, t *harnessTest) {
|
||||
closeChannelAndAssert(ctx, t, net, net.Alice, chanPoint, false)
|
||||
}
|
||||
|
||||
// findForceClosedChannel searches a pending channel response for a particular
|
||||
// channel, returning the force closed channel upon success.
|
||||
func findForceClosedChannel(t *harnessTest,
|
||||
pendingChanResp *lnrpc.PendingChannelResponse,
|
||||
op *wire.OutPoint) *lnrpc.PendingChannelResponse_ForceClosedChannel {
|
||||
|
||||
var found bool
|
||||
var forceClose *lnrpc.PendingChannelResponse_ForceClosedChannel
|
||||
for _, forceClose = range pendingChanResp.PendingForceClosingChannels {
|
||||
if forceClose.Channel.ChannelPoint == op.String() {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Fatalf("channel not marked as force closed")
|
||||
}
|
||||
|
||||
return forceClose
|
||||
}
|
||||
|
||||
func assertCommitmentMaturity(t *harnessTest,
|
||||
forceClose *lnrpc.PendingChannelResponse_ForceClosedChannel,
|
||||
maturityHeight uint32, blocksTilMaturity int32) {
|
||||
|
||||
if forceClose.MaturityHeight != maturityHeight {
|
||||
t.Fatalf("expected commitment maturity height to be %d, "+
|
||||
"found %d instead", maturityHeight,
|
||||
forceClose.MaturityHeight)
|
||||
}
|
||||
if forceClose.BlocksTilMaturity != blocksTilMaturity {
|
||||
t.Fatalf("expected commitment blocks til maturity to be %d, "+
|
||||
"found %d instead", blocksTilMaturity,
|
||||
forceClose.BlocksTilMaturity)
|
||||
}
|
||||
}
|
||||
|
||||
// assertForceClosedChannelNumHtlcs verifies that a force closed channel has the
|
||||
// proper number of htlcs.
|
||||
func assertPendingChannelNumHtlcs(t *harnessTest,
|
||||
forceClose *lnrpc.PendingChannelResponse_ForceClosedChannel,
|
||||
expectedNumHtlcs int) {
|
||||
|
||||
if len(forceClose.PendingHtlcs) != expectedNumHtlcs {
|
||||
t.Fatalf("expected force closed channel to have %d pending "+
|
||||
"htlcs, found %d instead", expectedNumHtlcs,
|
||||
len(forceClose.PendingHtlcs))
|
||||
}
|
||||
}
|
||||
|
||||
// assertNumForceClosedChannels checks that a pending channel response has the
|
||||
// expected number of force closed channels.
|
||||
func assertNumForceClosedChannels(t *harnessTest,
|
||||
pendingChanResp *lnrpc.PendingChannelResponse, expectedNumChans int) {
|
||||
|
||||
if len(pendingChanResp.PendingForceClosingChannels) != expectedNumChans {
|
||||
t.Fatalf("expected to find %d force closed channels, got %d",
|
||||
expectedNumChans,
|
||||
len(pendingChanResp.PendingForceClosingChannels))
|
||||
}
|
||||
}
|
||||
|
||||
// assertPendingHtlcStageAndMaturity uniformly tests all pending htlc's
|
||||
// belonging to a force closed channel, testing for the expeced stage number,
|
||||
// blocks till maturity, and the maturity height.
|
||||
func assertPendingHtlcStageAndMaturity(t *harnessTest,
|
||||
forceClose *lnrpc.PendingChannelResponse_ForceClosedChannel,
|
||||
stage, maturityHeight uint32, blocksTillMaturity int32) {
|
||||
|
||||
for _, pendingHtlc := range forceClose.PendingHtlcs {
|
||||
if pendingHtlc.Stage != stage {
|
||||
t.Fatalf("expected pending htlc to be stage %d, "+
|
||||
"found %d", stage, pendingHtlc.Stage)
|
||||
}
|
||||
if pendingHtlc.MaturityHeight != maturityHeight {
|
||||
t.Fatalf("expected pending htlc maturity height to be "+
|
||||
"%d, instead has %d", maturityHeight,
|
||||
pendingHtlc.MaturityHeight)
|
||||
}
|
||||
if pendingHtlc.BlocksTilMaturity != blocksTillMaturity {
|
||||
t.Fatalf("expected pending htlc blocks til maturity "+
|
||||
"to be %d, instead has %d", blocksTillMaturity,
|
||||
pendingHtlc.BlocksTilMaturity)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// testChannelForceClosure performs a test to exercise the behavior of "force"
|
||||
// closing a channel or unilaterally broadcasting the latest local commitment
|
||||
// state on-chain. The test creates a new channel between Alice and Bob, then
|
||||
// force closes the channel after some cursory assertions. Within the test, two
|
||||
// transactions should be broadcast on-chain, the commitment transaction itself
|
||||
// (which closes the channel), and the sweep transaction a few blocks later
|
||||
// once the output(s) become mature. This test also includes several restarts
|
||||
// to ensure that the transaction output states are persisted throughout
|
||||
// the forced closure process.
|
||||
// state on-chain. The test creates a new channel between Alice and Carol, then
|
||||
// force closes the channel after some cursory assertions. Within the test, a
|
||||
// total of 3 + n transactions will be broadcast, representing the commitment
|
||||
// transaction, a transaction sweeping the local CSV delayed output, a
|
||||
// transaction sweeping the CSV delayed 2nd-layer htlcs outputs, and n
|
||||
// htlc success transactions, where n is the number of payments Alice attempted
|
||||
// to send to Carol. This test includes several restarts to ensure that the
|
||||
// transaction output states are persisted throughout the forced closure
|
||||
// process.
|
||||
//
|
||||
// TODO(roasbeef): also add an unsettled HTLC before force closing.
|
||||
func testChannelForceClosure(net *networkHarness, t *harnessTest) {
|
||||
timeout := time.Duration(time.Second * 10)
|
||||
|
||||
ctxb := context.Background()
|
||||
const (
|
||||
timeout = time.Duration(time.Second * 10)
|
||||
chanAmt = btcutil.Amount(10e6)
|
||||
pushAmt = btcutil.Amount(5e6)
|
||||
paymentAmt = 100000
|
||||
numInvoices = 6
|
||||
)
|
||||
|
||||
// Before we start, obtain Bob's current wallet balance, we'll check to
|
||||
// ensure that at the end of the force closure by Alice, Bob recognizes
|
||||
// his new on-chain output.
|
||||
bobBalReq := &lnrpc.WalletBalanceRequest{}
|
||||
bobBalResp, err := net.Bob.WalletBalance(ctxb, bobBalReq)
|
||||
// TODO(roasbeef): should check default value in config here
|
||||
// instead, or make delay a param
|
||||
defaultCSV := uint32(4)
|
||||
defaultCLTV := defaultBitcoinForwardingPolicy.TimeLockDelta
|
||||
|
||||
// Since we'd like to test failure scenarios with outstanding htlcs,
|
||||
// we'll introduce another node into our test network: Carol.
|
||||
carol, err := net.NewNode([]string{"--debughtlc", "--hodlhtlc"})
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get bob's balance: %v", err)
|
||||
t.Fatalf("unable to create new nodes: %v", err)
|
||||
}
|
||||
bobStartingBalance := btcutil.Amount(bobBalResp.Balance * 1e8)
|
||||
|
||||
// First establish a channel with a capacity of 100k satoshis between
|
||||
// Alice and Bob. We also push 50k satoshis of the initial amount
|
||||
// towards Bob.
|
||||
numFundingConfs := uint32(1)
|
||||
chanAmt := btcutil.Amount(10e4)
|
||||
pushAmt := btcutil.Amount(5e4)
|
||||
chanOpenUpdate, err := net.OpenChannel(ctxb, net.Alice, net.Bob,
|
||||
chanAmt, pushAmt)
|
||||
// We must let Alice have an open channel before she can send a node
|
||||
// announcement, so we open a channel with Carol,
|
||||
if err := net.ConnectNodes(ctxb, net.Alice, carol); err != nil {
|
||||
t.Fatalf("unable to connect alice to carol: %v", err)
|
||||
}
|
||||
|
||||
// Before we start, obtain Carol's current wallet balance, we'll check
|
||||
// to ensure that at the end of the force closure by Alice, Carol
|
||||
// recognizes his new on-chain output.
|
||||
carolBalReq := &lnrpc.WalletBalanceRequest{}
|
||||
carolBalResp, err := carol.WalletBalance(ctxb, carolBalReq)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel: %v", err)
|
||||
t.Fatalf("unable to get carol's balance: %v", err)
|
||||
}
|
||||
|
||||
if _, err := net.Miner.Node.Generate(numFundingConfs); err != nil {
|
||||
t.Fatalf("unable to mine block: %v", err)
|
||||
}
|
||||
carolStartingBalance := btcutil.Amount(carolBalResp.Balance * 1e8)
|
||||
|
||||
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
||||
chanPoint, err := net.WaitForChannelOpen(ctxt, chanOpenUpdate)
|
||||
chanPoint := openChannelAndAssert(ctxt, t, net, net.Alice, carol,
|
||||
chanAmt, pushAmt)
|
||||
|
||||
// Wait for Alice to receive the channel edge from the funding manager.
|
||||
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
||||
err = net.Alice.WaitForNetworkChannelOpen(ctxt, chanPoint)
|
||||
if err != nil {
|
||||
t.Fatalf("error while waiting for channel to open: %v", err)
|
||||
t.Fatalf("alice didn't see the alice->carol channel before "+
|
||||
"timeout: %v", err)
|
||||
}
|
||||
|
||||
// Now that the channel is open, immediately execute a force closure of
|
||||
// the channel. This will also assert that the commitment transaction
|
||||
// was immediately broadcast in order to fulfill the force closure
|
||||
// request.
|
||||
// With the channel open, we'll create a few invoices for Carol that
|
||||
// Alice will pay to in order to advance the state of the channel.
|
||||
carolPaymentReqs := make([]string, numInvoices)
|
||||
for i := 0; i < numInvoices; i++ {
|
||||
preimage := bytes.Repeat([]byte{byte(128 - i)}, 32)
|
||||
invoice := &lnrpc.Invoice{
|
||||
Memo: "testing",
|
||||
RPreimage: preimage,
|
||||
Value: paymentAmt,
|
||||
}
|
||||
resp, err := carol.AddInvoice(ctxb, invoice)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to add invoice: %v", err)
|
||||
}
|
||||
|
||||
carolPaymentReqs[i] = resp.PaymentRequest
|
||||
}
|
||||
|
||||
// As we'll be querying the state of Carols's channels frequently we'll
|
||||
// create a closure helper function for the purpose.
|
||||
getAliceChanInfo := func() (*lnrpc.ActiveChannel, error) {
|
||||
req := &lnrpc.ListChannelsRequest{}
|
||||
aliceChannelInfo, err := net.Alice.ListChannels(ctxb, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(aliceChannelInfo.Channels) != 1 {
|
||||
t.Fatalf("alice should only have a single channel, "+
|
||||
"instead he has %v",
|
||||
len(aliceChannelInfo.Channels))
|
||||
}
|
||||
|
||||
return aliceChannelInfo.Channels[0], nil
|
||||
}
|
||||
|
||||
// Open up a payment stream to Alice that we'll use to send payment to
|
||||
// Carol. We also create a small helper function to send payments to
|
||||
// Carol, consuming the payment hashes we generated above.
|
||||
alicePayStream, err := net.Alice.SendPayment(ctxb)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to create payment stream for alice: %v", err)
|
||||
}
|
||||
sendPayments := func(start, stop int) error {
|
||||
for i := start; i < stop; i++ {
|
||||
sendReq := &lnrpc.SendRequest{
|
||||
PaymentRequest: carolPaymentReqs[i],
|
||||
}
|
||||
if err := alicePayStream.Send(sendReq); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Fetch starting height of this test so we can compute the block
|
||||
// heights we expect certain events to take place.
|
||||
_, curHeight, err := net.Miner.Node.GetBestBlock()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get best block height")
|
||||
}
|
||||
|
||||
// Using the current height of the chain, derive the relevant heights
|
||||
// for incubating two-stage htlcs.
|
||||
var (
|
||||
startHeight = uint32(curHeight)
|
||||
commCsvMaturityHeight = startHeight + 1 + defaultCSV
|
||||
htlcExpiryHeight = startHeight + defaultCLTV
|
||||
htlcCsvMaturityHeight = startHeight + defaultCLTV + 1 + defaultCSV
|
||||
)
|
||||
|
||||
// Send payments from Alice to Carol, since Carol is htlchodl mode,
|
||||
// the htlc outputs should be left unsettled, and should be swept by the
|
||||
// utxo nursery.
|
||||
if err := sendPayments(0, numInvoices); err != nil {
|
||||
t.Fatalf("unable to send payment: %v", err)
|
||||
}
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
aliceChan, err := getAliceChanInfo()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get alice's channel info: %v", err)
|
||||
}
|
||||
if aliceChan.NumUpdates == 0 {
|
||||
t.Fatalf("alice should see at least one update to her channel")
|
||||
}
|
||||
|
||||
// Now that the channel is open and we have unsettled htlcs, immediately
|
||||
// execute a force closure of the channel. This will also assert that
|
||||
// the commitment transaction was immediately broadcast in order to
|
||||
// fulfill the force closure request.
|
||||
_, closingTxID, err := net.CloseChannel(ctxb, net.Alice, chanPoint, true)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to execute force channel closure: %v", err)
|
||||
@ -1025,25 +1223,41 @@ func testChannelForceClosure(net *networkHarness, t *harnessTest) {
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
var found bool
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
// Compute the outpoint of the channel, which we will use repeatedly to
|
||||
// locate the pending channel information in the rpc responses.
|
||||
txid, _ := chainhash.NewHash(chanPoint.FundingTxid[:])
|
||||
op := wire.OutPoint{
|
||||
Hash: *txid,
|
||||
Index: chanPoint.OutputIndex,
|
||||
}
|
||||
for _, forceClose := range pendingChanResp.PendingForceClosingChannels {
|
||||
if forceClose.Channel.ChannelPoint == op.String() {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
|
||||
forceClose := findForceClosedChannel(t, pendingChanResp, &op)
|
||||
|
||||
// Immediately after force closing, all of the funds should be in limbo,
|
||||
// and the pending channels response should not indicate that any funds
|
||||
// have been recovered.
|
||||
if forceClose.LimboBalance == 0 {
|
||||
t.Fatalf("all funds should still be in limbo")
|
||||
}
|
||||
if !found {
|
||||
t.Fatalf("channel not marked as force close for alice")
|
||||
if forceClose.RecoveredBalance != 0 {
|
||||
t.Fatalf("no funds should yet be shown as recovered")
|
||||
}
|
||||
|
||||
// TODO(roasbeef): should check default value in config here instead,
|
||||
// or make delay a param
|
||||
const defaultCSV = 4
|
||||
// The commitment transaction has not been confirmed, so we expect to
|
||||
// see a maturity height and blocks til maturity of 0.
|
||||
assertCommitmentMaturity(t, forceClose, 0, 0)
|
||||
|
||||
// Since all of our payments were sent with Carol in hodl mode, all of
|
||||
// them should be unsettled and attached to the commitment transaction.
|
||||
// They also should have been configured such that they are not filtered
|
||||
// as dust. At this point, all pending htlcs should be in stage 1, with
|
||||
// a timeout set to the default CLTV expiry (144) blocks above the
|
||||
// starting height.
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 1, htlcExpiryHeight,
|
||||
int32(defaultCLTV))
|
||||
|
||||
// The several restarts in this test are intended to ensure that when a
|
||||
// channel is force-closed, the UTXO nursery has persisted the state of
|
||||
@ -1071,23 +1285,31 @@ func testChannelForceClosure(net *networkHarness, t *harnessTest) {
|
||||
duration := time.Millisecond * 300
|
||||
time.Sleep(duration)
|
||||
|
||||
// Now that the channel has been force closed, it should now have the
|
||||
// height and number of blocks to confirm populated.
|
||||
pendingChan, err := net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
if len(pendingChan.PendingForceClosingChannels) == 0 {
|
||||
t.Fatalf("channel not marked as force close for alice")
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
forceClose = findForceClosedChannel(t, pendingChanResp, &op)
|
||||
|
||||
// Now that the channel has been force closed, it should now have the
|
||||
// height and number of blocks to confirm populated.
|
||||
assertCommitmentMaturity(t, forceClose, commCsvMaturityHeight,
|
||||
int32(defaultCSV))
|
||||
|
||||
// Check that our pending htlcs have deducted the block confirming the
|
||||
// commitment transactionfrom their blocks til maturity value.
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 1, htlcExpiryHeight,
|
||||
int32(defaultCLTV)-1)
|
||||
|
||||
// None of our outputs have been swept, so they should all be limbo.
|
||||
if forceClose.LimboBalance == 0 {
|
||||
t.Fatalf("all funds should still be in limbo")
|
||||
}
|
||||
forceClosedChan := pendingChan.PendingForceClosingChannels[0]
|
||||
if forceClosedChan.MaturityHeight == 0 {
|
||||
t.Fatalf("force close channel marked as not confirmed")
|
||||
}
|
||||
if forceClosedChan.BlocksTilMaturity != defaultCSV {
|
||||
t.Fatalf("force closed channel has incorrect maturity time: "+
|
||||
"expected %v, got %v", forceClosedChan.BlocksTilMaturity,
|
||||
defaultCSV)
|
||||
if forceClose.RecoveredBalance != 0 {
|
||||
t.Fatalf("no funds should yet be shown as recovered")
|
||||
}
|
||||
|
||||
// The following restart is intended to ensure that outputs from the
|
||||
@ -1106,13 +1328,40 @@ func testChannelForceClosure(net *networkHarness, t *harnessTest) {
|
||||
t.Fatalf("unable to mine blocks: %v", err)
|
||||
}
|
||||
|
||||
// The following restart checks to ensure that outputs in the kindergarten
|
||||
// bucket are persisted while waiting for the required number of
|
||||
// confirmations to be reported.
|
||||
// The following restart checks to ensure that outputs in the
|
||||
// kindergarten bucket are persisted while waiting for the required
|
||||
// number of confirmations to be reported.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
forceClose = findForceClosedChannel(t, pendingChanResp, &op)
|
||||
|
||||
// At this point, the nursery should show that the commitment output has
|
||||
// 1 block left before its CSV delay expires. In total, we have mined
|
||||
// exactly defaultCSV blocks, so the htlc outputs should also reflect
|
||||
// that this many blocks have passed.
|
||||
assertCommitmentMaturity(t, forceClose, commCsvMaturityHeight, 1)
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 1, htlcExpiryHeight,
|
||||
int32(defaultCLTV)-int32(defaultCSV))
|
||||
|
||||
// All funds should still be shown in limbo.
|
||||
if forceClose.LimboBalance == 0 {
|
||||
t.Fatalf("all funds should still be in limbo")
|
||||
}
|
||||
if forceClose.RecoveredBalance != 0 {
|
||||
t.Fatalf("no funds should yet be shown as recovered")
|
||||
}
|
||||
|
||||
// Generate an additional block, which should cause the CSV delayed
|
||||
// output from the commitment txn to expire.
|
||||
if _, err := net.Miner.Node.Generate(1); err != nil {
|
||||
t.Fatalf("unable to mine blocks: %v", err)
|
||||
}
|
||||
@ -1120,37 +1369,11 @@ func testChannelForceClosure(net *networkHarness, t *harnessTest) {
|
||||
// At this point, the sweeping transaction should now be broadcast. So
|
||||
// we fetch the node's mempool to ensure it has been properly
|
||||
// broadcast.
|
||||
var sweepingTXID *chainhash.Hash
|
||||
var mempool []*chainhash.Hash
|
||||
mempoolTimeout := time.After(3 * time.Second)
|
||||
checkMempoolTick := time.NewTicker(100 * time.Millisecond)
|
||||
defer checkMempoolTick.Stop()
|
||||
mempoolPoll:
|
||||
for {
|
||||
select {
|
||||
case <-mempoolTimeout:
|
||||
t.Fatalf("sweep tx not found in mempool")
|
||||
case <-checkMempoolTick.C:
|
||||
mempool, err = net.Miner.Node.GetRawMempool()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to fetch node's mempool: %v", err)
|
||||
}
|
||||
if len(mempool) != 0 {
|
||||
break mempoolPoll
|
||||
}
|
||||
}
|
||||
sweepingTXID, err := waitForTxInMempool(net.Miner.Node, 3*time.Second)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to get sweep tx from mempool: %v", err)
|
||||
}
|
||||
|
||||
// There should be exactly one transaction within the mempool at this
|
||||
// point.
|
||||
// TODO(roasbeef): assertion may not necessarily hold with concurrent
|
||||
// test executions
|
||||
if len(mempool) != 1 {
|
||||
t.Fatalf("node's mempool is wrong size, expected 1 got %v",
|
||||
len(mempool))
|
||||
}
|
||||
sweepingTXID = mempool[0]
|
||||
|
||||
// Fetch the sweep transaction, all input it's spending should be from
|
||||
// the commitment transaction which was broadcast on-chain.
|
||||
sweepTx, err := net.Miner.Node.GetRawTransaction(sweepingTXID)
|
||||
@ -1165,7 +1388,13 @@ mempoolPoll:
|
||||
}
|
||||
}
|
||||
|
||||
// Finally, we mine an additional block which should include the sweep
|
||||
// Restart Alice to ensure that she resumes watching the finalized
|
||||
// commitment sweep txid.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
|
||||
// Next, we mine an additional block which should include the sweep
|
||||
// transaction as the input scripts and the sequence locks on the
|
||||
// inputs should be properly met.
|
||||
blockHash, err := net.Miner.Node.Generate(1)
|
||||
@ -1179,28 +1408,309 @@ mempoolPoll:
|
||||
|
||||
assertTxInBlock(t, block, sweepTx.Hash())
|
||||
|
||||
// Now that the channel has been fully swept, it should no longer show
|
||||
// up within the pending channels RPC.
|
||||
time.Sleep(time.Millisecond * 300)
|
||||
pendingChans, err := net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
// We sleep here to ensure that Alice has enough time to receive a
|
||||
// confirmation for the commitment transaction, which we already
|
||||
// asserted was in the last block.
|
||||
time.Sleep(300 * time.Millisecond)
|
||||
|
||||
// Now that the commit output has been fully swept, check to see that
|
||||
// the channel remains open for the pending htlc outputs.
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
if len(pendingChans.PendingForceClosingChannels) != 0 {
|
||||
t.Fatalf("no channels should be shown as force closed")
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
// Check that the commitment transactions shows that we are still past
|
||||
// the maturity of the commitment output.
|
||||
forceClose = findForceClosedChannel(t, pendingChanResp, &op)
|
||||
assertCommitmentMaturity(t, forceClose, commCsvMaturityHeight, -1)
|
||||
|
||||
// Our pending htlcs should still be shown in the first stage, having
|
||||
// deducted an additional two blocks from the relative maturity time..
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 1, htlcExpiryHeight,
|
||||
int32(defaultCLTV)-int32(defaultCSV)-2)
|
||||
|
||||
// The htlc funds will still be shown as limbo, since they are still in
|
||||
// their first stage. The commitment funds will have been recovered
|
||||
// after the commit txn was included in the last block.
|
||||
if forceClose.LimboBalance == 0 {
|
||||
t.Fatalf("htlc funds should still be in limbo")
|
||||
}
|
||||
if forceClose.RecoveredBalance == 0 {
|
||||
t.Fatalf("commitment funds should be shown as recovered")
|
||||
}
|
||||
|
||||
// At this point, Bob should now be aware of his new immediately
|
||||
// Compute the height preceding that which will cause the htlc CLTV
|
||||
// timeouts will expire. The outputs entered at the same height as the
|
||||
// output spending from the commitment txn, so we must deduct the number
|
||||
// of blocks we have generated since adding it to the nursery, and take
|
||||
// an additional block off so that we end up one block shy of the expiry
|
||||
// height.
|
||||
cltvHeightDelta := defaultCLTV - defaultCSV - 2 - 1
|
||||
|
||||
// Check that our htlcs are still expected to expire the computed expiry
|
||||
// height, and that the remaining number of blocks is equal to the delta
|
||||
// we just computed, including an additional block to actually trigger
|
||||
// the broadcast.
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 1, htlcExpiryHeight,
|
||||
int32(cltvHeightDelta+1))
|
||||
|
||||
// Advance the blockchain until just before the CLTV expires, nothing
|
||||
// exciting should have happened during this time.
|
||||
blockHash, err = net.Miner.Node.Generate(cltvHeightDelta)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to generate block: %v", err)
|
||||
}
|
||||
time.Sleep(duration)
|
||||
|
||||
// We now restart Alice, to ensure that she will broadcast the presigned
|
||||
// htlc timeout txns after the delay expires after experiencing an while
|
||||
// waiting for the htlc outputs to incubate.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
time.Sleep(duration)
|
||||
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
forceClose = findForceClosedChannel(t, pendingChanResp, &op)
|
||||
|
||||
// Verify that commitment output was confirmed many moons ago.
|
||||
assertCommitmentMaturity(t, forceClose, commCsvMaturityHeight,
|
||||
-int32(cltvHeightDelta)-1)
|
||||
|
||||
// We should now be at the block just before the utxo nursery will
|
||||
// attempt to broadcast the htlc timeout transactions.
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 1, htlcExpiryHeight, 1)
|
||||
|
||||
// Now that our commitment confirmation depth has been surpassed, we
|
||||
// should now see a non-zero recovered balance. All htlc outputs are
|
||||
// still left in limbo, so it should be non-zero as well.
|
||||
if forceClose.LimboBalance == 0 {
|
||||
t.Fatalf("htlc funds should still be in limbo")
|
||||
}
|
||||
if forceClose.RecoveredBalance == 0 {
|
||||
t.Fatalf("commitment funds should not be in limbo")
|
||||
}
|
||||
|
||||
// Now, generate the block which will cause Alice to broadcast the
|
||||
// presigned htlc timeout txns.
|
||||
blockHash, err = net.Miner.Node.Generate(1)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to generate block: %v", err)
|
||||
}
|
||||
|
||||
// Since Alice had numInvoices (6) htlcs extended to Carol before force
|
||||
// closing, we expect Alice to broadcast an htlc timeout txn for each
|
||||
// one. Wait for them all to show up in the mempool.
|
||||
htlcTxIDs, err := waitForNTxsInMempool(net.Miner.Node, numInvoices,
|
||||
3*time.Second)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to find htlc timeout txns in mempool: %v", err)
|
||||
}
|
||||
|
||||
// Retrieve each htlc timeout txn from the mempool, and ensure it is
|
||||
// well-formed. This entails verifying that each only spends from
|
||||
// output, and that that output is from the commitment txn.
|
||||
for _, htlcTxID := range htlcTxIDs {
|
||||
// Fetch the sweep transaction, all input it's spending should
|
||||
// be from the commitment transaction which was broadcast
|
||||
// on-chain.
|
||||
htlcTx, err := net.Miner.Node.GetRawTransaction(htlcTxID)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to fetch sweep tx: %v", err)
|
||||
}
|
||||
// Ensure the htlc transaction only has one input.
|
||||
if len(htlcTx.MsgTx().TxIn) != 1 {
|
||||
t.Fatalf("htlc transaction should only have one txin, "+
|
||||
"has %d", len(htlcTx.MsgTx().TxIn))
|
||||
}
|
||||
// Ensure the htlc transaction is spending from the commitment
|
||||
// transaction.
|
||||
txIn := htlcTx.MsgTx().TxIn[0]
|
||||
if !closingTxID.IsEqual(&txIn.PreviousOutPoint.Hash) {
|
||||
t.Fatalf("htlc transaction not spending from commit "+
|
||||
"tx %v, instead spending %v",
|
||||
closingTxID, txIn.PreviousOutPoint)
|
||||
}
|
||||
}
|
||||
|
||||
// With the htlc timeout txns still in the mempool, we restart Alice to
|
||||
// verify that she can resume watching the htlc txns she broadcasted
|
||||
// before crashing.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
time.Sleep(duration)
|
||||
|
||||
// Generate a block that mines the htlc timeout txns. Doing so now
|
||||
// activates the 2nd-stage CSV delayed outputs.
|
||||
blockHash, err = net.Miner.Node.Generate(1)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to generate block: %v", err)
|
||||
}
|
||||
// This sleep gives Alice enough to time move the crib outputs into the
|
||||
// kindergarten bucket.
|
||||
time.Sleep(duration)
|
||||
|
||||
// Alice is restarted here to ensure that she promptly moved the crib
|
||||
// outputs to the kindergarten bucket after the htlc timeout txns were
|
||||
// confirmed.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
|
||||
// Advance the chain until just before the 2nd-layer CSV delays expire.
|
||||
blockHash, err = net.Miner.Node.Generate(defaultCSV - 1)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to generate block: %v", err)
|
||||
}
|
||||
|
||||
// Restart Alice to ensure that she can recover from a failure before
|
||||
// having graduated the htlc outputs in the kindergarten bucket.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
|
||||
// Now that the channel has been fully swept, it should no longer show
|
||||
// incubated, check to see that Alice's node still reports the channel
|
||||
// as pending force closed.
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
forceClose = findForceClosedChannel(t, pendingChanResp, &op)
|
||||
assertCommitmentMaturity(t, forceClose, commCsvMaturityHeight,
|
||||
-int32(cltvHeightDelta)-int32(defaultCSV)-2)
|
||||
|
||||
if forceClose.LimboBalance == 0 {
|
||||
t.Fatalf("htlc funds should still be in limbo")
|
||||
}
|
||||
if forceClose.RecoveredBalance == 0 {
|
||||
t.Fatalf("commitment funds should not be in limbo")
|
||||
}
|
||||
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
|
||||
// Generate a block that causes Alice to sweep the htlc outputs in the
|
||||
// kindergarten bucket.
|
||||
blockHash, err = net.Miner.Node.Generate(1)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to generate block: %v", err)
|
||||
}
|
||||
|
||||
// Wait for the single sweep txn to appear in the mempool.
|
||||
htlcSweepTxID, err := waitForTxInMempool(net.Miner.Node, 3*time.Second)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to get sweep tx from mempool: %v", err)
|
||||
}
|
||||
|
||||
// Construct a map of the already confirmed htlc timeout txids, that
|
||||
// will count the number of times each is spent by the sweep txn. We
|
||||
// prepopulate it in this way so that we can later detect if we are
|
||||
// spending from an output that was not a confirmed htlc timeout txn.
|
||||
var htlcTxIDSet = make(map[chainhash.Hash]int)
|
||||
for _, htlcTxID := range htlcTxIDs {
|
||||
htlcTxIDSet[*htlcTxID] = 0
|
||||
}
|
||||
|
||||
// Fetch the htlc sweep transaction from the mempool.
|
||||
htlcSweepTx, err := net.Miner.Node.GetRawTransaction(htlcSweepTxID)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to fetch sweep tx: %v", err)
|
||||
}
|
||||
// Ensure the htlc sweep transaction only has one input for each htlc
|
||||
// Alice extended before force closing.
|
||||
if len(htlcSweepTx.MsgTx().TxIn) != numInvoices {
|
||||
t.Fatalf("htlc transaction should have %d txin, "+
|
||||
"has %d", numInvoices, len(htlcSweepTx.MsgTx().TxIn))
|
||||
}
|
||||
// Ensure that each output spends from exactly one htlc timeout txn.
|
||||
for _, txIn := range htlcSweepTx.MsgTx().TxIn {
|
||||
outpoint := txIn.PreviousOutPoint.Hash
|
||||
// Check that the input is a confirmed htlc timeout txn.
|
||||
if _, ok := htlcTxIDSet[outpoint]; !ok {
|
||||
t.Fatalf("htlc sweep output not spending from htlc "+
|
||||
"tx, instead spending output %v", outpoint)
|
||||
}
|
||||
// Increment our count for how many times this output was spent.
|
||||
htlcTxIDSet[outpoint]++
|
||||
|
||||
// Check that each is only spent once.
|
||||
if htlcTxIDSet[outpoint] > 1 {
|
||||
t.Fatalf("htlc sweep tx has multiple spends from "+
|
||||
"outpoint %v", outpoint)
|
||||
}
|
||||
}
|
||||
|
||||
// The following restart checks to ensure that the nursery store is
|
||||
// storing the txid of the previously broadcast htlc sweep txn, and that
|
||||
// it begins watching that txid after restarting.
|
||||
if err := net.RestartNode(net.Alice, nil); err != nil {
|
||||
t.Fatalf("Node restart failed: %v", err)
|
||||
}
|
||||
time.Sleep(duration)
|
||||
|
||||
// Now that the channel has been fully swept, it should no longer show
|
||||
// incubated, check to see that Alice's node still reports the channel
|
||||
// as pending force closed.
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 1)
|
||||
|
||||
// All htlcs should show zero blocks until maturity, as evidenced by
|
||||
// having checked the sweep transaction in the mempool.
|
||||
forceClose = findForceClosedChannel(t, pendingChanResp, &op)
|
||||
assertPendingChannelNumHtlcs(t, forceClose, numInvoices)
|
||||
assertPendingHtlcStageAndMaturity(t, forceClose, 2,
|
||||
htlcCsvMaturityHeight, 0)
|
||||
|
||||
// Generate the final block that sweeps all htlc funds into the user's
|
||||
// wallet.
|
||||
blockHash, err = net.Miner.Node.Generate(1)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to generate block: %v", err)
|
||||
}
|
||||
time.Sleep(3 * duration)
|
||||
|
||||
// Now that the channel has been fully swept, it should no longer show
|
||||
// up within the pending channels RPC.
|
||||
pendingChanResp, err = net.Alice.PendingChannels(ctxb, pendingChansRequest)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to query for pending channels: %v", err)
|
||||
}
|
||||
assertNumForceClosedChannels(t, pendingChanResp, 0)
|
||||
|
||||
// In addition to there being no pending channels, we verify that
|
||||
// pending channels does not report any money still in limbo.
|
||||
if pendingChanResp.TotalLimboBalance != 0 {
|
||||
t.Fatalf("no user funds should be left in limbo after incubation")
|
||||
}
|
||||
|
||||
// At this point, Carol should now be aware of his new immediately
|
||||
// spendable on-chain balance, as it was Alice who broadcast the
|
||||
// commitment transaction.
|
||||
bobBalResp, err = net.Bob.WalletBalance(ctxb, bobBalReq)
|
||||
carolBalResp, err = net.Bob.WalletBalance(ctxb, carolBalReq)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get bob's balance: %v", err)
|
||||
t.Fatalf("unable to get carol's balance: %v", err)
|
||||
}
|
||||
bobExpectedBalance := bobStartingBalance + pushAmt
|
||||
if btcutil.Amount(bobBalResp.Balance*1e8) < bobExpectedBalance {
|
||||
t.Fatalf("bob's balance is incorrect: expected %v got %v",
|
||||
bobExpectedBalance, btcutil.Amount(bobBalResp.Balance*1e8))
|
||||
carolExpectedBalance := carolStartingBalance + pushAmt
|
||||
if btcutil.Amount(carolBalResp.Balance*1e8) < carolExpectedBalance {
|
||||
t.Fatalf("carol's balance is incorrect: expected %v got %v",
|
||||
carolExpectedBalance,
|
||||
btcutil.Amount(carolBalResp.Balance*1e8))
|
||||
}
|
||||
}
|
||||
|
||||
@ -1984,6 +2494,36 @@ poll:
|
||||
return txid, nil
|
||||
}
|
||||
|
||||
// waitForNTxsInMempool polls until finding the desired number of transactions
|
||||
// in the provided miner's mempool. An error is returned if the this number is
|
||||
// not met after the given timeout.
|
||||
func waitForNTxsInMempool(miner *rpcclient.Client, n int,
|
||||
timeout time.Duration) ([]*chainhash.Hash, error) {
|
||||
|
||||
breakTimeout := time.After(timeout)
|
||||
ticker := time.NewTicker(50 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
var err error
|
||||
var mempool []*chainhash.Hash
|
||||
for {
|
||||
select {
|
||||
case <-breakTimeout:
|
||||
return nil, fmt.Errorf("wanted %v, only found %v txs "+
|
||||
"in mempool", n, len(mempool))
|
||||
case <-ticker.C:
|
||||
mempool, err = miner.GetRawMempool()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(mempool) == n {
|
||||
return mempool, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// testRevokedCloseRetributinPostBreachConf tests that Alice is able carry out
|
||||
// retribution in the event that she fails immediately after detecting Bob's
|
||||
// breach txn in the mempool.
|
||||
@ -3613,7 +4153,7 @@ func testBidirectionalAsyncPayments(net *networkHarness, t *harnessTest) {
|
||||
|
||||
const (
|
||||
timeout = time.Duration(time.Second * 5)
|
||||
paymentAmt = 100
|
||||
paymentAmt = 1000
|
||||
)
|
||||
|
||||
// First establish a channel with a capacity equals to the overall
|
||||
|
||||
795
lnrpc/rpc.pb.go
795
lnrpc/rpc.pb.go
File diff suppressed because it is too large
Load Diff
@ -564,7 +564,15 @@ func RegisterWalletUnlockerHandlerFromEndpoint(ctx context.Context, mux *runtime
|
||||
// RegisterWalletUnlockerHandler registers the http handlers for service WalletUnlocker to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over "conn".
|
||||
func RegisterWalletUnlockerHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
||||
client := NewWalletUnlockerClient(conn)
|
||||
return RegisterWalletUnlockerHandlerClient(ctx, mux, NewWalletUnlockerClient(conn))
|
||||
}
|
||||
|
||||
// RegisterWalletUnlockerHandler registers the http handlers for service WalletUnlocker to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over the given implementation of "WalletUnlockerClient".
|
||||
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WalletUnlockerClient"
|
||||
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
||||
// "WalletUnlockerClient" to call the correct interceptors.
|
||||
func RegisterWalletUnlockerHandlerClient(ctx context.Context, mux *runtime.ServeMux, client WalletUnlockerClient) error {
|
||||
|
||||
mux.Handle("POST", pattern_WalletUnlocker_CreateWallet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
@ -667,7 +675,15 @@ func RegisterLightningHandlerFromEndpoint(ctx context.Context, mux *runtime.Serv
|
||||
// RegisterLightningHandler registers the http handlers for service Lightning to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over "conn".
|
||||
func RegisterLightningHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
||||
client := NewLightningClient(conn)
|
||||
return RegisterLightningHandlerClient(ctx, mux, NewLightningClient(conn))
|
||||
}
|
||||
|
||||
// RegisterLightningHandler registers the http handlers for service Lightning to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over the given implementation of "LightningClient".
|
||||
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LightningClient"
|
||||
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
||||
// "LightningClient" to call the correct interceptors.
|
||||
func RegisterLightningHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LightningClient) error {
|
||||
|
||||
mux.Handle("GET", pattern_Lightning_WalletBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
|
||||
@ -840,6 +840,31 @@ message OpenStatusUpdate {
|
||||
}
|
||||
}
|
||||
|
||||
message PendingHTLC {
|
||||
|
||||
/// The direction within the channel that the htlc was sent
|
||||
bool incoming = 1 [ json_name = "incoming" ];
|
||||
|
||||
/// The total value of the htlc
|
||||
int64 amount = 2 [ json_name = "amount" ];
|
||||
|
||||
/// The final output to be swept back to the user's wallet
|
||||
string outpoint = 3 [ json_name = "outpoint" ];
|
||||
|
||||
/// The next block height at which we can spend the current stage
|
||||
uint32 maturity_height = 4 [ json_name = "maturity_height" ];
|
||||
|
||||
/**
|
||||
The number of blocks remaining until the current stage can be swept.
|
||||
Negative values indicate how many blocks have passed since becoming
|
||||
mature.
|
||||
*/
|
||||
int32 blocks_til_maturity = 5 [ json_name = "blocks_til_maturity" ];
|
||||
|
||||
/// Indicates whether the htlc is in its first or second stage of recovery
|
||||
uint32 stage = 6 [ json_name = "stage" ];
|
||||
}
|
||||
|
||||
message PendingChannelRequest {}
|
||||
message PendingChannelResponse {
|
||||
message PendingChannel {
|
||||
@ -894,8 +919,6 @@ message PendingChannelResponse {
|
||||
/// The pending channel to be force closed
|
||||
PendingChannel channel = 1 [ json_name = "channel" ];
|
||||
|
||||
// TODO(roasbeef): HTLC's as well?
|
||||
|
||||
/// The transaction id of the closing transaction
|
||||
string closing_txid = 2 [ json_name = "closing_txid" ];
|
||||
|
||||
@ -905,8 +928,17 @@ message PendingChannelResponse {
|
||||
/// The height at which funds can be sweeped into the wallet
|
||||
uint32 maturity_height = 4 [ json_name = "maturity_height" ];
|
||||
|
||||
/// Remaining # of blocks until funds can be sweeped into the wallet
|
||||
uint32 blocks_til_maturity = 5 [ json_name = "blocks_til_maturity" ];
|
||||
/*
|
||||
Remaining # of blocks until the commitment output can be swept.
|
||||
Negative values indicate how many blocks have passed since becoming
|
||||
mature.
|
||||
*/
|
||||
int32 blocks_til_maturity = 5 [ json_name = "blocks_til_maturity" ];
|
||||
|
||||
/// The total value of funds successfully recovered from this channel
|
||||
int64 recovered_balance = 6 [ json_name = "recovered_balance" ];
|
||||
|
||||
repeated PendingHTLC pending_htlcs = 8 [ json_name = "pending_htlcs" ];
|
||||
}
|
||||
|
||||
/// The balance in satoshis encumbered in pending channels
|
||||
|
||||
@ -732,8 +732,19 @@
|
||||
},
|
||||
"blocks_til_maturity": {
|
||||
"type": "integer",
|
||||
"format": "int32",
|
||||
"description": "Remaining # of blocks until the commitment output can be swept.\nNegative values indicate how many blocks have passed since becoming\nmature."
|
||||
},
|
||||
"recovered_balance": {
|
||||
"type": "string",
|
||||
"format": "int64",
|
||||
"title": "/ Remaining # of blocks until funds can be sweeped into the wallet"
|
||||
"title": "/ The total value of funds successfully recovered from this channel"
|
||||
},
|
||||
"pending_htlcs": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/definitions/lnrpcPendingHTLC"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
@ -1743,6 +1754,40 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"lnrpcPendingHTLC": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"incoming": {
|
||||
"type": "boolean",
|
||||
"format": "boolean",
|
||||
"title": "/ The direction within the channel that the htlc was sent"
|
||||
},
|
||||
"amount": {
|
||||
"type": "string",
|
||||
"format": "int64",
|
||||
"title": "/ The total value of the htlc"
|
||||
},
|
||||
"outpoint": {
|
||||
"type": "string",
|
||||
"title": "/ The final output to be swept back to the user's wallet"
|
||||
},
|
||||
"maturity_height": {
|
||||
"type": "integer",
|
||||
"format": "int64",
|
||||
"title": "/ The next block height at which we can spend the current stage"
|
||||
},
|
||||
"blocks_til_maturity": {
|
||||
"type": "integer",
|
||||
"format": "int32",
|
||||
"description": "*\nThe number of blocks remaining until the current stage can be swept.\nNegative values indicate how many blocks have passed since becoming\nmature."
|
||||
},
|
||||
"stage": {
|
||||
"type": "integer",
|
||||
"format": "int64",
|
||||
"title": "/ Indicates whether the htlc is in its first or second stage of recovery"
|
||||
}
|
||||
}
|
||||
},
|
||||
"lnrpcPendingUpdate": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
|
||||
@ -809,6 +809,34 @@ func htlcSpendSuccess(signer Signer, signDesc *SignDescriptor,
|
||||
return witnessStack, nil
|
||||
}
|
||||
|
||||
// HtlcSpendSuccess exposes the public witness generation function for spending
|
||||
// an HTLC success transaction, either due to an expiring time lock or having
|
||||
// had the payment preimage.
|
||||
// NOTE: The caller MUST set the txn version, sequence number, and sign
|
||||
// descriptor's sig hash cache before invocation.
|
||||
func HtlcSpendSuccess(signer Signer, signDesc *SignDescriptor,
|
||||
sweepTx *wire.MsgTx) (wire.TxWitness, error) {
|
||||
|
||||
// With the proper sequence an version set, we'll now sign the timeout
|
||||
// transaction using the passed signed descriptor. In order to generate
|
||||
// a valid signature, then signDesc should be using the base delay
|
||||
// public key, and the proper single tweak bytes.
|
||||
sweepSig, err := signer.SignOutputRaw(sweepTx, signDesc)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// We set a zero as the first element the witness stack (ignoring the
|
||||
// witness script), in order to force execution to the second portion
|
||||
// of the if clause.
|
||||
witnessStack := wire.TxWitness(make([][]byte, 3))
|
||||
witnessStack[0] = append(sweepSig, byte(txscript.SigHashAll))
|
||||
witnessStack[1] = nil
|
||||
witnessStack[2] = signDesc.WitnessScript
|
||||
|
||||
return witnessStack, nil
|
||||
}
|
||||
|
||||
// htlcTimeoutRevoke spends a second-level HTLC output. This function is to be
|
||||
// used by the sender or receiver of an HTLC to claim the HTLC after a revoked
|
||||
// commitment transaction was broadcast.
|
||||
|
||||
@ -186,20 +186,29 @@ const (
|
||||
// weight limits.
|
||||
MaxHTLCNumber = 966
|
||||
|
||||
// ToLocalPenaltyScriptSize 83 bytes
|
||||
// ToLocalScriptSize 83 bytes
|
||||
// - OP_IF: 1 byte
|
||||
// - OP_DATA: 1 byte (revocationkey length)
|
||||
// - revocationkey: 33 bytes
|
||||
// - OP_CHECKSIG: 1 byte
|
||||
// - OP_ELSE: 1 byte
|
||||
// - OP_DATA: 1 byte (localkey length)
|
||||
// - localkey: 33 bytes
|
||||
// - local_delay_key: 33 bytes
|
||||
// - OP_CHECKSIG_VERIFY: 1 byte
|
||||
// - OP_DATA: 1 byte (delay length)
|
||||
// - delay: 8 bytes
|
||||
// -OP_CHECKSEQUENCEVERIFY: 1 byte
|
||||
// - OP_ENDIF: 1 byte
|
||||
ToLocalPenaltyScriptSize = 1 + 1 + 33 + 1 + 1 + 1 + 33 + 1 + 1 + 8 + 1 + 1
|
||||
ToLocalScriptSize = 1 + 1 + 33 + 1 + 1 + 1 + 33 + 1 + 1 + 8 + 1 + 1
|
||||
|
||||
// ToLocalTimeoutWitnessSize x bytes
|
||||
// - number_of_witness_elements: 1 byte
|
||||
// - local_delay_sig_length: 1 byte
|
||||
// - local_delay_sig: 73 bytes
|
||||
// - zero_length: 1 byte
|
||||
// - witness_script_length: 1 byte
|
||||
// - witness_script (to_local_script)
|
||||
ToLocalTimeoutWitnessSize = 1 + 1 + 73 + 1 + 1 + ToLocalScriptSize
|
||||
|
||||
// ToLocalPenaltyWitnessSize 160 bytes
|
||||
// - number_of_witness_elements: 1 byte
|
||||
@ -208,9 +217,9 @@ const (
|
||||
// - one_length: 1 byte
|
||||
// - witness_script_length: 1 byte
|
||||
// - witness_script (to_local_script)
|
||||
ToLocalPenaltyWitnessSize = 1 + 1 + 73 + 1 + 1 + ToLocalPenaltyScriptSize
|
||||
ToLocalPenaltyWitnessSize = 1 + 1 + 73 + 1 + 1 + ToLocalScriptSize
|
||||
|
||||
// AcceptedHtlcPenaltyScriptSize 139 bytes
|
||||
// AcceptedHtlcScriptSize 139 bytes
|
||||
// - OP_DUP: 1 byte
|
||||
// - OP_HASH160: 1 byte
|
||||
// - OP_DATA: 1 byte (RIPEMD160(SHA256(revocationkey)) length)
|
||||
@ -245,9 +254,22 @@ const (
|
||||
// - OP_CHECKSIG: 1 byte
|
||||
// - OP_ENDIF: 1 byte
|
||||
// - OP_ENDIF: 1 byte
|
||||
AcceptedHtlcPenaltyScriptSize = 3*1 + 20 + 5*1 + 33 + 7*1 + 20 + 4*1 +
|
||||
AcceptedHtlcScriptSize = 3*1 + 20 + 5*1 + 33 + 7*1 + 20 + 4*1 +
|
||||
33 + 5*1 + 4 + 5*1
|
||||
|
||||
// AcceptedHtlcSuccessWitnessSize 325 bytes
|
||||
// - number_of_witness_elements: 1 byte
|
||||
// - nil_length: 1 byte
|
||||
// - sig_alice_length: 1 byte
|
||||
// - sig_alice: 73 bytes
|
||||
// - sig_bob_length: 1 byte
|
||||
// - sig_bob: 73 bytes
|
||||
// - preimage_length: 1 byte
|
||||
// - preimage: 32 bytes
|
||||
// - witness_script_length: 1 byte
|
||||
// - witness_script (accepted_htlc_script)
|
||||
AcceptedHtlcSuccessWitnessSize = 1 + 1 + 73 + 1 + 73 + 1 + 32 + 1 + AcceptedHtlcScriptSize
|
||||
|
||||
// AcceptedHtlcPenaltyWitnessSize 249 bytes
|
||||
// - number_of_witness_elements: 1 byte
|
||||
// - revocation_sig_length: 1 byte
|
||||
@ -256,8 +278,7 @@ const (
|
||||
// - revocation_key: 33 bytes
|
||||
// - witness_script_length: 1 byte
|
||||
// - witness_script (accepted_htlc_script)
|
||||
AcceptedHtlcPenaltyWitnessSize = 1 + 1 + 73 + 1 + 33 + 1 +
|
||||
AcceptedHtlcPenaltyScriptSize
|
||||
AcceptedHtlcPenaltyWitnessSize = 1 + 1 + 73 + 1 + 33 + 1 + AcceptedHtlcScriptSize
|
||||
|
||||
// OfferedHtlcScriptSize 133 bytes
|
||||
// - OP_DUP: 1 byte
|
||||
@ -303,6 +324,18 @@ const (
|
||||
// - witness_script (offered_htlc_script)
|
||||
OfferedHtlcWitnessSize = 1 + 1 + 73 + 1 + 33 + 1 + OfferedHtlcScriptSize
|
||||
|
||||
// OfferedHtlcTimeoutWitnessSize 285 bytes
|
||||
// - number_of_witness_elements: 1 byte
|
||||
// - nil_length: 1 byte
|
||||
// - sig_alice_length: 1 byte
|
||||
// - sig_alice: 73 bytes
|
||||
// - sig_bob_length: 1 byte
|
||||
// - sig_bob: 73 bytes
|
||||
// - nil_length: 1 byte
|
||||
// - witness_script_length: 1 byte
|
||||
// - witness_script (offered_htlc_script)
|
||||
OfferedHtlcTimeoutWitnessSize = 1 + 1 + 1 + 73 + 1 + 73 + 1 + 1 + OfferedHtlcScriptSize
|
||||
|
||||
// OfferedHtlcPenaltyWitnessSize 243 bytes
|
||||
// - number_of_witness_elements: 1 byte
|
||||
// - revocation_sig_length: 1 byte
|
||||
|
||||
@ -13,17 +13,18 @@ import (
|
||||
type WitnessType uint16
|
||||
|
||||
const (
|
||||
// CommitmentTimeLock is a witness that allows us to spend the output of a
|
||||
// commitment transaction after a relative lock-time lockout.
|
||||
// CommitmentTimeLock is a witness that allows us to spend the output of
|
||||
// a commitment transaction after a relative lock-time lockout.
|
||||
CommitmentTimeLock WitnessType = 0
|
||||
|
||||
// CommitmentNoDelay is a witness that allows us to spend a settled no-delay
|
||||
// output immediately on a counterparty's commitment transaction.
|
||||
// CommitmentNoDelay is a witness that allows us to spend a settled
|
||||
// no-delay output immediately on a counterparty's commitment
|
||||
// transaction.
|
||||
CommitmentNoDelay WitnessType = 1
|
||||
|
||||
// CommitmentRevoke is a witness that allows us to sweep the settled output
|
||||
// of a malicious counterparty's who broadcasts a revoked commitment
|
||||
// transaction.
|
||||
// CommitmentRevoke is a witness that allows us to sweep the settled
|
||||
// output of a malicious counterparty's who broadcasts a revoked
|
||||
// commitment transaction.
|
||||
CommitmentRevoke WitnessType = 2
|
||||
|
||||
// HtlcOfferedRevoke is a witness that allows us to sweep an HTLC
|
||||
@ -33,6 +34,15 @@ const (
|
||||
// HtlcAcceptedRevoke is a witness that allows us to sweep an HTLC
|
||||
// output that we accepted from the counterparty.
|
||||
HtlcAcceptedRevoke WitnessType = 4
|
||||
|
||||
// HtlcOfferedTimeout is a witness that allows us to sweep an HTLC
|
||||
// output that we extended to a party, but was never fulfilled.
|
||||
HtlcOfferedTimeout WitnessType = 5
|
||||
|
||||
// HtlcAcceptedSuccess is a witness that allows us to sweep an HTLC
|
||||
// output that was offered to us, and for which we have a payment
|
||||
// preimage.
|
||||
HtlcAcceptedSuccess WitnessType = 6
|
||||
)
|
||||
|
||||
// WitnessGenerator represents a function which is able to generate the final
|
||||
@ -64,6 +74,8 @@ func (wt WitnessType) GenWitnessFunc(signer Signer,
|
||||
return ReceiverHtlcSpendRevoke(signer, desc, tx)
|
||||
case HtlcAcceptedRevoke:
|
||||
return SenderHtlcSpendRevoke(signer, desc, tx)
|
||||
case HtlcOfferedTimeout:
|
||||
return HtlcSpendSuccess(signer, desc, tx)
|
||||
default:
|
||||
return nil, fmt.Errorf("unknown witness type: %v", wt)
|
||||
}
|
||||
|
||||
163
nursery_store.go
163
nursery_store.go
@ -25,19 +25,18 @@ import (
|
||||
// |
|
||||
// | LAST PURGED + FINALIZED HEIGHTS
|
||||
// |
|
||||
// | Each nursery store tracks a "last purged height", which records the
|
||||
// | most recent block height for which the nursery store has purged all
|
||||
// | state. This value lags behind the best block height for reorg safety,
|
||||
// | and serves as a starting height for rescans after a restart. It also
|
||||
// | tracks a "last finalized height", which records the last block height
|
||||
// | that the nursery attempted to graduate. If a finalized height has
|
||||
// | kindergarten outputs, the sweep txn for these outputs will be stored in
|
||||
// | the height bucket. This ensure that the same txid will be used after
|
||||
// | restarts. Otherwise, the nursery will be unable to recover the txid
|
||||
// | of kindergarten sweep transaction it has already broadcast.
|
||||
// | Each nursery store tracks a "last graduated height", which records the
|
||||
// | most recent block height for which the nursery store has successfully
|
||||
// | graduated all outputs. It also tracks a "last finalized height", which
|
||||
// | records the last block height that the nursery attempted to graduate
|
||||
// | If a finalized height has kindergarten outputs, the sweep txn for these
|
||||
// | outputs will be stored in the height bucket. This ensure that the same
|
||||
// | txid will be used after restarts. Otherwise, the nursery will be unable
|
||||
// | to recover the txid of kindergarten sweep transaction it has already
|
||||
// | broadcast.
|
||||
// |
|
||||
// ├── last-purged-height-key: <last-purged-height>
|
||||
// ├── last-finalized-height-key: <last-finalized-height>
|
||||
// ├── last-graduated-height-key: <last-graduated-height>
|
||||
// |
|
||||
// | CHANNEL INDEX
|
||||
// |
|
||||
@ -142,13 +141,17 @@ type NurseryStore interface {
|
||||
// nursery store finalized a kindergarten class.
|
||||
LastFinalizedHeight() (uint32, error)
|
||||
|
||||
// PurgeHeight deletes specified the height bucket if it exists, and
|
||||
// records it as that last purged height.
|
||||
PurgeHeight(height uint32) error
|
||||
// GraduateHeight records the provided height as the last height for
|
||||
// which the nursery store successfully graduated all outputs.
|
||||
GraduateHeight(height uint32) error
|
||||
|
||||
// LastPurgedHeight returns the last block height for which the nursery
|
||||
// store has purged all persistent state.
|
||||
LastPurgedHeight() (uint32, error)
|
||||
// LastGraduatedHeight returns the last block height for which the
|
||||
// nursery store successfully graduated all outputs.
|
||||
LastGraduatedHeight() (uint32, error)
|
||||
|
||||
// HeightsBelowOrEqual returns the lowest non-empty heights in the
|
||||
// height index, that exist at or below the provided upper bound.
|
||||
HeightsBelowOrEqual(height uint32) ([]uint32, error)
|
||||
|
||||
// ForChanOutputs iterates over all outputs being incubated for a
|
||||
// particular channel point. This method accepts a callback that allows
|
||||
@ -179,9 +182,9 @@ var (
|
||||
// last finalized height.
|
||||
lastFinalizedHeightKey = []byte("last-finalized-height")
|
||||
|
||||
// lastPurgedHeightKey is a static key used to retrieve the height of
|
||||
// the last bucket that was purged.
|
||||
lastPurgedHeightKey = []byte("last-purged-height")
|
||||
// lastGraduatedHeightKey is a static key used to retrieve the height of
|
||||
// the last bucket that successfully graduated all outputs.
|
||||
lastGraduatedHeightKey = []byte("last-graduated-height")
|
||||
|
||||
// channelIndexKey is a static key used to lookup the bucket containing
|
||||
// all of the nursery's active channels.
|
||||
@ -557,10 +560,10 @@ func (ns *nurseryStore) GraduateKinder(height uint32) error {
|
||||
})
|
||||
}
|
||||
|
||||
// FinalizeKinder accepts a block height as a parameter and purges its
|
||||
// persistent state for all outputs at that height. During a restart, the utxo
|
||||
// nursery will begin it's recovery procedure from the next height that has
|
||||
// yet to be finalized.
|
||||
// FinalizeKinder accepts a block height and a finalized kindergarten sweep
|
||||
// transaction, persisting the transaction at the appropriate height bucket. The
|
||||
// nursery store's last finalized height is also updated with the provided
|
||||
// height.
|
||||
func (ns *nurseryStore) FinalizeKinder(height uint32,
|
||||
finalTx *wire.MsgTx) error {
|
||||
|
||||
@ -569,17 +572,12 @@ func (ns *nurseryStore) FinalizeKinder(height uint32,
|
||||
})
|
||||
}
|
||||
|
||||
// PurgeHeight accepts a block height as a parameter and purges its persistent
|
||||
// state for all outputs at that height. During a restart, the utxo nursery will
|
||||
// begin it's recovery procedure from the next height that has yet to be
|
||||
// finalized.
|
||||
func (ns *nurseryStore) PurgeHeight(height uint32) error {
|
||||
return ns.db.Update(func(tx *bolt.Tx) error {
|
||||
if err := ns.purgeHeightBucket(tx, height); err != nil {
|
||||
return err
|
||||
}
|
||||
// GraduateHeight persists the provided height as the nursery store's last
|
||||
// graduated height.
|
||||
func (ns *nurseryStore) GraduateHeight(height uint32) error {
|
||||
|
||||
return ns.putLastPurgedHeight(tx, height)
|
||||
return ns.db.Update(func(tx *bolt.Tx) error {
|
||||
return ns.putLastGraduatedHeight(tx, height)
|
||||
})
|
||||
}
|
||||
|
||||
@ -725,6 +723,45 @@ func (ns *nurseryStore) FetchPreschools() ([]kidOutput, error) {
|
||||
return kids, nil
|
||||
}
|
||||
|
||||
// HeightsBelowOrEqual returns a slice of all non-empty heights in the height
|
||||
// index at or below the provided upper bound.
|
||||
func (ns *nurseryStore) HeightsBelowOrEqual(height uint32) ([]uint32, error) {
|
||||
var activeHeights []uint32
|
||||
err := ns.db.View(func(tx *bolt.Tx) error {
|
||||
// Ensure that the chain bucket for this nursery store exists.
|
||||
chainBucket := tx.Bucket(ns.pfxChainKey)
|
||||
if chainBucket == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Ensure that the height index has been properly initialized for this
|
||||
// chain.
|
||||
hghtIndex := chainBucket.Bucket(heightIndexKey)
|
||||
if hghtIndex == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Serialize the provided height, as this will form the name of the
|
||||
// bucket.
|
||||
var lower, upper [4]byte
|
||||
byteOrder.PutUint32(upper[:], height)
|
||||
|
||||
c := hghtIndex.Cursor()
|
||||
for k, _ := c.Seek(lower[:]); bytes.Compare(k, upper[:]) <= 0 &&
|
||||
len(k) == 4; k, _ = c.Next() {
|
||||
|
||||
activeHeights = append(activeHeights, byteOrder.Uint32(k))
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return activeHeights, nil
|
||||
}
|
||||
|
||||
// ForChanOutputs iterates over all outputs being incubated for a particular
|
||||
// channel point. This method accepts a callback that allows the caller to
|
||||
// process each key-value pair. The key will be a prefixed outpoint, and the
|
||||
@ -863,8 +900,7 @@ func (ns *nurseryStore) RemoveChannel(chanPoint *wire.OutPoint) error {
|
||||
}
|
||||
|
||||
// LastFinalizedHeight returns the last block height for which the nursery
|
||||
// store has purged all persistent state. This occurs after a fixed interval
|
||||
// for reorg safety.
|
||||
// store has finalized a kindergarten class.
|
||||
func (ns *nurseryStore) LastFinalizedHeight() (uint32, error) {
|
||||
var lastFinalizedHeight uint32
|
||||
err := ns.db.View(func(tx *bolt.Tx) error {
|
||||
@ -876,18 +912,17 @@ func (ns *nurseryStore) LastFinalizedHeight() (uint32, error) {
|
||||
return lastFinalizedHeight, err
|
||||
}
|
||||
|
||||
// LastPurgedHeight returns the last block height for which the nursery store
|
||||
// has purged all persistent state. This occurs after a fixed interval for reorg
|
||||
// safety.
|
||||
func (ns *nurseryStore) LastPurgedHeight() (uint32, error) {
|
||||
var lastPurgedHeight uint32
|
||||
// LastGraduatedHeight returns the last block height for which the nursery
|
||||
// store has successfully graduated all outputs.
|
||||
func (ns *nurseryStore) LastGraduatedHeight() (uint32, error) {
|
||||
var lastGraduatedHeight uint32
|
||||
err := ns.db.View(func(tx *bolt.Tx) error {
|
||||
var err error
|
||||
lastPurgedHeight, err = ns.getLastPurgedHeight(tx)
|
||||
lastGraduatedHeight, err = ns.getLastGraduatedHeight(tx)
|
||||
return err
|
||||
})
|
||||
|
||||
return lastPurgedHeight, err
|
||||
return lastGraduatedHeight, err
|
||||
}
|
||||
|
||||
// Helper Methods
|
||||
@ -1091,24 +1126,6 @@ func (ns *nurseryStore) getHeightBucket(tx *bolt.Tx,
|
||||
return hghtBucket
|
||||
}
|
||||
|
||||
// purgeHeightBucket ensures that the height bucket at the provided index is
|
||||
// purged from the nursery store.
|
||||
func (ns *nurseryStore) purgeHeightBucket(tx *bolt.Tx, height uint32) error {
|
||||
// Ensure that the height bucket already exists.
|
||||
_, hghtIndex, hghtBucket := ns.getHeightBucketPath(tx, height)
|
||||
if hghtBucket == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Serialize the provided height, as this will form the name of the
|
||||
// bucket.
|
||||
var heightBytes [4]byte
|
||||
byteOrder.PutUint32(heightBytes[:], height)
|
||||
|
||||
// Finally, delete the bucket in question.
|
||||
return removeBucketIfExists(hghtIndex, heightBytes[:])
|
||||
}
|
||||
|
||||
// createHeightChanBucket creates or retrieves an existing height-channel bucket
|
||||
// for the provided block height and channel point. This method will attempt to
|
||||
// instantiate all buckets along the path if required.
|
||||
@ -1365,29 +1382,29 @@ func (ns *nurseryStore) getFinalizedTxn(tx *bolt.Tx,
|
||||
return txn, nil
|
||||
}
|
||||
|
||||
// getLastPurgedHeight is a helper method that retrieves the last height for
|
||||
// which the database purged its persistent state.
|
||||
func (ns *nurseryStore) getLastPurgedHeight(tx *bolt.Tx) (uint32, error) {
|
||||
// getLastGraduatedHeight is a helper method that retrieves the last height for
|
||||
// which the database graduated all outputs successfully.
|
||||
func (ns *nurseryStore) getLastGraduatedHeight(tx *bolt.Tx) (uint32, error) {
|
||||
// Retrieve the chain bucket associated with the given nursery store.
|
||||
chainBucket := tx.Bucket(ns.pfxChainKey)
|
||||
if chainBucket == nil {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// Lookup the last purged height in the top-level chain bucket.
|
||||
heightBytes := chainBucket.Get(lastPurgedHeightKey)
|
||||
// Lookup the last graduated height in the top-level chain bucket.
|
||||
heightBytes := chainBucket.Get(lastGraduatedHeightKey)
|
||||
if heightBytes == nil {
|
||||
// We have never purged before, return height 0.
|
||||
// We have never graduated before, return height 0.
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// Otherwise, parse the bytes and return the last purged height.
|
||||
// Otherwise, parse the bytes and return the last graduated height.
|
||||
return byteOrder.Uint32(heightBytes), nil
|
||||
}
|
||||
|
||||
// pubLastPurgedHeight is a helper method that writes the provided height under
|
||||
// the last purged height key.
|
||||
func (ns *nurseryStore) putLastPurgedHeight(tx *bolt.Tx, height uint32) error {
|
||||
// pubLastGraduatedHeight is a helper method that writes the provided height under
|
||||
// the last graduated height key.
|
||||
func (ns *nurseryStore) putLastGraduatedHeight(tx *bolt.Tx, height uint32) error {
|
||||
|
||||
// Ensure that the chain bucket for this nursery store exists.
|
||||
chainBucket, err := tx.CreateBucketIfNotExists(ns.pfxChainKey)
|
||||
@ -1395,12 +1412,12 @@ func (ns *nurseryStore) putLastPurgedHeight(tx *bolt.Tx, height uint32) error {
|
||||
return err
|
||||
}
|
||||
|
||||
// Serialize the provided last-purged height, and store it in the
|
||||
// Serialize the provided last-gradauted height, and store it in the
|
||||
// top-level chain bucket for this nursery store.
|
||||
var lastHeightBytes [4]byte
|
||||
byteOrder.PutUint32(lastHeightBytes[:], height)
|
||||
|
||||
return chainBucket.Put(lastPurgedHeightKey, lastHeightBytes[:])
|
||||
return chainBucket.Put(lastGraduatedHeightKey, lastHeightBytes[:])
|
||||
}
|
||||
|
||||
// errBucketNotEmpty signals that an attempt to prune a particular
|
||||
|
||||
754
nursery_store_test.go
Normal file
754
nursery_store_test.go
Normal file
@ -0,0 +1,754 @@
|
||||
// +build !rpctest
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/btcsuite/btclog"
|
||||
"github.com/lightningnetwork/lnd/channeldb"
|
||||
"github.com/roasbeef/btcd/wire"
|
||||
)
|
||||
|
||||
func init() {
|
||||
// Disable logging to prevent panics bc. of global state
|
||||
channeldb.UseLogger(btclog.Disabled)
|
||||
utxnLog = btclog.Disabled
|
||||
}
|
||||
|
||||
// makeTestDB creates a new instance of the ChannelDB for testing purposes. A
|
||||
// callback which cleans up the created temporary directories is also returned
|
||||
// and intended to be executed after the test completes.
|
||||
func makeTestDB() (*channeldb.DB, func(), error) {
|
||||
// First, create a temporary directory to be used for the duration of
|
||||
// this test.
|
||||
tempDirName, err := ioutil.TempDir("", "channeldb")
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
// Next, create channeldb for the first time.
|
||||
cdb, err := channeldb.Open(tempDirName)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
cleanUp := func() {
|
||||
cdb.Close()
|
||||
os.RemoveAll(tempDirName)
|
||||
}
|
||||
|
||||
return cdb, cleanUp, nil
|
||||
}
|
||||
|
||||
type incubateTest struct {
|
||||
nOutputs int
|
||||
chanPoint *wire.OutPoint
|
||||
commOutput *kidOutput
|
||||
htlcOutputs []babyOutput
|
||||
err error
|
||||
}
|
||||
|
||||
// incubateTests holds the test vectors used to test the state transitions of
|
||||
// outputs stored in the nursery store.
|
||||
var incubateTests []incubateTest
|
||||
|
||||
// initIncubateTests instantiates the test vectors during package init, which
|
||||
// properly captures the sign descriptors and public keys.
|
||||
func initIncubateTests() {
|
||||
incubateTests = []incubateTest{
|
||||
{
|
||||
nOutputs: 0,
|
||||
chanPoint: &outPoints[3],
|
||||
},
|
||||
{
|
||||
nOutputs: 1,
|
||||
chanPoint: &outPoints[0],
|
||||
commOutput: &kidOutputs[0],
|
||||
},
|
||||
{
|
||||
nOutputs: 4,
|
||||
chanPoint: &outPoints[0],
|
||||
commOutput: &kidOutputs[0],
|
||||
htlcOutputs: babyOutputs,
|
||||
},
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// TestNurseryStoreInit verifies basic properties of the nursery store before
|
||||
// any modifying calls are made.
|
||||
func TestNurseryStoreInit(t *testing.T) {
|
||||
cdb, cleanUp, err := makeTestDB()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel db: %v", err)
|
||||
}
|
||||
defer cleanUp()
|
||||
|
||||
ns, err := newNurseryStore(&bitcoinGenesis, cdb)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open nursery store: %v", err)
|
||||
}
|
||||
|
||||
assertNumChannels(t, ns, 0)
|
||||
assertNumPreschools(t, ns, 0)
|
||||
assertLastFinalizedHeight(t, ns, 0)
|
||||
assertLastGraduatedHeight(t, ns, 0)
|
||||
}
|
||||
|
||||
// TestNurseryStoreIncubate tests the primary state transitions taken by outputs
|
||||
// in the nursery store. The test is designed to walk both commitment or htlc
|
||||
// outputs through the nursery store, verifying the properties of the
|
||||
// intermediate states.
|
||||
func TestNurseryStoreIncubate(t *testing.T) {
|
||||
cdb, cleanUp, err := makeTestDB()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel db: %v", err)
|
||||
}
|
||||
defer cleanUp()
|
||||
|
||||
ns, err := newNurseryStore(&bitcoinGenesis, cdb)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open nursery store: %v", err)
|
||||
}
|
||||
|
||||
for i, test := range incubateTests {
|
||||
// At the beginning of each test, we do not expect to the
|
||||
// nursery store to be tracking any outputs for this channel
|
||||
// point.
|
||||
assertNumChanOutputs(t, ns, test.chanPoint, 0)
|
||||
|
||||
// Nursery store should be completely empty.
|
||||
assertNumChannels(t, ns, 0)
|
||||
assertNumPreschools(t, ns, 0)
|
||||
|
||||
// Begin incubating all of the outputs provided in this test
|
||||
// vector.
|
||||
err = ns.Incubate(test.commOutput, test.htlcOutputs)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to incubate outputs"+
|
||||
"on test #%d: %v", i, err)
|
||||
}
|
||||
// Now that the outputs have been inserted, the nursery store
|
||||
// should see exactly that many outputs under this channel
|
||||
// point.
|
||||
// NOTE: This property should remain intact after every state
|
||||
// change until the channel has been completely removed.
|
||||
assertNumChanOutputs(t, ns, test.chanPoint, test.nOutputs)
|
||||
|
||||
// If there were no inputs to be incubated, just check that the
|
||||
// no trace of the channel was left.
|
||||
if test.nOutputs == 0 {
|
||||
assertNumChannels(t, ns, 0)
|
||||
continue
|
||||
}
|
||||
|
||||
// The test vector has a non-zero number of outputs, we will
|
||||
// expect to only see the one channel from this test case.
|
||||
assertNumChannels(t, ns, 1)
|
||||
|
||||
// The channel should be shown as immature, since none of the
|
||||
// outputs should be graduated directly after being inserted.
|
||||
// It should also be impossible to remove the channel, if it is
|
||||
// also immature.
|
||||
// NOTE: These two tests properties should hold between every
|
||||
// state change until all outputs have been fully graduated.
|
||||
assertChannelMaturity(t, ns, test.chanPoint, false)
|
||||
assertCanRemoveChannel(t, ns, test.chanPoint, false)
|
||||
|
||||
// Verify that the htlc outputs, if any, reside in the height
|
||||
// index at their first stage CLTV's expiry height.
|
||||
for _, htlcOutput := range test.htlcOutputs {
|
||||
assertCribAtExpiryHeight(t, ns, &htlcOutput)
|
||||
}
|
||||
|
||||
// If the commitment output was not dust, we will move it from
|
||||
// the preschool bucket to the kindergarten bucket.
|
||||
if test.commOutput != nil {
|
||||
// If the commitment output was not considered dust, we
|
||||
// should see exactly one preschool output in the
|
||||
// nursery store.
|
||||
assertNumPreschools(t, ns, 1)
|
||||
|
||||
// Now, move the commitment output to the kindergarten
|
||||
// bucket.
|
||||
err = ns.PreschoolToKinder(test.commOutput)
|
||||
if err != test.err {
|
||||
t.Fatalf("unable to move commitment output from "+
|
||||
"pscl to kndr: %v", err)
|
||||
}
|
||||
|
||||
// The total number of outputs for this channel should
|
||||
// not have changed, and the kindergarten output should
|
||||
// reside at it's maturity height.
|
||||
assertNumChanOutputs(t, ns, test.chanPoint, test.nOutputs)
|
||||
assertKndrAtMaturityHeight(t, ns, test.commOutput)
|
||||
|
||||
// The total number of channels should not have changed.
|
||||
assertNumChannels(t, ns, 1)
|
||||
|
||||
// Channel maturity and removal should reflect that the
|
||||
// channel still has non-graduated outputs.
|
||||
assertChannelMaturity(t, ns, test.chanPoint, false)
|
||||
assertCanRemoveChannel(t, ns, test.chanPoint, false)
|
||||
|
||||
// Moving the preschool output should have no effect on
|
||||
// the placement of crib outputs in the height index.
|
||||
for _, htlcOutput := range test.htlcOutputs {
|
||||
assertCribAtExpiryHeight(t, ns, &htlcOutput)
|
||||
}
|
||||
}
|
||||
|
||||
// At this point, we should see no more preschool outputs in the
|
||||
// nursery store. Either it was moved to the kindergarten
|
||||
// bucket, or never inserted.
|
||||
assertNumPreschools(t, ns, 0)
|
||||
|
||||
// If the commitment output is not-dust, we will graduate the
|
||||
// class at its maturity height.
|
||||
if test.commOutput != nil {
|
||||
// Compute the commitment output's maturity height, and
|
||||
// move proceed to graduate that class.
|
||||
maturityHeight := test.commOutput.ConfHeight() +
|
||||
test.commOutput.BlocksToMaturity()
|
||||
|
||||
err = ns.GraduateKinder(maturityHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to graduate kindergarten class at "+
|
||||
"height %d: %v", maturityHeight, err)
|
||||
}
|
||||
|
||||
// The total number of outputs for this channel should
|
||||
// not have changed, but the kindergarten output should
|
||||
// have been removed from it's maturity height.
|
||||
assertNumChanOutputs(t, ns, test.chanPoint, test.nOutputs)
|
||||
assertKndrNotAtMaturityHeight(t, ns, test.commOutput)
|
||||
|
||||
// The total number of channels should not have changed.
|
||||
assertNumChannels(t, ns, 1)
|
||||
|
||||
// Moving the preschool output should have no effect on
|
||||
// the placement of crib outputs in the height index.
|
||||
for _, htlcOutput := range test.htlcOutputs {
|
||||
assertCribAtExpiryHeight(t, ns, &htlcOutput)
|
||||
}
|
||||
}
|
||||
|
||||
// If there are any htlc outputs to incubate, we will walk them
|
||||
// through their two-stage incubation process.
|
||||
if len(test.htlcOutputs) > 0 {
|
||||
for i, htlcOutput := range test.htlcOutputs {
|
||||
// Begin by moving each htlc output from the
|
||||
// crib to kindergarten state.
|
||||
err = ns.CribToKinder(&htlcOutput)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to move htlc output from "+
|
||||
"crib to kndr: %v", err)
|
||||
}
|
||||
// Number of outputs for this channel should
|
||||
// remain unchanged.
|
||||
assertNumChanOutputs(t, ns, test.chanPoint,
|
||||
test.nOutputs)
|
||||
|
||||
// If the output hasn't moved to kndr, it should
|
||||
// be at it's crib expiry height, otherwise is
|
||||
// should have been removed.
|
||||
for j := range test.htlcOutputs {
|
||||
if j > i {
|
||||
assertCribAtExpiryHeight(t, ns,
|
||||
&test.htlcOutputs[j])
|
||||
assertKndrNotAtMaturityHeight(t,
|
||||
ns, &test.htlcOutputs[j].kidOutput)
|
||||
} else {
|
||||
assertCribNotAtExpiryHeight(t, ns,
|
||||
&test.htlcOutputs[j])
|
||||
assertKndrAtMaturityHeight(t,
|
||||
ns, &test.htlcOutputs[j].kidOutput)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Total number of channels in the nursery store should
|
||||
// be the same, no outputs should be marked as
|
||||
// preschool.
|
||||
assertNumChannels(t, ns, 1)
|
||||
assertNumPreschools(t, ns, 0)
|
||||
|
||||
// Channel should also not be mature, as it we should
|
||||
// still have outputs in kindergarten.
|
||||
assertChannelMaturity(t, ns, test.chanPoint, false)
|
||||
assertCanRemoveChannel(t, ns, test.chanPoint, false)
|
||||
|
||||
// Now, graduate each htlc kindergarten output,
|
||||
// asserting the invariant number of outputs being
|
||||
// tracked in this channel
|
||||
for _, htlcOutput := range test.htlcOutputs {
|
||||
maturityHeight := htlcOutput.ConfHeight() +
|
||||
htlcOutput.BlocksToMaturity()
|
||||
|
||||
err = ns.GraduateKinder(maturityHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to graduate htlc output "+
|
||||
"from kndr to grad: %v", err)
|
||||
}
|
||||
assertNumChanOutputs(t, ns, test.chanPoint,
|
||||
test.nOutputs)
|
||||
}
|
||||
}
|
||||
|
||||
// All outputs have been advanced through the nursery store, but
|
||||
// no attempt has been made to clean up this channel. We expect
|
||||
// to see the same channel remaining, and no kindergarten
|
||||
// outputs.
|
||||
assertNumChannels(t, ns, 1)
|
||||
assertNumPreschools(t, ns, 0)
|
||||
|
||||
// Since all outputs have now been graduated, the nursery store
|
||||
// should recognize that the channel is mature, and attempting
|
||||
// to remove it should succeed.
|
||||
assertChannelMaturity(t, ns, test.chanPoint, true)
|
||||
assertCanRemoveChannel(t, ns, test.chanPoint, true)
|
||||
|
||||
// Now that the channel has been removed, the nursery store
|
||||
// should be no channels in the nursery store, and no outputs
|
||||
// being tracked for this channel point.
|
||||
assertNumChannels(t, ns, 0)
|
||||
assertNumChanOutputs(t, ns, test.chanPoint, 0)
|
||||
|
||||
// If we had a commitment output, ensure it was removed from the
|
||||
// height index.
|
||||
if test.commOutput != nil {
|
||||
assertKndrNotAtMaturityHeight(t, ns, test.commOutput)
|
||||
}
|
||||
|
||||
// Check that all htlc outputs are no longer stored in their
|
||||
// crib or kindergarten height buckets.
|
||||
for _, htlcOutput := range test.htlcOutputs {
|
||||
assertCribNotAtExpiryHeight(t, ns, &htlcOutput)
|
||||
assertKndrNotAtMaturityHeight(t, ns, &htlcOutput.kidOutput)
|
||||
}
|
||||
|
||||
// Lastly, there should be no lingering preschool outputs.
|
||||
assertNumPreschools(t, ns, 0)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNurseryStoreFinalize tests that kindergarten sweep transactions are
|
||||
// properly persistted, and that the last finalized height is being set
|
||||
// accordingly.
|
||||
func TestNurseryStoreFinalize(t *testing.T) {
|
||||
cdb, cleanUp, err := makeTestDB()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel db: %v", err)
|
||||
}
|
||||
defer cleanUp()
|
||||
|
||||
ns, err := newNurseryStore(&bitcoinGenesis, cdb)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open nursery store: %v", err)
|
||||
}
|
||||
|
||||
kid := &kidOutputs[3]
|
||||
|
||||
// Compute the maturity height at which to enter the commitment output.
|
||||
maturityHeight := kid.ConfHeight() + kid.BlocksToMaturity()
|
||||
|
||||
// Since we haven't finalized before, we should see a last finalized
|
||||
// height of 0.
|
||||
assertLastFinalizedHeight(t, ns, 0)
|
||||
|
||||
// Begin incubating the commitment output, which will be placed in the
|
||||
// preschool bucket.
|
||||
err = ns.Incubate(kid, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to incubate commitment output: %v", err)
|
||||
}
|
||||
|
||||
// Then move the commitment output to the kindergarten bucket, so that
|
||||
// the output is registered in the height index.
|
||||
err = ns.PreschoolToKinder(kid)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to move pscl output to kndr: %v", err)
|
||||
}
|
||||
|
||||
// We should still see a last finalized height of 0, since no classes
|
||||
// have been graduated.
|
||||
assertLastFinalizedHeight(t, ns, 0)
|
||||
|
||||
// Now, iteratively finalize all heights below the maturity height,
|
||||
// ensuring that the last finalized height is properly persisted, and
|
||||
// that the finalized transactions are all nil.
|
||||
for i := 0; i < int(maturityHeight); i++ {
|
||||
err = ns.FinalizeKinder(uint32(i), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to finalize kndr at height=%d: %v",
|
||||
i, err)
|
||||
}
|
||||
assertLastFinalizedHeight(t, ns, uint32(i))
|
||||
assertFinalizedTxn(t, ns, uint32(i), nil)
|
||||
}
|
||||
|
||||
// As we have now finalized all heights below the maturity height, we
|
||||
// should still see the commitment output in the kindergarten bucket at
|
||||
// its maturity height.
|
||||
assertKndrAtMaturityHeight(t, ns, kid)
|
||||
|
||||
// Now, finalize the kindergarten sweep transaction at the maturity
|
||||
// height.
|
||||
err = ns.FinalizeKinder(maturityHeight, timeoutTx)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to finalize kndr at height=%d: %v",
|
||||
maturityHeight, err)
|
||||
}
|
||||
|
||||
// The nursery store should now see the maturity height finalized, and
|
||||
// the finalized kindergarten sweep txn should be returned at this
|
||||
// height.
|
||||
assertLastFinalizedHeight(t, ns, maturityHeight)
|
||||
assertFinalizedTxn(t, ns, maturityHeight, timeoutTx)
|
||||
|
||||
// Lastly, continue to finalize heights above the maturity height. Each
|
||||
// should report having a nil finalized kindergarten sweep txn.
|
||||
for i := maturityHeight + 1; i < maturityHeight+10; i++ {
|
||||
err = ns.FinalizeKinder(uint32(i), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to finalize kndr at height=%d: %v",
|
||||
i, err)
|
||||
}
|
||||
assertLastFinalizedHeight(t, ns, uint32(i))
|
||||
assertFinalizedTxn(t, ns, uint32(i), nil)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNurseryStoreGraduate verifies that the nursery store properly removes
|
||||
// populated entries from the height index as it is purged, and that the last
|
||||
// purged height is set appropriately.
|
||||
func TestNurseryStoreGraduate(t *testing.T) {
|
||||
cdb, cleanUp, err := makeTestDB()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel db: %v", err)
|
||||
}
|
||||
defer cleanUp()
|
||||
|
||||
ns, err := newNurseryStore(&bitcoinGenesis, cdb)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open nursery store: %v", err)
|
||||
}
|
||||
|
||||
kid := &kidOutputs[3]
|
||||
|
||||
// Compute the height at which this output will be inserted in the
|
||||
// height index.
|
||||
maturityHeight := kid.ConfHeight() + kid.BlocksToMaturity()
|
||||
|
||||
// Since we have never purged, the last purged height should be 0.
|
||||
assertLastGraduatedHeight(t, ns, 0)
|
||||
|
||||
// First, add a commitment output to the nursery store, which is
|
||||
// initially inserted in the preschool bucket.
|
||||
err = ns.Incubate(kid, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to incubate commitment output: %v", err)
|
||||
}
|
||||
|
||||
// Then, move the commitment output to the kindergarten bucket, such
|
||||
// that it resides in the height index at it's maturity height.
|
||||
err = ns.PreschoolToKinder(kid)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to move pscl output to kndr: %v", err)
|
||||
}
|
||||
|
||||
// Now, iteratively purge all height below the target maturity height,
|
||||
// checking that each class is now empty, and that the last purged
|
||||
// height is set correctly.
|
||||
for i := 0; i < int(maturityHeight); i++ {
|
||||
err = ns.GraduateHeight(uint32(i))
|
||||
if err != nil {
|
||||
t.Fatalf("unable to purge height=%d: %v", i, err)
|
||||
}
|
||||
|
||||
assertLastGraduatedHeight(t, ns, uint32(i))
|
||||
assertHeightIsPurged(t, ns, uint32(i))
|
||||
}
|
||||
|
||||
// Check that the commitment output currently exists at it's maturity
|
||||
// height.
|
||||
assertKndrAtMaturityHeight(t, ns, kid)
|
||||
|
||||
// Finalize the kindergarten transaction, ensuring that it is a non-nil
|
||||
// value.
|
||||
err = ns.FinalizeKinder(maturityHeight, timeoutTx)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to finalize kndr at height=%d: %v",
|
||||
maturityHeight, err)
|
||||
}
|
||||
|
||||
// Verify that the maturity height has now been finalized.
|
||||
assertLastFinalizedHeight(t, ns, maturityHeight)
|
||||
assertFinalizedTxn(t, ns, maturityHeight, timeoutTx)
|
||||
|
||||
// Finally, purge the non-empty maturity height, and check that returned
|
||||
// class is empty.
|
||||
err = ns.GraduateHeight(maturityHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to set graduated height=%d: %v", maturityHeight,
|
||||
err)
|
||||
}
|
||||
|
||||
err = ns.GraduateKinder(maturityHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to graduate kindergarten outputs at height=%d: "+
|
||||
"%v", maturityHeight, err)
|
||||
}
|
||||
|
||||
assertHeightIsPurged(t, ns, maturityHeight)
|
||||
}
|
||||
|
||||
// assertNumChanOutputs checks that the channel bucket has the expected number
|
||||
// of outputs.
|
||||
func assertNumChanOutputs(t *testing.T, ns NurseryStore,
|
||||
chanPoint *wire.OutPoint, expectedNum int) {
|
||||
|
||||
var count int
|
||||
err := ns.ForChanOutputs(chanPoint, func([]byte, []byte) error {
|
||||
count++
|
||||
return nil
|
||||
})
|
||||
|
||||
if count == 0 && err == ErrContractNotFound {
|
||||
return
|
||||
} else if err != nil {
|
||||
t.Fatalf("unable to count num outputs for channel %v: %v",
|
||||
chanPoint, err)
|
||||
}
|
||||
|
||||
if count != expectedNum {
|
||||
t.Fatalf("nursery store should have %d outputs, found %d",
|
||||
expectedNum, count)
|
||||
}
|
||||
}
|
||||
|
||||
// assertLastFinalizedHeight checks that the nursery stores last finalized
|
||||
// height matches the expected height.
|
||||
func assertLastFinalizedHeight(t *testing.T, ns NurseryStore,
|
||||
expected uint32) {
|
||||
|
||||
lfh, err := ns.LastFinalizedHeight()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get last finalized height: %v", err)
|
||||
}
|
||||
|
||||
if lfh != expected {
|
||||
t.Fatalf("expected last finalized height to be %d, got %d",
|
||||
expected, lfh)
|
||||
}
|
||||
}
|
||||
|
||||
// assertLastGraduatedHeight checks that the nursery stores last purged height
|
||||
// matches the expected height.
|
||||
func assertLastGraduatedHeight(t *testing.T, ns NurseryStore, expected uint32) {
|
||||
lgh, err := ns.LastGraduatedHeight()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get last graduated height: %v", err)
|
||||
}
|
||||
|
||||
if lgh != expected {
|
||||
t.Fatalf("expected last graduated height to be %d, got %d",
|
||||
expected, lgh)
|
||||
}
|
||||
}
|
||||
|
||||
// assertNumPreschools loads all preschool outputs and verifies their count
|
||||
// matches the expected number.
|
||||
func assertNumPreschools(t *testing.T, ns NurseryStore, expected int) {
|
||||
psclOutputs, err := ns.FetchPreschools()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to retrieve preschool outputs: %v", err)
|
||||
}
|
||||
|
||||
if len(psclOutputs) != expected {
|
||||
t.Fatalf("expected number of pscl outputs to be %d, got %v",
|
||||
expected, len(psclOutputs))
|
||||
}
|
||||
}
|
||||
|
||||
// assertNumChannels checks that the nursery has a given number of active
|
||||
// channels.
|
||||
func assertNumChannels(t *testing.T, ns NurseryStore, expected int) {
|
||||
channels, err := ns.ListChannels()
|
||||
if err != nil {
|
||||
t.Fatalf("unable to fetch channels from nursery store: %v",
|
||||
err)
|
||||
}
|
||||
|
||||
if len(channels) != expected {
|
||||
t.Fatalf("expected number of active channels to be %d, got %d",
|
||||
expected, len(channels))
|
||||
}
|
||||
}
|
||||
|
||||
// assertHeightIsPurged checks that the finalized transaction, kindergarten, and
|
||||
// htlc outputs at a particular height are all nil.
|
||||
func assertHeightIsPurged(t *testing.T, ns NurseryStore,
|
||||
height uint32) {
|
||||
|
||||
finalTx, kndrOutputs, cribOutputs, err := ns.FetchClass(height)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to retrieve class at height=%d: %v",
|
||||
height, err)
|
||||
}
|
||||
|
||||
if finalTx != nil {
|
||||
t.Fatalf("height=%d not purged, final txn should be nil", height)
|
||||
}
|
||||
|
||||
if kndrOutputs != nil {
|
||||
t.Fatalf("height=%d not purged, kndr outputs should be nil", height)
|
||||
}
|
||||
|
||||
if cribOutputs != nil {
|
||||
t.Fatalf("height=%d not purged, crib outputs should be nil", height)
|
||||
}
|
||||
}
|
||||
|
||||
// assertCribAtExpiryHeight loads the class at the given height, and verifies
|
||||
// that the given htlc output is one of the crib outputs.
|
||||
func assertCribAtExpiryHeight(t *testing.T, ns NurseryStore,
|
||||
htlcOutput *babyOutput) {
|
||||
|
||||
expiryHeight := htlcOutput.expiry
|
||||
_, _, cribOutputs, err := ns.FetchClass(expiryHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to retrieve class at height=%d: %v",
|
||||
expiryHeight, err)
|
||||
}
|
||||
|
||||
for _, crib := range cribOutputs {
|
||||
if reflect.DeepEqual(&crib, htlcOutput) {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
t.Fatalf("could not find crib output %v at height %d",
|
||||
htlcOutput.OutPoint(), expiryHeight)
|
||||
}
|
||||
|
||||
// assertCribNotAtExpiryHeight loads the class at the given height, and verifies
|
||||
// that the given htlc output is not one of the crib outputs.
|
||||
func assertCribNotAtExpiryHeight(t *testing.T, ns NurseryStore,
|
||||
htlcOutput *babyOutput) {
|
||||
|
||||
expiryHeight := htlcOutput.expiry
|
||||
_, _, cribOutputs, err := ns.FetchClass(expiryHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to retrieve class at height %d: %v",
|
||||
expiryHeight, err)
|
||||
}
|
||||
|
||||
for _, crib := range cribOutputs {
|
||||
if reflect.DeepEqual(&crib, htlcOutput) {
|
||||
t.Fatalf("found find crib output %v at height %d",
|
||||
htlcOutput.OutPoint(), expiryHeight)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// assertFinalizedTxn loads the class at the given height and compares the
|
||||
// returned finalized txn to that in the class. It is safe to presented a nil
|
||||
// expected transaction.
|
||||
func assertFinalizedTxn(t *testing.T, ns NurseryStore, height uint32,
|
||||
exFinalTx *wire.MsgTx) {
|
||||
|
||||
finalTx, _, _, err := ns.FetchClass(height)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to fetch class at height=%d: %v", height,
|
||||
err)
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(finalTx, exFinalTx) {
|
||||
t.Fatalf("expected finalized txn at height=%d "+
|
||||
"to be %v, got %v", height, finalTx.TxHash(),
|
||||
exFinalTx.TxHash())
|
||||
}
|
||||
}
|
||||
|
||||
// assertKndrAtMaturityHeight loads the class at the provided height and
|
||||
// verifies that the provided kid output is one of the kindergarten outputs
|
||||
// returned.
|
||||
func assertKndrAtMaturityHeight(t *testing.T, ns NurseryStore,
|
||||
kndrOutput *kidOutput) {
|
||||
|
||||
maturityHeight := kndrOutput.ConfHeight() +
|
||||
kndrOutput.BlocksToMaturity()
|
||||
_, kndrOutputs, _, err := ns.FetchClass(maturityHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to retrieve class at height %d: %v",
|
||||
maturityHeight, err)
|
||||
}
|
||||
|
||||
for _, kndr := range kndrOutputs {
|
||||
if reflect.DeepEqual(&kndr, kndrOutput) {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
t.Fatalf("could not find kndr output %v at height %d",
|
||||
kndrOutput.OutPoint(), maturityHeight)
|
||||
}
|
||||
|
||||
// assertKndrNotAtMaturityHeight loads the class at the provided height and
|
||||
// verifies that the provided kid output is not one of the kindergarten outputs
|
||||
// returned.
|
||||
func assertKndrNotAtMaturityHeight(t *testing.T, ns NurseryStore,
|
||||
kndrOutput *kidOutput) {
|
||||
|
||||
maturityHeight := kndrOutput.ConfHeight() +
|
||||
kndrOutput.BlocksToMaturity()
|
||||
|
||||
_, kndrOutputs, _, err := ns.FetchClass(maturityHeight)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to retrieve class at height %d: %v",
|
||||
maturityHeight, err)
|
||||
}
|
||||
|
||||
for _, kndr := range kndrOutputs {
|
||||
if reflect.DeepEqual(&kndr, kndrOutput) {
|
||||
t.Fatalf("found find kndr output %v at height %d",
|
||||
kndrOutput.OutPoint(), maturityHeight)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// assertChannelMaturity queries the nursery store for the maturity of the given
|
||||
// channel, failing if the result does not match the expectedMaturity.
|
||||
func assertChannelMaturity(t *testing.T, ns NurseryStore,
|
||||
chanPoint *wire.OutPoint, expectedMaturity bool) {
|
||||
|
||||
isMature, err := ns.IsMatureChannel(chanPoint)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to fetch channel maturity: %v", err)
|
||||
}
|
||||
|
||||
if isMature != expectedMaturity {
|
||||
t.Fatalf("expected channel maturity: %v, actual: %v",
|
||||
expectedMaturity, isMature)
|
||||
}
|
||||
}
|
||||
|
||||
// assertCanRemoveChannel tries to remove a channel from the nursery store,
|
||||
// failing if the result does match expected canRemove.
|
||||
func assertCanRemoveChannel(t *testing.T, ns NurseryStore,
|
||||
chanPoint *wire.OutPoint, canRemove bool) {
|
||||
|
||||
err := ns.RemoveChannel(chanPoint)
|
||||
if canRemove && err != nil {
|
||||
t.Fatalf("expected nil when removing active channel, got: %v",
|
||||
err)
|
||||
} else if !canRemove && err != ErrImmatureChannel {
|
||||
t.Fatalf("expected ErrImmatureChannel when removing "+
|
||||
"active channel: %v", err)
|
||||
}
|
||||
}
|
||||
32
rpcserver.go
32
rpcserver.go
@ -942,7 +942,9 @@ func (r *rpcServer) forceCloseChan(channel *lnwallet.LightningChannel) (*chainha
|
||||
|
||||
// Send the closed channel summary over to the utxoNursery in order to
|
||||
// have its outputs swept back into the wallet once they're mature.
|
||||
r.server.utxoNursery.IncubateOutputs(closeSummary)
|
||||
if err := r.server.utxoNursery.IncubateOutputs(closeSummary); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
return &txid, closeSummary, nil
|
||||
}
|
||||
@ -1241,13 +1243,37 @@ func (r *rpcServer) PendingChannels(ctx context.Context,
|
||||
// we can ultimately sweep the funds into the wallet.
|
||||
if nurseryInfo != nil {
|
||||
forceClose.LimboBalance = int64(nurseryInfo.limboBalance)
|
||||
forceClose.RecoveredBalance = int64(nurseryInfo.recoveredBalance)
|
||||
forceClose.MaturityHeight = nurseryInfo.maturityHeight
|
||||
|
||||
// If the transaction has been confirmed, then
|
||||
// we can compute how many blocks it has left.
|
||||
if forceClose.MaturityHeight != 0 {
|
||||
forceClose.BlocksTilMaturity = (forceClose.MaturityHeight -
|
||||
uint32(currentHeight))
|
||||
forceClose.BlocksTilMaturity =
|
||||
int32(forceClose.MaturityHeight) -
|
||||
currentHeight
|
||||
}
|
||||
|
||||
for _, htlcReport := range nurseryInfo.htlcs {
|
||||
// TODO(conner) set incoming flag
|
||||
// appropriately after handling incoming
|
||||
// incubation
|
||||
htlc := &lnrpc.PendingHTLC{
|
||||
Incoming: false,
|
||||
Amount: int64(htlcReport.amount),
|
||||
Outpoint: htlcReport.outpoint.String(),
|
||||
MaturityHeight: htlcReport.maturityHeight,
|
||||
Stage: htlcReport.stage,
|
||||
}
|
||||
|
||||
if htlc.MaturityHeight != 0 {
|
||||
htlc.BlocksTilMaturity =
|
||||
int32(htlc.MaturityHeight) -
|
||||
currentHeight
|
||||
}
|
||||
|
||||
forceClose.PendingHtlcs = append(forceClose.PendingHtlcs,
|
||||
htlc)
|
||||
}
|
||||
|
||||
resp.TotalLimboBalance += int64(nurseryInfo.limboBalance)
|
||||
|
||||
38
server.go
38
server.go
@ -136,8 +136,6 @@ func newServer(listenAddrs []string, chanDB *channeldb.DB, cc *chainControl,
|
||||
|
||||
invoices: newInvoiceRegistry(chanDB),
|
||||
|
||||
utxoNursery: newUtxoNursery(chanDB, cc.chainNotifier, cc.wallet),
|
||||
|
||||
identityPriv: privKey,
|
||||
nodeSigner: newNodeSigner(privKey),
|
||||
|
||||
@ -306,6 +304,26 @@ func newServer(listenAddrs []string, chanDB *channeldb.DB, cc *chainControl,
|
||||
return nil, err
|
||||
}
|
||||
|
||||
utxnStore, err := newNurseryStore(&bitcoinGenesis, chanDB)
|
||||
if err != nil {
|
||||
srvrLog.Errorf("unable to create nursery store: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
s.utxoNursery = newUtxoNursery(&NurseryConfig{
|
||||
ChainIO: cc.chainIO,
|
||||
ConfDepth: 1,
|
||||
DB: chanDB,
|
||||
Estimator: cc.feeEstimator,
|
||||
GenSweepScript: func() ([]byte, error) {
|
||||
return newSweepPkScript(cc.wallet)
|
||||
},
|
||||
Notifier: cc.chainNotifier,
|
||||
PublishTransaction: cc.wallet.PublishTransaction,
|
||||
Signer: cc.wallet.Cfg.Signer,
|
||||
Store: utxnStore,
|
||||
})
|
||||
|
||||
// Construct a closure that wraps the htlcswitch's CloseLink method.
|
||||
closeLink := func(chanPoint *wire.OutPoint,
|
||||
closureType htlcswitch.ChannelCloseType) {
|
||||
@ -315,17 +333,17 @@ func newServer(listenAddrs []string, chanDB *channeldb.DB, cc *chainControl,
|
||||
}
|
||||
|
||||
s.breachArbiter = newBreachArbiter(&BreachConfig{
|
||||
Signer: cc.wallet.Cfg.Signer,
|
||||
DB: chanDB,
|
||||
PublishTransaction: cc.wallet.PublishTransaction,
|
||||
Notifier: cc.chainNotifier,
|
||||
ChainIO: s.cc.chainIO,
|
||||
Estimator: s.cc.feeEstimator,
|
||||
CloseLink: closeLink,
|
||||
Store: newRetributionStore(chanDB),
|
||||
ChainIO: s.cc.chainIO,
|
||||
CloseLink: closeLink,
|
||||
DB: chanDB,
|
||||
Estimator: s.cc.feeEstimator,
|
||||
GenSweepScript: func() ([]byte, error) {
|
||||
return newSweepPkScript(cc.wallet)
|
||||
},
|
||||
Notifier: cc.chainNotifier,
|
||||
PublishTransaction: cc.wallet.PublishTransaction,
|
||||
Signer: cc.wallet.Cfg.Signer,
|
||||
Store: newRetributionStore(chanDB),
|
||||
})
|
||||
|
||||
// Create the connection manager which will be responsible for
|
||||
|
||||
1971
utxonursery.go
1971
utxonursery.go
File diff suppressed because it is too large
Load Diff
@ -40,11 +40,38 @@ var (
|
||||
Hash: [chainhash.HashSize]byte{
|
||||
0x81, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
|
||||
0x63, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
|
||||
0xd, 0xe7, 0x95, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
|
||||
0x0d, 0xe7, 0x95, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
|
||||
0x1e, 0xb, 0x4c, 0xfd, 0x9e, 0xc5, 0x8c, 0xe9,
|
||||
},
|
||||
Index: 23,
|
||||
},
|
||||
{
|
||||
Hash: [chainhash.HashSize]byte{
|
||||
0x1e, 0xb, 0x4c, 0xfd, 0x9e, 0xc5, 0x8c, 0xe9,
|
||||
0x81, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
|
||||
0x0d, 0xe7, 0x95, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
|
||||
0x63, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
|
||||
},
|
||||
Index: 30,
|
||||
},
|
||||
{
|
||||
Hash: [chainhash.HashSize]byte{
|
||||
0x0d, 0xe7, 0x95, 0xe4, 0xfc, 0xd2, 0xc6, 0xda,
|
||||
0xb7, 0x25, 0xb8, 0x4d, 0x63, 0x59, 0xe6, 0x96,
|
||||
0x31, 0x13, 0xa1, 0x17, 0x81, 0xb6, 0x37, 0xd8,
|
||||
0x1e, 0x0b, 0x4c, 0xfd, 0x9e, 0xc5, 0x8c, 0xe9,
|
||||
},
|
||||
Index: 2,
|
||||
},
|
||||
{
|
||||
Hash: [chainhash.HashSize]byte{
|
||||
0x48, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
|
||||
0x51, 0xb6, 0x37, 0xd8, 0x1f, 0x0b, 0x4c, 0xf9,
|
||||
0x9e, 0xc5, 0x8c, 0xe9, 0xfc, 0xd2, 0xc6, 0xda,
|
||||
0x2d, 0xe7, 0x93, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
|
||||
},
|
||||
Index: 9,
|
||||
},
|
||||
}
|
||||
|
||||
keys = [][]byte{
|
||||
@ -170,50 +197,61 @@ var (
|
||||
{
|
||||
breachedOutput: breachedOutput{
|
||||
amt: btcutil.Amount(13e7),
|
||||
outpoint: outPoints[0],
|
||||
outpoint: outPoints[1],
|
||||
witnessType: lnwallet.CommitmentTimeLock,
|
||||
},
|
||||
originChanPoint: outPoints[1],
|
||||
blocksToMaturity: uint32(100),
|
||||
confHeight: uint32(1770001),
|
||||
originChanPoint: outPoints[0],
|
||||
blocksToMaturity: uint32(42),
|
||||
confHeight: uint32(1000),
|
||||
},
|
||||
|
||||
{
|
||||
breachedOutput: breachedOutput{
|
||||
amt: btcutil.Amount(24e7),
|
||||
outpoint: outPoints[1],
|
||||
outpoint: outPoints[2],
|
||||
witnessType: lnwallet.CommitmentTimeLock,
|
||||
},
|
||||
originChanPoint: outPoints[0],
|
||||
blocksToMaturity: uint32(50),
|
||||
confHeight: uint32(22342321),
|
||||
blocksToMaturity: uint32(42),
|
||||
confHeight: uint32(1000),
|
||||
},
|
||||
|
||||
{
|
||||
breachedOutput: breachedOutput{
|
||||
amt: btcutil.Amount(2e5),
|
||||
outpoint: outPoints[2],
|
||||
outpoint: outPoints[3],
|
||||
witnessType: lnwallet.CommitmentTimeLock,
|
||||
},
|
||||
originChanPoint: outPoints[2],
|
||||
blocksToMaturity: uint32(12),
|
||||
confHeight: uint32(34241),
|
||||
originChanPoint: outPoints[0],
|
||||
blocksToMaturity: uint32(28),
|
||||
confHeight: uint32(500),
|
||||
},
|
||||
|
||||
{
|
||||
breachedOutput: breachedOutput{
|
||||
amt: btcutil.Amount(10e6),
|
||||
outpoint: outPoints[4],
|
||||
witnessType: lnwallet.CommitmentTimeLock,
|
||||
},
|
||||
originChanPoint: outPoints[0],
|
||||
blocksToMaturity: uint32(28),
|
||||
confHeight: uint32(500),
|
||||
},
|
||||
}
|
||||
|
||||
babyOutputs = []babyOutput{
|
||||
{
|
||||
kidOutput: kidOutputs[0],
|
||||
kidOutput: kidOutputs[1],
|
||||
expiry: 3829,
|
||||
timeoutTx: timeoutTx,
|
||||
},
|
||||
{
|
||||
kidOutput: kidOutputs[1],
|
||||
expiry: 85903,
|
||||
kidOutput: kidOutputs[2],
|
||||
expiry: 4,
|
||||
timeoutTx: timeoutTx,
|
||||
},
|
||||
{
|
||||
kidOutput: kidOutputs[2],
|
||||
kidOutput: kidOutputs[3],
|
||||
expiry: 4,
|
||||
timeoutTx: timeoutTx,
|
||||
},
|
||||
@ -283,32 +321,18 @@ func init() {
|
||||
}
|
||||
signDescriptors[i].PubKey = pk
|
||||
|
||||
kidOutputs[i].signDesc = signDescriptors[i]
|
||||
babyOutputs[i].kidOutput.signDesc = signDescriptors[i]
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeserializeKidsList(t *testing.T) {
|
||||
var b bytes.Buffer
|
||||
for _, kid := range kidOutputs {
|
||||
if err := kid.Encode(&b); err != nil {
|
||||
t.Fatalf("unable to serialize and add kid output to "+
|
||||
"list: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
kidList, err := deserializeKidList(&b)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to deserialize kid output list: %v", err)
|
||||
}
|
||||
|
||||
for i := range kidOutputs {
|
||||
if !reflect.DeepEqual(&kidOutputs[i], kidList[i]) {
|
||||
t.Fatalf("kidOutputs don't match \n%+v\n%+v",
|
||||
&kidOutputs[i], kidList[i])
|
||||
}
|
||||
isd := i % len(signDescriptors)
|
||||
kidOutputs[i].signDesc = signDescriptors[isd]
|
||||
}
|
||||
|
||||
for i := range babyOutputs {
|
||||
isd := i % len(signDescriptors)
|
||||
babyOutputs[i].kidOutput.signDesc = signDescriptors[isd]
|
||||
}
|
||||
|
||||
initIncubateTests()
|
||||
}
|
||||
|
||||
func TestKidOutputSerialization(t *testing.T) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user