ab4da0f53d
This commits exposes the various parameters around going to chain and accepting htlcs in a clear way. In addition to this, it reverts those parameters to what they were before the merge of commit d1076271456bdab1625ea6b52b93ca3e1bd9aed9.
1204 lines
33 KiB
Go
1204 lines
33 KiB
Go
package contractcourt
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/lightningnetwork/lnd/chainntnfs"
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
"github.com/lightningnetwork/lnd/input"
|
|
"github.com/lightningnetwork/lnd/lnwallet"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
)
|
|
|
|
type mockArbitratorLog struct {
|
|
state ArbitratorState
|
|
newStates chan ArbitratorState
|
|
failLog bool
|
|
failFetch error
|
|
failCommit bool
|
|
failCommitState ArbitratorState
|
|
resolutions *ContractResolutions
|
|
chainActions ChainActionMap
|
|
resolvers map[ContractResolver]struct{}
|
|
|
|
sync.Mutex
|
|
}
|
|
|
|
// A compile time check to ensure mockArbitratorLog meets the ArbitratorLog
|
|
// interface.
|
|
var _ ArbitratorLog = (*mockArbitratorLog)(nil)
|
|
|
|
func (b *mockArbitratorLog) CurrentState() (ArbitratorState, error) {
|
|
return b.state, nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) CommitState(s ArbitratorState) error {
|
|
if b.failCommit && s == b.failCommitState {
|
|
return fmt.Errorf("intentional commit error at state %v",
|
|
b.failCommitState)
|
|
}
|
|
b.state = s
|
|
b.newStates <- s
|
|
return nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) FetchUnresolvedContracts() ([]ContractResolver,
|
|
error) {
|
|
|
|
b.Lock()
|
|
v := make([]ContractResolver, len(b.resolvers))
|
|
idx := 0
|
|
for resolver := range b.resolvers {
|
|
v[idx] = resolver
|
|
idx++
|
|
}
|
|
b.Unlock()
|
|
|
|
return v, nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) InsertUnresolvedContracts(
|
|
resolvers ...ContractResolver) error {
|
|
|
|
b.Lock()
|
|
for _, resolver := range resolvers {
|
|
b.resolvers[resolver] = struct{}{}
|
|
}
|
|
b.Unlock()
|
|
return nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) SwapContract(oldContract,
|
|
newContract ContractResolver) error {
|
|
|
|
b.Lock()
|
|
delete(b.resolvers, oldContract)
|
|
b.resolvers[newContract] = struct{}{}
|
|
b.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) ResolveContract(res ContractResolver) error {
|
|
b.Lock()
|
|
delete(b.resolvers, res)
|
|
b.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) LogContractResolutions(c *ContractResolutions) error {
|
|
if b.failLog {
|
|
return fmt.Errorf("intentional log failure")
|
|
}
|
|
b.resolutions = c
|
|
return nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) FetchContractResolutions() (*ContractResolutions, error) {
|
|
if b.failFetch != nil {
|
|
return nil, b.failFetch
|
|
}
|
|
|
|
return b.resolutions, nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) LogChainActions(actions ChainActionMap) error {
|
|
b.chainActions = actions
|
|
return nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) FetchChainActions() (ChainActionMap, error) {
|
|
actionsMap := b.chainActions
|
|
return actionsMap, nil
|
|
}
|
|
|
|
func (b *mockArbitratorLog) WipeHistory() error {
|
|
return nil
|
|
}
|
|
|
|
type mockChainIO struct{}
|
|
|
|
func (*mockChainIO) GetBestBlock() (*chainhash.Hash, int32, error) {
|
|
return nil, 0, nil
|
|
}
|
|
|
|
func (*mockChainIO) GetUtxo(op *wire.OutPoint, _ []byte,
|
|
heightHint uint32) (*wire.TxOut, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (*mockChainIO) GetBlockHash(blockHeight int64) (*chainhash.Hash, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (*mockChainIO) GetBlock(blockHash *chainhash.Hash) (*wire.MsgBlock, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func createTestChannelArbitrator(log ArbitratorLog) (*ChannelArbitrator,
|
|
chan struct{}, error) {
|
|
blockEpoch := &chainntnfs.BlockEpochEvent{
|
|
Cancel: func() {},
|
|
}
|
|
|
|
chanPoint := wire.OutPoint{}
|
|
shortChanID := lnwire.ShortChannelID{}
|
|
chanEvents := &ChainEventSubscription{
|
|
RemoteUnilateralClosure: make(chan *lnwallet.UnilateralCloseSummary, 1),
|
|
LocalUnilateralClosure: make(chan *LocalUnilateralCloseInfo, 1),
|
|
CooperativeClosure: make(chan *CooperativeCloseInfo, 1),
|
|
ContractBreach: make(chan *lnwallet.BreachRetribution, 1),
|
|
}
|
|
|
|
chainIO := &mockChainIO{}
|
|
chainArbCfg := ChainArbitratorConfig{
|
|
ChainIO: chainIO,
|
|
PublishTx: func(*wire.MsgTx) error {
|
|
return nil
|
|
},
|
|
DeliverResolutionMsg: func(...ResolutionMsg) error {
|
|
return nil
|
|
},
|
|
OutgoingBroadcastDelta: 5,
|
|
IncomingBroadcastDelta: 5,
|
|
Notifier: &mockNotifier{
|
|
epochChan: make(chan *chainntnfs.BlockEpoch),
|
|
spendChan: make(chan *chainntnfs.SpendDetail),
|
|
confChan: make(chan *chainntnfs.TxConfirmation),
|
|
},
|
|
IncubateOutputs: func(wire.OutPoint, *lnwallet.CommitOutputResolution,
|
|
*lnwallet.OutgoingHtlcResolution,
|
|
*lnwallet.IncomingHtlcResolution, uint32) error {
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// We'll use the resolvedChan to synchronize on call to
|
|
// MarkChannelResolved.
|
|
resolvedChan := make(chan struct{}, 1)
|
|
|
|
// Next we'll create the matching configuration struct that contains
|
|
// all interfaces and methods the arbitrator needs to do its job.
|
|
arbCfg := ChannelArbitratorConfig{
|
|
ChanPoint: chanPoint,
|
|
ShortChanID: shortChanID,
|
|
BlockEpochs: blockEpoch,
|
|
MarkChannelResolved: func() error {
|
|
resolvedChan <- struct{}{}
|
|
return nil
|
|
},
|
|
ForceCloseChan: func() (*lnwallet.LocalForceCloseSummary, error) {
|
|
summary := &lnwallet.LocalForceCloseSummary{
|
|
CloseTx: &wire.MsgTx{},
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
}
|
|
return summary, nil
|
|
},
|
|
MarkCommitmentBroadcasted: func() error {
|
|
return nil
|
|
},
|
|
MarkChannelClosed: func(*channeldb.ChannelCloseSummary) error {
|
|
return nil
|
|
},
|
|
IsPendingClose: false,
|
|
ChainArbitratorConfig: chainArbCfg,
|
|
ChainEvents: chanEvents,
|
|
}
|
|
|
|
return NewChannelArbitrator(arbCfg, nil, log), resolvedChan, nil
|
|
}
|
|
|
|
// assertState checks that the ChannelArbitrator is in the state we expect it
|
|
// to be.
|
|
func assertState(t *testing.T, c *ChannelArbitrator, expected ArbitratorState) {
|
|
if c.state != expected {
|
|
t.Fatalf("expected state %v, was %v", expected, c.state)
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorCooperativeClose tests that the ChannelArbitertor
|
|
// correctly marks the channel resolved in case a cooperative close is
|
|
// confirmed.
|
|
func TestChannelArbitratorCooperativeClose(t *testing.T) {
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// It should start out in the default state.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// We set up a channel to detect when MarkChannelClosed is called.
|
|
closeInfos := make(chan *channeldb.ChannelCloseSummary)
|
|
chanArb.cfg.MarkChannelClosed = func(
|
|
closeInfo *channeldb.ChannelCloseSummary) error {
|
|
closeInfos <- closeInfo
|
|
return nil
|
|
}
|
|
|
|
// Cooperative close should do trigger a MarkChannelClosed +
|
|
// MarkChannelResolved.
|
|
closeInfo := &CooperativeCloseInfo{
|
|
&channeldb.ChannelCloseSummary{},
|
|
}
|
|
chanArb.cfg.ChainEvents.CooperativeClosure <- closeInfo
|
|
|
|
select {
|
|
case c := <-closeInfos:
|
|
if c.CloseType != channeldb.CooperativeClose {
|
|
t.Fatalf("expected cooperative close, got %v", c.CloseType)
|
|
}
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("timeout waiting for channel close")
|
|
}
|
|
|
|
// It should mark the channel as resolved.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
func assertStateTransitions(t *testing.T, newStates <-chan ArbitratorState,
|
|
expectedStates ...ArbitratorState) {
|
|
t.Helper()
|
|
|
|
for _, exp := range expectedStates {
|
|
var state ArbitratorState
|
|
select {
|
|
case state = <-newStates:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("new state not received")
|
|
}
|
|
|
|
if state != exp {
|
|
t.Fatalf("expected new state %v, got %v", exp, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorRemoteForceClose checks that the ChannelArbitrator goes
|
|
// through the expected states if a remote force close is observed in the
|
|
// chain.
|
|
func TestChannelArbitratorRemoteForceClose(t *testing.T) {
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// It should start out in the default state.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// Send a remote force close event.
|
|
commitSpend := &chainntnfs.SpendDetail{
|
|
SpenderTxHash: &chainhash.Hash{},
|
|
}
|
|
|
|
uniClose := &lnwallet.UnilateralCloseSummary{
|
|
SpendDetail: commitSpend,
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
}
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
|
|
// It should transition StateDefault -> StateContractClosed ->
|
|
// StateFullyResolved.
|
|
assertStateTransitions(
|
|
t, log.newStates, StateContractClosed, StateFullyResolved,
|
|
)
|
|
|
|
// It should alos mark the channel as resolved.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorLocalForceClose tests that the ChannelArbitrator goes
|
|
// through the expected states in case we request it to force close the channel,
|
|
// and the local force close event is observed in chain.
|
|
func TestChannelArbitratorLocalForceClose(t *testing.T) {
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// It should start out in the default state.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// We create a channel we can use to pause the ChannelArbitrator at the
|
|
// point where it broadcasts the close tx, and check its state.
|
|
stateChan := make(chan ArbitratorState)
|
|
chanArb.cfg.PublishTx = func(*wire.MsgTx) error {
|
|
// When the force close tx is being broadcasted, check that the
|
|
// state is correct at that point.
|
|
select {
|
|
case stateChan <- chanArb.state:
|
|
case <-chanArb.quit:
|
|
return fmt.Errorf("exiting")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
errChan := make(chan error, 1)
|
|
respChan := make(chan *wire.MsgTx, 1)
|
|
|
|
// With the channel found, and the request crafted, we'll send over a
|
|
// force close request to the arbitrator that watches this channel.
|
|
chanArb.forceCloseReqs <- &forceCloseReq{
|
|
errResp: errChan,
|
|
closeTx: respChan,
|
|
}
|
|
|
|
// It should transition to StateBroadcastCommit.
|
|
assertStateTransitions(t, log.newStates, StateBroadcastCommit)
|
|
|
|
// When it is broadcasting the force close, its state should be
|
|
// StateBroadcastCommit.
|
|
select {
|
|
case state := <-stateChan:
|
|
if state != StateBroadcastCommit {
|
|
t.Fatalf("state during PublishTx was %v", state)
|
|
}
|
|
case <-time.After(15 * time.Second):
|
|
t.Fatalf("did not get state update")
|
|
}
|
|
|
|
// After broadcasting, transition should be to
|
|
// StateCommitmentBroadcasted.
|
|
assertStateTransitions(t, log.newStates, StateCommitmentBroadcasted)
|
|
|
|
select {
|
|
case <-respChan:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
select {
|
|
case err := <-errChan:
|
|
if err != nil {
|
|
t.Fatalf("error force closing channel: %v", err)
|
|
}
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
// After broadcasting the close tx, it should be in state
|
|
// StateCommitmentBroadcasted.
|
|
assertState(t, chanArb, StateCommitmentBroadcasted)
|
|
|
|
// Now notify about the local force close getting confirmed.
|
|
chanArb.cfg.ChainEvents.LocalUnilateralClosure <- &LocalUnilateralCloseInfo{
|
|
&chainntnfs.SpendDetail{},
|
|
&lnwallet.LocalForceCloseSummary{
|
|
CloseTx: &wire.MsgTx{},
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
},
|
|
&channeldb.ChannelCloseSummary{},
|
|
}
|
|
|
|
// It should transition StateContractClosed -> StateFullyResolved.
|
|
assertStateTransitions(t, log.newStates, StateContractClosed,
|
|
StateFullyResolved)
|
|
|
|
// It should also mark the channel as resolved.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorLocalForceClosePendingHtlc tests that the
|
|
// ChannelArbitrator goes through the expected states in case we request it to
|
|
// force close a channel that still has an HTLC pending.
|
|
func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
|
|
arbLog := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
resolvers: make(map[ContractResolver]struct{}),
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(arbLog)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
incubateChan := make(chan struct{})
|
|
chanArb.cfg.IncubateOutputs = func(_ wire.OutPoint,
|
|
_ *lnwallet.CommitOutputResolution,
|
|
_ *lnwallet.OutgoingHtlcResolution,
|
|
_ *lnwallet.IncomingHtlcResolution, _ uint32) error {
|
|
|
|
incubateChan <- struct{}{}
|
|
|
|
return nil
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// Create htlcUpdates channel.
|
|
htlcUpdates := make(chan []channeldb.HTLC)
|
|
|
|
signals := &ContractSignals{
|
|
HtlcUpdates: htlcUpdates,
|
|
ShortChanID: lnwire.ShortChannelID{},
|
|
}
|
|
chanArb.UpdateContractSignals(signals)
|
|
|
|
// Add HTLC to channel arbitrator.
|
|
htlc := channeldb.HTLC{
|
|
Incoming: false,
|
|
Amt: 10000,
|
|
HtlcIndex: 0,
|
|
}
|
|
|
|
htlcUpdates <- []channeldb.HTLC{
|
|
htlc,
|
|
}
|
|
|
|
errChan := make(chan error, 1)
|
|
respChan := make(chan *wire.MsgTx, 1)
|
|
|
|
// With the channel found, and the request crafted, we'll send over a
|
|
// force close request to the arbitrator that watches this channel.
|
|
chanArb.forceCloseReqs <- &forceCloseReq{
|
|
errResp: errChan,
|
|
closeTx: respChan,
|
|
}
|
|
|
|
// The force close request should trigger broadcast of the commitment
|
|
// transaction.
|
|
assertStateTransitions(
|
|
t, arbLog.newStates, StateBroadcastCommit,
|
|
StateCommitmentBroadcasted,
|
|
)
|
|
select {
|
|
case <-respChan:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
select {
|
|
case err := <-errChan:
|
|
if err != nil {
|
|
t.Fatalf("error force closing channel: %v", err)
|
|
}
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
// Now notify about the local force close getting confirmed.
|
|
closeTx := &wire.MsgTx{
|
|
TxIn: []*wire.TxIn{
|
|
{
|
|
PreviousOutPoint: wire.OutPoint{},
|
|
Witness: [][]byte{
|
|
{0x1},
|
|
{0x2},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
htlcOp := wire.OutPoint{
|
|
Hash: closeTx.TxHash(),
|
|
Index: 0,
|
|
}
|
|
|
|
// Set up the outgoing resolution. Populate SignedTimeoutTx because
|
|
// our commitment transaction got confirmed.
|
|
outgoingRes := lnwallet.OutgoingHtlcResolution{
|
|
Expiry: 10,
|
|
SweepSignDesc: input.SignDescriptor{
|
|
Output: &wire.TxOut{},
|
|
},
|
|
SignedTimeoutTx: &wire.MsgTx{
|
|
TxIn: []*wire.TxIn{
|
|
{
|
|
PreviousOutPoint: htlcOp,
|
|
Witness: [][]byte{{}},
|
|
},
|
|
},
|
|
TxOut: []*wire.TxOut{
|
|
{},
|
|
},
|
|
},
|
|
}
|
|
|
|
chanArb.cfg.ChainEvents.LocalUnilateralClosure <- &LocalUnilateralCloseInfo{
|
|
&chainntnfs.SpendDetail{},
|
|
&lnwallet.LocalForceCloseSummary{
|
|
CloseTx: closeTx,
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{
|
|
OutgoingHTLCs: []lnwallet.OutgoingHtlcResolution{
|
|
outgoingRes,
|
|
},
|
|
},
|
|
},
|
|
&channeldb.ChannelCloseSummary{},
|
|
}
|
|
|
|
assertStateTransitions(
|
|
t, arbLog.newStates, StateContractClosed,
|
|
StateWaitingFullResolution,
|
|
)
|
|
|
|
// htlcOutgoingContestResolver is now active and waiting for the HTLC to
|
|
// expire. It should not yet have passed it on for incubation.
|
|
select {
|
|
case <-incubateChan:
|
|
t.Fatalf("contract should not be incubated yet")
|
|
default:
|
|
}
|
|
|
|
// Send a notification that the expiry height has been reached.
|
|
notifier := chanArb.cfg.Notifier.(*mockNotifier)
|
|
notifier.epochChan <- &chainntnfs.BlockEpoch{Height: 10}
|
|
|
|
// htlcOutgoingContestResolver is now transforming into a
|
|
// htlcTimeoutResolver and should send the contract off for incubation.
|
|
select {
|
|
case <-incubateChan:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
// Notify resolver that the HTLC output of the commitment has been
|
|
// spent.
|
|
notifier.spendChan <- &chainntnfs.SpendDetail{SpendingTx: closeTx}
|
|
|
|
// As this is our own commitment transaction, the HTLC will go through
|
|
// to the second level. Channel arbitrator should still not be marked
|
|
// as resolved.
|
|
select {
|
|
case <-resolved:
|
|
t.Fatalf("channel resolved prematurely")
|
|
default:
|
|
}
|
|
|
|
// Notify resolver that the second level transaction is spent.
|
|
notifier.spendChan <- &chainntnfs.SpendDetail{SpendingTx: closeTx}
|
|
|
|
// At this point channel should be marked as resolved.
|
|
assertStateTransitions(t, arbLog.newStates, StateFullyResolved)
|
|
|
|
select {
|
|
case <-resolved:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorLocalForceCloseRemoteConfiremd tests that the
|
|
// ChannelArbitrator behaves as expected in the case where we request a local
|
|
// force close, but a remote commitment ends up being confirmed in chain.
|
|
func TestChannelArbitratorLocalForceCloseRemoteConfirmed(t *testing.T) {
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// It should start out in the default state.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// Create a channel we can use to assert the state when it publishes
|
|
// the close tx.
|
|
stateChan := make(chan ArbitratorState)
|
|
chanArb.cfg.PublishTx = func(*wire.MsgTx) error {
|
|
// When the force close tx is being broadcasted, check that the
|
|
// state is correct at that point.
|
|
select {
|
|
case stateChan <- chanArb.state:
|
|
case <-chanArb.quit:
|
|
return fmt.Errorf("exiting")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
errChan := make(chan error, 1)
|
|
respChan := make(chan *wire.MsgTx, 1)
|
|
|
|
// With the channel found, and the request crafted, we'll send over a
|
|
// force close request to the arbitrator that watches this channel.
|
|
chanArb.forceCloseReqs <- &forceCloseReq{
|
|
errResp: errChan,
|
|
closeTx: respChan,
|
|
}
|
|
|
|
// It should transition to StateBroadcastCommit.
|
|
assertStateTransitions(t, log.newStates, StateBroadcastCommit)
|
|
|
|
// We expect it to be in state StateBroadcastCommit when publishing
|
|
// the force close.
|
|
select {
|
|
case state := <-stateChan:
|
|
if state != StateBroadcastCommit {
|
|
t.Fatalf("state during PublishTx was %v", state)
|
|
}
|
|
case <-time.After(15 * time.Second):
|
|
t.Fatalf("no state update received")
|
|
}
|
|
|
|
// After broadcasting, transition should be to
|
|
// StateCommitmentBroadcasted.
|
|
assertStateTransitions(t, log.newStates, StateCommitmentBroadcasted)
|
|
|
|
// Wait for a response to the force close.
|
|
select {
|
|
case <-respChan:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
select {
|
|
case err := <-errChan:
|
|
if err != nil {
|
|
t.Fatalf("error force closing channel: %v", err)
|
|
}
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
// The state should be StateCommitmentBroadcasted.
|
|
assertState(t, chanArb, StateCommitmentBroadcasted)
|
|
|
|
// Now notify about the _REMOTE_ commitment getting confirmed.
|
|
commitSpend := &chainntnfs.SpendDetail{
|
|
SpenderTxHash: &chainhash.Hash{},
|
|
}
|
|
uniClose := &lnwallet.UnilateralCloseSummary{
|
|
SpendDetail: commitSpend,
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
}
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
|
|
// It should transition StateContractClosed -> StateFullyResolved.
|
|
assertStateTransitions(t, log.newStates, StateContractClosed,
|
|
StateFullyResolved)
|
|
|
|
// It should resolve.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(15 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorLocalForceCloseDoubleSpend tests that the
|
|
// ChannelArbitrator behaves as expected in the case where we request a local
|
|
// force close, but we fail broadcasting our commitment because a remote
|
|
// commitment has already been published.
|
|
func TestChannelArbitratorLocalForceDoubleSpend(t *testing.T) {
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// It should start out in the default state.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// Return ErrDoubleSpend when attempting to publish the tx.
|
|
stateChan := make(chan ArbitratorState)
|
|
chanArb.cfg.PublishTx = func(*wire.MsgTx) error {
|
|
// When the force close tx is being broadcasted, check that the
|
|
// state is correct at that point.
|
|
select {
|
|
case stateChan <- chanArb.state:
|
|
case <-chanArb.quit:
|
|
return fmt.Errorf("exiting")
|
|
}
|
|
return lnwallet.ErrDoubleSpend
|
|
}
|
|
|
|
errChan := make(chan error, 1)
|
|
respChan := make(chan *wire.MsgTx, 1)
|
|
|
|
// With the channel found, and the request crafted, we'll send over a
|
|
// force close request to the arbitrator that watches this channel.
|
|
chanArb.forceCloseReqs <- &forceCloseReq{
|
|
errResp: errChan,
|
|
closeTx: respChan,
|
|
}
|
|
|
|
// It should transition to StateBroadcastCommit.
|
|
assertStateTransitions(t, log.newStates, StateBroadcastCommit)
|
|
|
|
// We expect it to be in state StateBroadcastCommit when publishing
|
|
// the force close.
|
|
select {
|
|
case state := <-stateChan:
|
|
if state != StateBroadcastCommit {
|
|
t.Fatalf("state during PublishTx was %v", state)
|
|
}
|
|
case <-time.After(15 * time.Second):
|
|
t.Fatalf("no state update received")
|
|
}
|
|
|
|
// After broadcasting, transition should be to
|
|
// StateCommitmentBroadcasted.
|
|
assertStateTransitions(t, log.newStates, StateCommitmentBroadcasted)
|
|
|
|
// Wait for a response to the force close.
|
|
select {
|
|
case <-respChan:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
select {
|
|
case err := <-errChan:
|
|
if err != nil {
|
|
t.Fatalf("error force closing channel: %v", err)
|
|
}
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("no response received")
|
|
}
|
|
|
|
// The state should be StateCommitmentBroadcasted.
|
|
assertState(t, chanArb, StateCommitmentBroadcasted)
|
|
|
|
// Now notify about the _REMOTE_ commitment getting confirmed.
|
|
commitSpend := &chainntnfs.SpendDetail{
|
|
SpenderTxHash: &chainhash.Hash{},
|
|
}
|
|
uniClose := &lnwallet.UnilateralCloseSummary{
|
|
SpendDetail: commitSpend,
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
}
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
|
|
// It should transition StateContractClosed -> StateFullyResolved.
|
|
assertStateTransitions(t, log.newStates, StateContractClosed,
|
|
StateFullyResolved)
|
|
|
|
// It should resolve.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(15 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorPersistence tests that the ChannelArbitrator is able to
|
|
// keep advancing the state machine from various states after restart.
|
|
func TestChannelArbitratorPersistence(t *testing.T) {
|
|
// Start out with a log that will fail writing the set of resolutions.
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
failLog: true,
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
// It should start in StateDefault.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// Send a remote force close event.
|
|
commitSpend := &chainntnfs.SpendDetail{
|
|
SpenderTxHash: &chainhash.Hash{},
|
|
}
|
|
|
|
uniClose := &lnwallet.UnilateralCloseSummary{
|
|
SpendDetail: commitSpend,
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
}
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
|
|
// Since writing the resolutions fail, the arbitrator should not
|
|
// advance to the next state.
|
|
time.Sleep(100 * time.Millisecond)
|
|
if log.state != StateDefault {
|
|
t.Fatalf("expected to stay in StateDefault")
|
|
}
|
|
chanArb.Stop()
|
|
|
|
// Create a new arbitrator with the same log.
|
|
chanArb, resolved, err = createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
// Again, it should start up in the default state.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// Now we make the log succeed writing the resolutions, but fail when
|
|
// attempting to close the channel.
|
|
log.failLog = false
|
|
chanArb.cfg.MarkChannelClosed = func(*channeldb.ChannelCloseSummary) error {
|
|
return fmt.Errorf("intentional close error")
|
|
}
|
|
|
|
// Send a new remote force close event.
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
|
|
// Since closing the channel failed, the arbitrator should stay in the
|
|
// default state.
|
|
time.Sleep(100 * time.Millisecond)
|
|
if log.state != StateDefault {
|
|
t.Fatalf("expected to stay in StateDefault")
|
|
}
|
|
chanArb.Stop()
|
|
|
|
// Create yet another arbitrator with the same log.
|
|
chanArb, resolved, err = createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
// Starts out in StateDefault.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
// Now make fetching the resolutions fail.
|
|
log.failFetch = fmt.Errorf("intentional fetch failure")
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
|
|
// Since logging the resolutions and closing the channel now succeeds,
|
|
// it should advance to StateContractClosed.
|
|
assertStateTransitions(
|
|
t, log.newStates, StateContractClosed,
|
|
)
|
|
|
|
// It should not advance further, however, as fetching resolutions
|
|
// failed.
|
|
time.Sleep(100 * time.Millisecond)
|
|
if log.state != StateContractClosed {
|
|
t.Fatalf("expected to stay in StateContractClosed")
|
|
}
|
|
chanArb.Stop()
|
|
|
|
// Create a new arbitrator, and now make fetching resolutions succeed.
|
|
log.failFetch = nil
|
|
chanArb, resolved, err = createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// Finally it should advance to StateFullyResolved.
|
|
assertStateTransitions(
|
|
t, log.newStates, StateFullyResolved,
|
|
)
|
|
|
|
// It should also mark the channel as resolved.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorCommitFailure tests that the channel arbitrator is able
|
|
// to recover from a failed CommitState call at restart.
|
|
func TestChannelArbitratorCommitFailure(t *testing.T) {
|
|
|
|
testCases := []struct {
|
|
|
|
// closeType is the type of channel close we want ot test.
|
|
closeType channeldb.ClosureType
|
|
|
|
// sendEvent is a function that will send the event
|
|
// corresponding to this test's closeType to the passed
|
|
// ChannelArbitrator.
|
|
sendEvent func(chanArb *ChannelArbitrator)
|
|
|
|
// expectedStates is the states we expect the state machine to
|
|
// go through after a restart and successful log commit.
|
|
expectedStates []ArbitratorState
|
|
}{
|
|
{
|
|
closeType: channeldb.CooperativeClose,
|
|
sendEvent: func(chanArb *ChannelArbitrator) {
|
|
closeInfo := &CooperativeCloseInfo{
|
|
&channeldb.ChannelCloseSummary{},
|
|
}
|
|
chanArb.cfg.ChainEvents.CooperativeClosure <- closeInfo
|
|
},
|
|
expectedStates: []ArbitratorState{StateFullyResolved},
|
|
},
|
|
{
|
|
closeType: channeldb.RemoteForceClose,
|
|
sendEvent: func(chanArb *ChannelArbitrator) {
|
|
commitSpend := &chainntnfs.SpendDetail{
|
|
SpenderTxHash: &chainhash.Hash{},
|
|
}
|
|
|
|
uniClose := &lnwallet.UnilateralCloseSummary{
|
|
SpendDetail: commitSpend,
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
}
|
|
chanArb.cfg.ChainEvents.RemoteUnilateralClosure <- uniClose
|
|
},
|
|
expectedStates: []ArbitratorState{StateContractClosed, StateFullyResolved},
|
|
},
|
|
{
|
|
closeType: channeldb.LocalForceClose,
|
|
sendEvent: func(chanArb *ChannelArbitrator) {
|
|
chanArb.cfg.ChainEvents.LocalUnilateralClosure <- &LocalUnilateralCloseInfo{
|
|
&chainntnfs.SpendDetail{},
|
|
&lnwallet.LocalForceCloseSummary{
|
|
CloseTx: &wire.MsgTx{},
|
|
HtlcResolutions: &lnwallet.HtlcResolutions{},
|
|
},
|
|
&channeldb.ChannelCloseSummary{},
|
|
}
|
|
},
|
|
expectedStates: []ArbitratorState{StateContractClosed, StateFullyResolved},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
failCommit: true,
|
|
|
|
// Set the log to fail on the first expected state
|
|
// after state machine progress for this test case.
|
|
failCommitState: test.expectedStates[0],
|
|
}
|
|
|
|
chanArb, resolved, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
// It should start in StateDefault.
|
|
assertState(t, chanArb, StateDefault)
|
|
|
|
closed := make(chan struct{})
|
|
chanArb.cfg.MarkChannelClosed = func(
|
|
*channeldb.ChannelCloseSummary) error {
|
|
close(closed)
|
|
return nil
|
|
}
|
|
|
|
// Send the test event to trigger the state machine.
|
|
test.sendEvent(chanArb)
|
|
|
|
select {
|
|
case <-closed:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("channel was not marked closed")
|
|
}
|
|
|
|
// Since the channel was marked closed in the database, but the
|
|
// commit to the next state failed, the state should still be
|
|
// StateDefault.
|
|
time.Sleep(100 * time.Millisecond)
|
|
if log.state != StateDefault {
|
|
t.Fatalf("expected to stay in StateDefault, instead "+
|
|
"has %v", log.state)
|
|
}
|
|
chanArb.Stop()
|
|
|
|
// Start the arbitrator again, with IsPendingClose reporting
|
|
// the channel closed in the database.
|
|
chanArb, resolved, err = createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
log.failCommit = false
|
|
|
|
chanArb.cfg.IsPendingClose = true
|
|
chanArb.cfg.ClosingHeight = 100
|
|
chanArb.cfg.CloseType = test.closeType
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
// Since the channel is marked closed in the database, it
|
|
// should advance to the expected states.
|
|
assertStateTransitions(
|
|
t, log.newStates, test.expectedStates...,
|
|
)
|
|
|
|
// It should also mark the channel as resolved.
|
|
select {
|
|
case <-resolved:
|
|
// Expected.
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatalf("contract was not resolved")
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChannelArbitratorEmptyResolutions makes sure that a channel that is
|
|
// pending close in the database, but haven't had any resolutions logged will
|
|
// not be marked resolved. This situation must be handled to avoid closing
|
|
// channels from earlier versions of the ChannelArbitrator, which didn't have a
|
|
// proper handoff from the ChainWatcher, and we could risk ending up in a state
|
|
// where the channel was closed in the DB, but the resolutions weren't properly
|
|
// written.
|
|
func TestChannelArbitratorEmptyResolutions(t *testing.T) {
|
|
// Start out with a log that will fail writing the set of resolutions.
|
|
log := &mockArbitratorLog{
|
|
state: StateDefault,
|
|
newStates: make(chan ArbitratorState, 5),
|
|
failFetch: errNoResolutions,
|
|
}
|
|
|
|
chanArb, _, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
chanArb.cfg.IsPendingClose = true
|
|
chanArb.cfg.ClosingHeight = 100
|
|
chanArb.cfg.CloseType = channeldb.RemoteForceClose
|
|
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
|
|
// It should not advance its state beyond StateContractClosed, since
|
|
// fetching resolutions fails.
|
|
assertStateTransitions(
|
|
t, log.newStates, StateContractClosed,
|
|
)
|
|
|
|
// It should not advance further, however, as fetching resolutions
|
|
// failed.
|
|
time.Sleep(100 * time.Millisecond)
|
|
if log.state != StateContractClosed {
|
|
t.Fatalf("expected to stay in StateContractClosed")
|
|
}
|
|
chanArb.Stop()
|
|
}
|
|
|
|
// TestChannelArbitratorAlreadyForceClosed ensures that we cannot force close a
|
|
// channel that is already in the process of doing so.
|
|
func TestChannelArbitratorAlreadyForceClosed(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// We'll create the arbitrator and its backing log to signal that it's
|
|
// already in the process of being force closed.
|
|
log := &mockArbitratorLog{
|
|
state: StateCommitmentBroadcasted,
|
|
}
|
|
chanArb, _, err := createTestChannelArbitrator(log)
|
|
if err != nil {
|
|
t.Fatalf("unable to create ChannelArbitrator: %v", err)
|
|
}
|
|
if err := chanArb.Start(); err != nil {
|
|
t.Fatalf("unable to start ChannelArbitrator: %v", err)
|
|
}
|
|
defer chanArb.Stop()
|
|
|
|
// Then, we'll create a request to signal a force close request to the
|
|
// channel arbitrator.
|
|
errChan := make(chan error, 1)
|
|
respChan := make(chan *wire.MsgTx, 1)
|
|
|
|
select {
|
|
case chanArb.forceCloseReqs <- &forceCloseReq{
|
|
closeTx: respChan,
|
|
errResp: errChan,
|
|
}:
|
|
case <-chanArb.quit:
|
|
}
|
|
|
|
// Finally, we should ensure that we are not able to do so by seeing the
|
|
// expected errAlreadyForceClosed error.
|
|
select {
|
|
case err = <-errChan:
|
|
if err != errAlreadyForceClosed {
|
|
t.Fatalf("expected errAlreadyForceClosed, got %v", err)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatal("expected to receive error response")
|
|
}
|
|
}
|