require ( 	github.com/go-stack/stack v1.8.0 	github.com/golang/protobuf v1.5.2 	github.com/google/btree v1.0.0 // indirect-	github.com/hashicorp/consul/api v1.3.0+	github.com/hashicorp/consul/api v1.8.1

 const ( 	KeyEncMode   key = iota ) +// Created based on github.com/aws/aws-lambda-go/events.APIGatewayProxyRequest for the purposes of the tests below.

 func testPaymentLifecycle(t *testing.T, test paymentLifecycleTestCase, 		t.Fatalf("SendPayment didn't exit") 	} }++// TestPaymentState tests that the logics implemented on paymentState struct+// are as expected. In particular, that the method terminated and+// needWaitForShards return the right values.+func TestPaymentState(t *testing.T) {+	t.Parallel()++	testCases := []struct {+		name string++		// Use the following three params, each is equivalent to a bool

 func TestChannelOnChainRejectionZombie(t *testing.T) { 	require.Nil(t, err) 	assertChanChainRejection(t, ctx, edge, ErrInvalidFundingOutput) }++func createDummyTestGraph(t *testing.T) *testGraphInstance {+	// Setup two simple channels such that we can mock sending along this+	// route.+	chanCapSat := btcutil.Amount(100000)+	testChannels := []*testChannel{+		symmetricTestChannel("a", "b", chanCapSat, &testChannelPolicy{+			Expiry:  144,+			FeeRate: 400,+			MinHTLC: 1,+			MaxHTLC: lnwire.NewMSatFromSatoshis(chanCapSat),+		}, 1),+		symmetricTestChannel("b", "c", chanCapSat, &testChannelPolicy{+			Expiry:  144,+			FeeRate: 400,+			MinHTLC: 1,+			MaxHTLC: lnwire.NewMSatFromSatoshis(chanCapSat),+		}, 2),+	}++	testGraph, err := createTestGraphFromChannels(testChannels, "a")+	require.NoError(t, err, "failed to create graph")+	return testGraph+}++func createDummyLightningPayment(t *testing.T,+	target route.Vertex, amt lnwire.MilliSatoshi) *LightningPayment {++	var preImage lntypes.Preimage+	_, err := rand.Read(preImage[:])+	require.NoError(t, err, "unable to generate preimage")++	payHash := preImage.Hash()++	return &LightningPayment{+		Target:      target,+		Amount:      amt,+		FeeLimit:    noFeeLimit,+		paymentHash: &payHash,+	}+}++// TestSendMPPaymentSucceed tests that we can successfully send a MPPayment via+// router.SendPayment. This test mainly focuses on testing the logic of the+// method resumePayment is implemented as expected.+func TestSendMPPaymentSucceed(t *testing.T) {+	const startingBlockHeight = 101++	// Create mockers to initialize the router.+	controlTower := &mockControlTower{}+	sessionSource := &mockPaymentSessionSource{}+	missionControl := &mockMissionControl{}+	payer := &mockPaymentAttemptDispatcher{}+	chain := newMockChain(startingBlockHeight)+	chainView := newMockChainView(chain)+	testGraph := createDummyTestGraph(t)++	// Define the behavior of the mockers to the point where we can+	// successfully start the router.+	controlTower.On("FetchInFlightPayments").Return(+		[]*channeldb.MPPayment{}, nil,+	)+	payer.On("CleanStore", mock.Anything).Return(nil)++	// Create and start the router.+	router, err := New(Config{+		Control:        controlTower,+		SessionSource:  sessionSource,+		MissionControl: missionControl,+		Payer:          payer,++		// TODO(yy): create new mocks for the chain and chainview.+		Chain:     chain,+		ChainView: chainView,++		// TODO(yy): mock the graph once it's changed into interface.+		Graph: testGraph.graph,++		Clock:              clock.NewTestClock(time.Unix(1, 0)),+		GraphPruneInterval: time.Hour * 2,+		NextPaymentID: func() (uint64, error) {+			next := atomic.AddUint64(&uniquePaymentID, 1)+			return next, nil+		},+	})+	require.NoError(t, err, "failed to create router")++	// Make sure the router can start and stop without error.+	require.NoError(t, router.Start(), "router failed to start")+	defer func() {+		require.NoError(t, router.Stop(), "router failed to stop")+	}()++	// Once the router is started, check that the mocked methods are called+	// as expected.+	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)++	// Mock the methods to the point where we are inside the function+	// resumePayment.+	paymentAmt := lnwire.MilliSatoshi(10000)+	req := createDummyLightningPayment(+		t, testGraph.aliasMap["c"], paymentAmt,+	)+	identifier := lntypes.Hash(req.Identifier())+	session := &mockPaymentSession{}+	sessionSource.On("NewPaymentSession", req).Return(session, nil)+	controlTower.On("InitPayment", identifier, mock.Anything).Return(nil)++	// The following mocked methods are called inside resumePayment. Note+	// that the payment object below will determine the state of the+	// paymentLifecycle.+	payment := &channeldb.MPPayment{}+	controlTower.On("FetchPayment", identifier).Return(payment, nil)++	// Create a route that can send 1/4 of the total amount. This value+	// will be returned by calling RequestRoute.+	shard, err := createTestRoute(paymentAmt/4, testGraph.aliasMap)+	require.NoError(t, err, "failed to create route")+	session.On("RequestRoute",+		mock.Anything, mock.Anything, mock.Anything, mock.Anything,+	).Return(shard, nil)++	// Make a new htlc attempt with zero fee and append it to the payment's+	// HTLCs when calling RegisterAttempt.+	activeAttempt := makeActiveAttempt(int(paymentAmt/4), 0)+	controlTower.On("RegisterAttempt",+		identifier, mock.Anything,+	).Return(nil).Run(func(args mock.Arguments) {+		payment.HTLCs = append(payment.HTLCs, activeAttempt)+	})++	// Create a buffered chan and it will be returned by GetPaymentResult.+	payer.resultChan = make(chan *htlcswitch.PaymentResult, 10)+	payer.On("GetPaymentResult",+		mock.Anything, identifier, mock.Anything,+	).Run(func(args mock.Arguments) {+		// Before the mock method is returned, we send the result to+		// the read-only chan.+		payer.resultChan <- &htlcswitch.PaymentResult{}+	})++	// Simple mocking the rest.+	payer.On("SendHTLC",+		mock.Anything, mock.Anything, mock.Anything,+	).Return(nil)+	missionControl.On("ReportPaymentSuccess",+		mock.Anything, mock.Anything,+	).Return(nil)++	// Mock SettleAttempt by changing one of the HTLCs to be settled.+	preimage := lntypes.Preimage{1, 2, 3}+	settledAttempt := makeSettledAttempt(+		int(paymentAmt/4), 0, preimage,+	)+	controlTower.On("SettleAttempt",+		identifier, mock.Anything, mock.Anything,+	).Return(&settledAttempt, nil).Run(func(args mock.Arguments) {+		// Whenever this method is invoked, we will mark the first+		// active attempt settled and exit.+		for i, attempt := range payment.HTLCs {+			if attempt.Settle == nil {+				attempt.Settle = &channeldb.HTLCSettleInfo{+					Preimage: preimage,+				}+				payment.HTLCs[i] = attempt+				return+			}+		}+	})++	// Call the actual method SendPayment on router. This is place inside a+	// goroutine so we can set a timeout for the whole test, in case+	// anything goes wrong and the test never finishes.+	done := make(chan struct{})+	var p lntypes.Hash+	go func() {+		p, _, err = router.SendPayment(req)+		close(done)+	}()++	select {+	case <-done:+	case <-time.After(testTimeout):+		t.Fatalf("SendPayment didn't exit")+	}++	// Finally, validate the returned values and check that the mock+	// methods are called as expected.+	require.NoError(t, err, "send payment failed")+	require.EqualValues(t, preimage, p, "preimage not match")++	// Note that we also implicitly check the methods such as FailAttempt,+	// ReportPaymentFail, etc, are not called because we never mocked them+	// in this test. If any of the unexpected methods was called, the test+	// would fail.+	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)+	sessionSource.AssertExpectations(t)+	session.AssertExpectations(t)+	missionControl.AssertExpectations(t)+}++// TestSendMPPaymentSucceedOnExtraShards tests that we need extra attempts if+// there are failed ones,so that a payment is successfully sent. This test+// mainly focuses on testing the logic of the method resumePayment is+// implemented as expected.+func TestSendMPPaymentSucceedOnExtraShards(t *testing.T) {+	const startingBlockHeight = 101++	// Create mockers to initialize the router.+	controlTower := &mockControlTower{}+	sessionSource := &mockPaymentSessionSource{}+	missionControl := &mockMissionControl{}+	payer := &mockPaymentAttemptDispatcher{}+	chain := newMockChain(startingBlockHeight)+	chainView := newMockChainView(chain)+	testGraph := createDummyTestGraph(t)++	// Define the behavior of the mockers to the point where we can+	// successfully start the router.+	controlTower.On("FetchInFlightPayments").Return(+		[]*channeldb.MPPayment{}, nil,+	)+	payer.On("CleanStore", mock.Anything).Return(nil)++	// Create and start the router.+	router, err := New(Config{+		Control:        controlTower,+		SessionSource:  sessionSource,+		MissionControl: missionControl,+		Payer:          payer,++		// TODO(yy): create new mocks for the chain and chainview.+		Chain:     chain,+		ChainView: chainView,++		// TODO(yy): mock the graph once it's changed into interface.+		Graph: testGraph.graph,++		Clock:              clock.NewTestClock(time.Unix(1, 0)),+		GraphPruneInterval: time.Hour * 2,+		NextPaymentID: func() (uint64, error) {+			next := atomic.AddUint64(&uniquePaymentID, 1)+			return next, nil+		},+	})+	require.NoError(t, err, "failed to create router")++	// Make sure the router can start and stop without error.+	require.NoError(t, router.Start(), "router failed to start")+	defer func() {+		require.NoError(t, router.Stop(), "router failed to stop")+	}()++	// Once the router is started, check that the mocked methods are called+	// as expected.+	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)++	// Mock the methods to the point where we are inside the function+	// resumePayment.+	paymentAmt := lnwire.MilliSatoshi(20000)+	req := createDummyLightningPayment(+		t, testGraph.aliasMap["c"], paymentAmt,+	)+	identifier := lntypes.Hash(req.Identifier())+	session := &mockPaymentSession{}+	sessionSource.On("NewPaymentSession", req).Return(session, nil)+	controlTower.On("InitPayment", identifier, mock.Anything).Return(nil)++	// The following mocked methods are called inside resumePayment. Note+	// that the payment object below will determine the state of the+	// paymentLifecycle.+	payment := &channeldb.MPPayment{}+	controlTower.On("FetchPayment", identifier).Return(payment, nil)++	// Create a route that can send 1/4 of the total amount. This value+	// will be returned by calling RequestRoute.+	shard, err := createTestRoute(paymentAmt/4, testGraph.aliasMap)+	require.NoError(t, err, "failed to create route")+	session.On("RequestRoute",+		mock.Anything, mock.Anything, mock.Anything, mock.Anything,+	).Return(shard, nil)++	// Make a new htlc attempt with zero fee and append it to the payment's+	// HTLCs when calling RegisterAttempt.+	activeAttempt := makeActiveAttempt(int(paymentAmt/4), 0)+	controlTower.On("RegisterAttempt",+		identifier, mock.Anything,+	).Return(nil).Run(func(args mock.Arguments) {+		payment.HTLCs = append(payment.HTLCs, activeAttempt)+	})++	// Create a buffered chan and it will be returned by GetPaymentResult.+	payer.resultChan = make(chan *htlcswitch.PaymentResult, 10)++	// We use the failAttemptCount to track how many attempts we want to+	// fail. Each time the following mock method is called, the count gets+	// updated.+	failAttemptCount := 0+	payer.On("GetPaymentResult",+		mock.Anything, identifier, mock.Anything,+	).Run(func(args mock.Arguments) {+		// Before the mock method is returned, we send the result to+		// the read-only chan.++		// Update the counter.+		failAttemptCount++++		// We will make the first two attempts failed with temporary+		// error.+		if failAttemptCount <= 2 {+			payer.resultChan <- &htlcswitch.PaymentResult{+				Error: htlcswitch.NewForwardingError(+					&lnwire.FailTemporaryChannelFailure{},+					1,+				),+			}+			return+		}++		// Otherwise we will mark the attempt succeeded.+		payer.resultChan <- &htlcswitch.PaymentResult{}+	})++	// Mock the FailAttempt method to fail one of the attempts.+	var failedAttempt channeldb.HTLCAttempt+	controlTower.On("FailAttempt",+		identifier, mock.Anything, mock.Anything,+	).Return(&failedAttempt, nil).Run(func(args mock.Arguments) {+		// Whenever this method is invoked, we will mark the first+		// active attempt as failed and exit.+		for i, attempt := range payment.HTLCs {+			if attempt.Settle != nil || attempt.Failure != nil {+				continue+			}++			attempt.Failure = &channeldb.HTLCFailInfo{}+			failedAttempt = attempt+			payment.HTLCs[i] = attempt+			return+		}++	})++	// Setup ReportPaymentFail to return nil reason and error so the+	// payment won't fail.+	missionControl.On("ReportPaymentFail",+		mock.Anything, mock.Anything, mock.Anything, mock.Anything,+	).Return(nil, nil)++	// Simple mocking the rest.+	payer.On("SendHTLC",+		mock.Anything, mock.Anything, mock.Anything,+	).Return(nil)+	missionControl.On("ReportPaymentSuccess",+		mock.Anything, mock.Anything,+	).Return(nil)++	// Mock SettleAttempt by changing one of the HTLCs to be settled.+	preimage := lntypes.Preimage{1, 2, 3}+	settledAttempt := makeSettledAttempt(+		int(paymentAmt/4), 0, preimage,+	)+	controlTower.On("SettleAttempt",+		identifier, mock.Anything, mock.Anything,+	).Return(&settledAttempt, nil).Run(func(args mock.Arguments) {+		// Whenever this method is invoked, we will mark the first+		// active attempt settled and exit.+		for i, attempt := range payment.HTLCs {+			if attempt.Settle != nil || attempt.Failure != nil {+				continue+			}++			attempt.Settle = &channeldb.HTLCSettleInfo{+				Preimage: preimage,+			}+			payment.HTLCs[i] = attempt+			return+		}+	})++	// Call the actual method SendPayment on router. This is place inside a+	// goroutine so we can set a timeout for the whole test, in case+	// anything goes wrong and the test never finishes.+	done := make(chan struct{})+	var p lntypes.Hash+	go func() {+		p, _, err = router.SendPayment(req)+		close(done)+	}()++	select {+	case <-done:+	case <-time.After(testTimeout):+		t.Fatalf("SendPayment didn't exit")+	}++	// Finally, validate the returned values and check that the mock+	// methods are called as expected.+	require.NoError(t, err, "send payment failed")+	require.EqualValues(t, preimage, p, "preimage not match")++	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)+	sessionSource.AssertExpectations(t)+	session.AssertExpectations(t)+	missionControl.AssertExpectations(t)+}++// TestSendMPPaymentFailed tests that when one of the shard fails with a+// terminal error, the router will stop attempting and the payment will fail.+// This test mainly focuses on testing the logic of the method resumePayment+// is implemented as expected.+func TestSendMPPaymentFailed(t *testing.T) {+	const startingBlockHeight = 101++	// Create mockers to initialize the router.+	controlTower := &mockControlTower{}+	sessionSource := &mockPaymentSessionSource{}+	missionControl := &mockMissionControl{}+	payer := &mockPaymentAttemptDispatcher{}+	chain := newMockChain(startingBlockHeight)+	chainView := newMockChainView(chain)+	testGraph := createDummyTestGraph(t)++	// Define the behavior of the mockers to the point where we can+	// successfully start the router.+	controlTower.On("FetchInFlightPayments").Return(+		[]*channeldb.MPPayment{}, nil,+	)+	payer.On("CleanStore", mock.Anything).Return(nil)++	// Create and start the router.+	router, err := New(Config{+		Control:        controlTower,+		SessionSource:  sessionSource,+		MissionControl: missionControl,+		Payer:          payer,++		// TODO(yy): create new mocks for the chain and chainview.+		Chain:     chain,+		ChainView: chainView,++		// TODO(yy): mock the graph once it's changed into interface.+		Graph: testGraph.graph,++		Clock:              clock.NewTestClock(time.Unix(1, 0)),+		GraphPruneInterval: time.Hour * 2,+		NextPaymentID: func() (uint64, error) {+			next := atomic.AddUint64(&uniquePaymentID, 1)+			return next, nil+		},+	})+	require.NoError(t, err, "failed to create router")++	// Make sure the router can start and stop without error.+	require.NoError(t, router.Start(), "router failed to start")+	defer func() {+		require.NoError(t, router.Stop(), "router failed to stop")+	}()++	// Once the router is started, check that the mocked methods are called+	// as expected.+	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)++	// Mock the methods to the point where we are inside the function+	// resumePayment.+	paymentAmt := lnwire.MilliSatoshi(10000)+	req := createDummyLightningPayment(+		t, testGraph.aliasMap["c"], paymentAmt,+	)+	identifier := lntypes.Hash(req.Identifier())+	session := &mockPaymentSession{}+	sessionSource.On("NewPaymentSession", req).Return(session, nil)+	controlTower.On("InitPayment", identifier, mock.Anything).Return(nil)++	// The following mocked methods are called inside resumePayment. Note+	// that the payment object below will determine the state of the+	// paymentLifecycle.+	payment := &channeldb.MPPayment{}+	controlTower.On("FetchPayment", identifier).Return(payment, nil)++	// Create a route that can send 1/4 of the total amount. This value+	// will be returned by calling RequestRoute.+	shard, err := createTestRoute(paymentAmt/4, testGraph.aliasMap)+	require.NoError(t, err, "failed to create route")+	session.On("RequestRoute",+		mock.Anything, mock.Anything, mock.Anything, mock.Anything,+	).Return(shard, nil)++	// Make a new htlc attempt with zero fee and append it to the payment's+	// HTLCs when calling RegisterAttempt.+	activeAttempt := makeActiveAttempt(int(paymentAmt/4), 0)+	controlTower.On("RegisterAttempt",+		identifier, mock.Anything,+	).Return(nil).Run(func(args mock.Arguments) {+		payment.HTLCs = append(payment.HTLCs, activeAttempt)+	})++	// Create a buffered chan and it will be returned by GetPaymentResult.+	payer.resultChan = make(chan *htlcswitch.PaymentResult, 10)++	// We use the failAttemptCount to track how many attempts we want to+	// fail. Each time the following mock method is called, the count gets+	// updated.+	failAttemptCount := 0+	payer.On("GetPaymentResult",+		mock.Anything, identifier, mock.Anything,+	).Run(func(args mock.Arguments) {+		// Before the mock method is returned, we send the result to+		// the read-only chan.++		// Update the counter.+		failAttemptCount++++		// We fail the first attempt with terminal error.+		if failAttemptCount == 1 {+			payer.resultChan <- &htlcswitch.PaymentResult{+				Error: htlcswitch.NewForwardingError(+					&lnwire.FailIncorrectDetails{},+					1,+				),+			}+			return++		}++		// We will make the rest attempts failed with temporary error.+		payer.resultChan <- &htlcswitch.PaymentResult{+			Error: htlcswitch.NewForwardingError(+				&lnwire.FailTemporaryChannelFailure{},+				1,+			),+		}+	})++	// Mock the FailAttempt method to fail one of the attempts.+	var failedAttempt channeldb.HTLCAttempt+	controlTower.On("FailAttempt",+		identifier, mock.Anything, mock.Anything,+	).Return(&failedAttempt, nil).Run(func(args mock.Arguments) {+		// Whenever this method is invoked, we will mark the first+		// active attempt as failed and exit.+		for i, attempt := range payment.HTLCs {+			if attempt.Settle != nil || attempt.Failure != nil {+				continue+			}++			attempt.Failure = &channeldb.HTLCFailInfo{}+			failedAttempt = attempt+			payment.HTLCs[i] = attempt+			return+		}++	})++	// Setup ReportPaymentFail to return nil reason and error so the+	// payment won't fail.+	var called bool+	failureReason := channeldb.FailureReasonPaymentDetails+	missionControl.On("ReportPaymentFail",+		mock.Anything, mock.Anything, mock.Anything, mock.Anything,+	).Return(nil, nil).Run(func(args mock.Arguments) {+		// We only return the terminal error once, thus when the method+		// is called, we will return it with a nil error.+		if called {+			missionControl.failReason = nil+			return+		}++		// If it's the first time calling this method, we will return a+		// terminal error.+		missionControl.failReason = &failureReason+		payment.FailureReason = &failureReason+		called = true+	})++	// Simple mocking the rest.+	controlTower.On("Fail", identifier, failureReason).Return(nil)+	payer.On("SendHTLC",+		mock.Anything, mock.Anything, mock.Anything,+	).Return(nil)++	// Call the actual method SendPayment on router. This is place inside a+	// goroutine so we can set a timeout for the whole test, in case+	// anything goes wrong and the test never finishes.+	done := make(chan struct{})+	var p lntypes.Hash+	go func() {+		p, _, err = router.SendPayment(req)+		close(done)+	}()++	select {+	case <-done:+	case <-time.After(testTimeout):+		t.Fatalf("SendPayment didn't exit")+	}++	// Finally, validate the returned values and check that the mock+	// methods are called as expected.+	require.Error(t, err, "expected send payment error")+	require.EqualValues(t, [32]byte{}, p, "preimage not match")++	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)+	sessionSource.AssertExpectations(t)+	session.AssertExpectations(t)+	missionControl.AssertExpectations(t)+}++// TestSendMPPaymentFailedWithShardsInFlight tests that when the payment is in+// terminal state, even if we have shards in flight, we still fail the payment+// and exit. This test mainly focuses on testing the logic of the method+// resumePayment is implemented as expected.+func TestSendMPPaymentFailedWithShardsInFlight(t *testing.T) {+	const startingBlockHeight = 101++	// Create mockers to initialize the router.+	controlTower := &mockControlTower{}+	sessionSource := &mockPaymentSessionSource{}+	missionControl := &mockMissionControl{}+	payer := &mockPaymentAttemptDispatcher{}+	chain := newMockChain(startingBlockHeight)+	chainView := newMockChainView(chain)+	testGraph := createDummyTestGraph(t)++	// Define the behavior of the mockers to the point where we can+	// successfully start the router.+	controlTower.On("FetchInFlightPayments").Return(+		[]*channeldb.MPPayment{}, nil,+	)+	payer.On("CleanStore", mock.Anything).Return(nil)++	// Create and start the router.+	router, err := New(Config{+		Control:        controlTower,+		SessionSource:  sessionSource,+		MissionControl: missionControl,+		Payer:          payer,++		// TODO(yy): create new mocks for the chain and chainview.+		Chain:     chain,+		ChainView: chainView,++		// TODO(yy): mock the graph once it's changed into interface.+		Graph: testGraph.graph,++		Clock:              clock.NewTestClock(time.Unix(1, 0)),+		GraphPruneInterval: time.Hour * 2,+		NextPaymentID: func() (uint64, error) {+			next := atomic.AddUint64(&uniquePaymentID, 1)+			return next, nil+		},+	})+	require.NoError(t, err, "failed to create router")++	// Make sure the router can start and stop without error.+	require.NoError(t, router.Start(), "router failed to start")+	defer func() {+		require.NoError(t, router.Stop(), "router failed to stop")+	}()++	// Once the router is started, check that the mocked methods are called+	// as expected.+	controlTower.AssertExpectations(t)+	payer.AssertExpectations(t)++	// Mock the methods to the point where we are inside the function+	// resumePayment.+	paymentAmt := lnwire.MilliSatoshi(10000)+	req := createDummyLightningPayment(+		t, testGraph.aliasMap["c"], paymentAmt,+	)+	identifier := lntypes.Hash(req.Identifier())+	session := &mockPaymentSession{}+	sessionSource.On("NewPaymentSession", req).Return(session, nil)+	controlTower.On("InitPayment", identifier, mock.Anything).Return(nil)++	// The following mocked methods are called inside resumePayment. Note+	// that the payment object below will determine the state of the+	// paymentLifecycle.+	payment := &channeldb.MPPayment{}+	controlTower.On("FetchPayment", identifier).Return(payment, nil)++	// Create a route that can send 1/4 of the total amount. This value+	// will be returned by calling RequestRoute.+	shard, err := createTestRoute(paymentAmt/4, testGraph.aliasMap)+	require.NoError(t, err, "failed to create route")+	session.On("RequestRoute",+		mock.Anything, mock.Anything, mock.Anything, mock.Anything,+	).Return(shard, nil)++	// Make a new htlc attempt with zero fee and append it to the payment's+	// HTLCs when calling RegisterAttempt.+	activeAttempt := makeActiveAttempt(int(paymentAmt/4), 0)+	controlTower.On("RegisterAttempt",+		identifier, mock.Anything,+	).Return(nil).Run(func(args mock.Arguments) {+		payment.HTLCs = append(payment.HTLCs, activeAttempt)+	})++	// Create a buffered chan and it will be returned by GetPaymentResult.+	payer.resultChan = make(chan *htlcswitch.PaymentResult, 10)++	// We use the failAttemptCount to track how many attempts we want to+	// fail. Each time the following mock method is called, the count gets+	// updated.+	failAttemptCount := 0+	payer.On("GetPaymentResult",+		mock.Anything, identifier, mock.Anything,+	).Run(func(args mock.Arguments) {+		// Before the mock method is returned, we send the result to+		// the read-only chan.++		// Update the counter.+		failAttemptCount++++		// We fail the first attempt with terminal error.+		if failAttemptCount == 1 {+			payer.resultChan <- &htlcswitch.PaymentResult{+				Error: htlcswitch.NewForwardingError(+					&lnwire.FailIncorrectDetails{},+					1,+				),+			}+			return++		}++		// For the rest attempts we will NOT send anything to the+		// resultChan, thus making all the shards in active state,+		// neither settled or failed.+	})++	// Mock the FailAttempt method to fail EXACTLY once.+	var failedAttempt channeldb.HTLCAttempt+	controlTower.On("FailAttempt",+		identifier, mock.Anything, mock.Anything,+	).Return(&failedAttempt, nil).Run(func(args mock.Arguments) {

 type paymentState struct { 	numShardsInFlight int 	remainingAmt      lnwire.MilliSatoshi 	remainingFees     lnwire.MilliSatoshi-	terminate         bool++	// terminate indicates the payment is in its final stage and no more+	// shards should be launched. This value is true if we have an HTLC+	// settled or the payment has an error.+	terminate bool+}++// terminated returns a bool to indicate there are no further actions needed+// and we should return what we have, either the payment preimage or the+// payment error.+func (ps paymentState) terminated() bool {+	// If the payment is in final stage and we have no in flight shards to+	// wait result for, we consider the whole action terminated.+	return ps.terminate && ps.numShardsInFlight == 0+}++// needWaitForShards returns a bool to specify whether we need to wait for the+// outcome of the shanrdHandler.+func (ps paymentState) needWaitForShards() bool {+	// If we have in flight shards and the payment is in final stage, we+	// need to wait for the outcomes from the shards. Or if we have no more+	// money to be sent, we need to wait for the already launched shards.+	if ps.numShardsInFlight == 0 {

 type paymentState struct { 	numShardsInFlight int 	remainingAmt      lnwire.MilliSatoshi 	remainingFees     lnwire.MilliSatoshi-	terminate         bool++	// terminate indicates the payment is in its final stage and no more+	// shards should be launched. This value is true if we have an HTLC+	// settled or the payment has an error.+	terminate bool+}++// terminated returns a bool to indicate there are no further actions needed+// and we should return what we have, either the payment preimage or the+// payment error.+func (ps paymentState) terminated() bool {+	// If the payment is in final stage and we have no in flight shards to+	// wait result for, we consider the whole action terminated.+	return ps.terminate && ps.numShardsInFlight == 0+}++// needWaitForShards returns a bool to specify whether we need to wait for the+// outcome of the shanrdHandler.+func (ps paymentState) needWaitForShards() bool {+	// If we have in flight shards and the payment is in final stage, we+	// need to wait for the outcomes from the shards. Or if we have no more+	// money to be sent, we need to wait for the already launched shards.+	if ps.numShardsInFlight == 0 {+		return false+	}+	return ps.terminate || ps.remainingAmt == 0 } -// paymentState uses the passed payment to find the latest information we need-// to act on every iteration of the payment loop.-func (p *paymentLifecycle) paymentState(payment *channeldb.MPPayment) (+// updatePaymentState will fetch db for the payment to find the latest+// information we need to act on every iteration of the payment loop and update+// the paymentState.+func (p *paymentLifecycle) updatePaymentState() (*channeldb.MPPayment,

 lifecycle:  		// If this route will consume the last remeining amount to send 		// to the receiver, this will be our last shard (for now).-		lastShard := rt.ReceiverAmt() == state.remainingAmt+		lastShard := rt.ReceiverAmt() == currentState.remainingAmt  		// We found a route to try, launch a new shard. 		attempt, outcome, err := shardHandler.launchShard(rt, lastShard)-		switch {-		// We may get a terminal error if we've processed a shard with-		// a terminal state (settled or permanent failure), while we-		// were pathfinding. We know we're in a terminal state here,-		// so we can continue and wait for our last shards to return.-		case err == channeldb.ErrPaymentTerminal:

 func (p *shardHandler) collectResultAsync(attempt *channeldb.HTLCAttemptInfo) { 					attempt.AttemptID, p.identifier, err) 			} -			select {-			case p.shardErrors <- err:-			case <-p.router.quit:-			case <-p.quit:-			}+			// Overwrite errToSend and return.

 func (m *mockControlTowerOld) SubscribePayment(paymentHash lntypes.Hash) (  	return nil, errors.New("not implemented") }++type mockPaymentAttemptDispatcher struct {

 func (p *shardHandler) collectResultAsync(attempt *channeldb.HTLCAttemptInfo) { 					attempt.AttemptID, p.identifier, err) 			} -			select {-			case p.shardErrors <- err:

 func (r *rpcServer) extractPaymentIntent(rpcPayReq *rpcPaymentRequest) (rpcPayme 		return payIntent, errors.New("invalid payment address length") 	} -	if payIntent.paymentAddr == nil {+	// Set the payment address if it was explicitly defined with the+	// rpcPaymentRequest.+	// Note that the payment address for the payIntent should be nil if none+	// was provided with the rpcPaymentRequest.+	if len(rpcPayReq.PaymentAddr) != 0 { 		payIntent.paymentAddr = &[32]byte{}+		copy(payIntent.paymentAddr[:], rpcPayReq.PaymentAddr) 	}-	copy(payIntent.paymentAddr[:], rpcPayReq.PaymentAddr)

 namespace BCLog {     } } -void BCLog::Logger::LogPrintStr(const std::string& str, const std::string& logging_function, const std::string& source_file, const int source_line)+static constexpr uint64_t HOURLY_LOG_QUOTA_IN_BYTES_PER_SOURCE_LOCATION{1024 * 1024};++bool BCLog::Logger::RateLimit(std::string& str, const std::string& logging_function, const SourceLocation& source_location)+{+    if (!m_rate_limiting) {+        // Rate limiting is disabled.+        return false;+    }++    const std::chrono::seconds now = GetTime<std::chrono::seconds>();+    QuotaUsage& quota_usage = m_quota_usage_per_source_location[source_location];+    // Is the quota exceeded before this log call?+    bool quota_exceeded_before = quota_usage.m_bytes_logged > HOURLY_LOG_QUOTA_IN_BYTES_PER_SOURCE_LOCATION;++    bool dont_skip = false;

 type ChannelLink interface { 	// will use this function in forwarding decisions accordingly. 	EligibleToForward() bool +	// MayAddOutgoingHtlc returns an error if we may not add an outgoing

 void BCLog::Logger::LogPrintStr(const std::string& str, const std::string& loggi     for (const auto& cb : m_print_callbacks) {         cb(str_prefixed);     }-    if (m_print_to_file) {+    if (m_print_to_file && !skip_writing_to_disk_due_to_rate_limiting) {