func (h *mockLightningClient) OpenChannel(_ context.Context, _ route.Vertex,
	_, _ btcutil.Amount, _ bool) (*wire.OutPoint, error) {
	return nil, nil
}
OpenChannel opens a channel to the peer provided with the amounts
specified.
package test
import (
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"sync"
	"time"
	"github.com/btcsuite/btcd/btcec"
	"github.com/btcsuite/btcd/wire"
	"github.com/btcsuite/btcutil"
	"github.com/lightninglabs/lndclient"
	"github.com/lightningnetwork/lnd/channeldb"
	"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
	"github.com/lightningnetwork/lnd/lntypes"
	"github.com/lightningnetwork/lnd/routing/route"
	"github.com/lightningnetwork/lnd/zpay32"
	"golang.org/x/net/context"
)
type mockLightningClient struct {
	lndclient.LightningClient
	lnd *LndMockServices
	wg  sync.WaitGroup
}
func (h *mockLightningClient) PayInvoice(ctx context.Context, invoice string,
	maxFee btcutil.Amount,
	outgoingChannel *uint64) chan lndclient.PaymentResult {
	done := make(chan lndclient.PaymentResult, 1)
	h.lnd.SendPaymentChannel <- PaymentChannelMessage{
		PaymentRequest: invoice,
		Done:           done,
	}
	return done
}
func (h *mockLightningClient) WaitForFinished() {
	h.wg.Wait()
}
func (h *mockLightningClient) ConfirmedWalletBalance(ctx context.Context) (
	btcutil.Amount, error) {
	return 1000000, nil
}
func (h *mockLightningClient) GetInfo(ctx context.Context) (*lndclient.Info,
	error) {
	pubKeyBytes, err := hex.DecodeString(h.lnd.NodePubkey)
	if err != nil {
		return nil, err
	}
	var pubKey [33]byte
	copy(pubKey[:], pubKeyBytes)
	return &lndclient.Info{
		BlockHeight:    600,
		IdentityPubkey: pubKey,
		Uris:           []string{h.lnd.NodePubkey + "@127.0.0.1:9735"},
	}, nil
}
func (h *mockLightningClient) EstimateFeeToP2WSH(ctx context.Context,
	amt btcutil.Amount, confTarget int32) (btcutil.Amount,
	error) {
	return 3000, nil
}
func (h *mockLightningClient) AddInvoice(ctx context.Context,
	in *invoicesrpc.AddInvoiceData) (lntypes.Hash, string, error) {
	h.lnd.lock.Lock()
	defer h.lnd.lock.Unlock()
	var hash lntypes.Hash
	switch {
	case in.Hash != nil:
		hash = *in.Hash
	case in.Preimage != nil:
		hash = (*in.Preimage).Hash()
	default:
		if _, err := rand.Read(hash[:]); err != nil {
			return lntypes.Hash{}, "", err
		}
	}
	creationDate := time.Now()
	payReq, err := zpay32.NewInvoice(
		h.lnd.ChainParams, hash, creationDate,
		zpay32.Description(in.Memo),
		zpay32.CLTVExpiry(in.CltvExpiry),
		zpay32.Amount(in.Value),
	)
	if err != nil {
		return lntypes.Hash{}, "", err
	}
	privKey, err := btcec.NewPrivateKey(btcec.S256())
	if err != nil {
		return lntypes.Hash{}, "", err
	}
	payReqString, err := payReq.Encode(
		zpay32.MessageSigner{
			SignCompact: func(hash []byte) ([]byte, error) {
				sig, err := btcec.SignCompact(
					btcec.S256(), privKey, hash, true,
				)
				if err != nil {
					return nil, fmt.Errorf("can't sign the hash: %v", err)
				}
				return sig, nil
			},
		},
	)
	if err != nil {
		return lntypes.Hash{}, "", err
	}
	h.lnd.Invoices[hash] = &lndclient.Invoice{
		Preimage:       nil,
		Hash:           hash,
		PaymentRequest: payReqString,
		Amount:         in.Value,
		CreationDate:   creationDate,
		State:          channeldb.ContractOpen,
		IsKeysend:      false,
	}
	return hash, payReqString, nil
}
func (h *mockLightningClient) LookupInvoice(_ context.Context,
	hash lntypes.Hash) (*lndclient.Invoice, error) {
	h.lnd.lock.Lock()
	defer h.lnd.lock.Unlock()
	inv, ok := h.lnd.Invoices[hash]
	if !ok {
		return nil, fmt.Errorf("invoice: %x not found", hash)
	}
	return inv, nil
}
func (h *mockLightningClient) ListTransactions(
	_ context.Context, _, _ int32) ([]lndclient.Transaction, error) {
	h.lnd.lock.Lock()
	txs := h.lnd.Transactions
	h.lnd.lock.Unlock()
	return txs, nil
}
func (h *mockLightningClient) ListChannels(ctx context.Context) (
	[]lndclient.ChannelInfo, error) {
	return h.lnd.Channels, nil
}
func (h *mockLightningClient) ClosedChannels(_ context.Context) ([]lndclient.ClosedChannel,
	error) {
	return h.lnd.ClosedChannels, nil
}
func (h *mockLightningClient) PendingChannels(_ context.Context) (
	*lndclient.PendingChannels, error) {
	return nil, nil
}
func (h *mockLightningClient) ForwardingHistory(_ context.Context,
	_ lndclient.ForwardingHistoryRequest) (*lndclient.ForwardingHistoryResponse,
	error) {
	return &lndclient.ForwardingHistoryResponse{
		LastIndexOffset: 0,
		Events:          h.lnd.ForwardingEvents,
	}, nil
}
func (h *mockLightningClient) ListInvoices(_ context.Context,
	_ lndclient.ListInvoicesRequest) (*lndclient.ListInvoicesResponse,
	error) {
	invoices := make([]lndclient.Invoice, 0, len(h.lnd.Invoices))
	for _, invoice := range h.lnd.Invoices {
		invoices = append(invoices, *invoice)
	}
	return &lndclient.ListInvoicesResponse{
		Invoices: invoices,
	}, nil
}
func (h *mockLightningClient) ListPayments(_ context.Context,
	_ lndclient.ListPaymentsRequest) (*lndclient.ListPaymentsResponse,
	error) {
	return &lndclient.ListPaymentsResponse{
		Payments: h.lnd.Payments,
	}, nil
}
func (h *mockLightningClient) ChannelBackup(context.Context, wire.OutPoint) ([]byte, error) {
	return nil, nil
}
func (h *mockLightningClient) ChannelBackups(ctx context.Context) ([]byte, error) {
	return nil, nil
}
func (h *mockLightningClient) DecodePaymentRequest(_ context.Context,
	_ string) (*lndclient.PaymentRequest, error) {
	return nil, nil
}