mod+lsat+test: copy test code to get rid of loop

To get rid of the loop dependency, we copy the test code that we rely on
and fix some imports.

go.mod

@@ -3,15 +3,31 @@ module github.com/lightninglabs/aperture
 go 1.13
 
 require (
+	github.com/btcsuite/btcd v0.20.1-beta.0.20200515232429-9f0179fd2c46
 	github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f
 	github.com/btcsuite/btcutil v1.0.2
+	github.com/btcsuite/btcwallet/wtxmgr v1.2.0
 	github.com/coreos/etcd v3.3.22+incompatible
+	github.com/coreos/go-semver v0.3.0 // indirect
+	github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf // indirect
+	github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f // indirect
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible // indirect
+	github.com/dustin/go-humanize v1.0.0 // indirect
+	github.com/fortytw2/leaktest v1.3.0
+	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.3.2
+	github.com/google/btree v1.0.0 // indirect
+	github.com/gorilla/websocket v1.4.2 // indirect
+	github.com/jonboulle/clockwork v0.2.0 // indirect
+	github.com/json-iterator/go v1.1.10 // indirect
 	github.com/lightninglabs/lndclient v1.0.1-0.20200708223031-76709c25d859
-	github.com/lightninglabs/loop v0.6.5-beta
 	github.com/lightningnetwork/lnd v0.10.3-beta
 	github.com/lightningnetwork/lnd/cert v1.0.2
+	github.com/modern-go/reflect2 v1.0.1 // indirect
+	github.com/soheilhy/cmux v0.1.4 // indirect
 	github.com/tmc/grpc-websocket-proxy v0.0.0-20200122045848-3419fae592fc // indirect
+	github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2 // indirect
+	go.uber.org/zap v1.15.0 // indirect
 	golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37
 	golang.org/x/net v0.0.0-20191112182307-2180aed22343
 	google.golang.org/grpc v1.25.1

go.sum

@@ -16,7 +16,6 @@ github.com/aead/siphash v1.0.1 h1:FwHfE/T45KPKYuuSAKyyvE+oPWcaQ+CUmFW0bPlM+kg=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6/go.mod h1:V8iCPQYkqmusNa815XgQio277wI47sdRh1dUOLdyC6Q=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0=
@@ -38,7 +37,6 @@ github.com/btcsuite/btcutil v1.0.2 h1:9iZ1Terx9fMIOtq1VrwdqfsATL9MC2l8ZrUY6YZ2ut
 github.com/btcsuite/btcutil v1.0.2/go.mod h1:j9HUFwoQRsZL3V4n+qG+CUnEGHOarIxfC3Le2Yhbcts=
 github.com/btcsuite/btcutil/psbt v1.0.2 h1:gCVY3KxdoEVU7Q6TjusPO+GANIwVgr9yTLqM+a6CZr8=
 github.com/btcsuite/btcutil/psbt v1.0.2/go.mod h1:LVveMu4VaNSkIRTZu2+ut0HDBRuYjqGocxDMNS1KuGQ=
-github.com/btcsuite/btcwallet v0.11.1-0.20200604005347-6390f167e5f8/go.mod h1:9+AH3V5mcTtNXTKe+fe63fDLKGOwQbZqmvOVUef+JFE=
 github.com/btcsuite/btcwallet v0.11.1-0.20200612012534-48addcd5591a h1:AZ1Mf0gd9mgJqrTTIFUc17ep9EKUbQusVAIzJ6X+x3Q=
 github.com/btcsuite/btcwallet v0.11.1-0.20200612012534-48addcd5591a/go.mod h1:9+AH3V5mcTtNXTKe+fe63fDLKGOwQbZqmvOVUef+JFE=
 github.com/btcsuite/btcwallet/wallet/txauthor v1.0.0 h1:KGHMW5sd7yDdDMkCZ/JpP0KltolFsQcB973brBnfj4c=
@@ -57,7 +55,6 @@ github.com/btcsuite/btcwallet/walletdb v1.3.3 h1:u6e7vRIKBF++cJy+hOHaMGg+88ZTwvp
 github.com/btcsuite/btcwallet/walletdb v1.3.3/go.mod h1:oJDxAEUHVtnmIIBaa22wSBPTVcs6hUp5NKWmI8xDwwU=
 github.com/btcsuite/btcwallet/wtxmgr v1.0.0 h1:aIHgViEmZmZfe0tQQqF1xyd2qBqFWxX5vZXkkbjtbeA=
 github.com/btcsuite/btcwallet/wtxmgr v1.0.0/go.mod h1:vc4gBprll6BP0UJ+AIGDaySoc7MdAmZf8kelfNb8CFY=
-github.com/btcsuite/btcwallet/wtxmgr v1.1.1-0.20200604005347-6390f167e5f8/go.mod h1:cJGqxXtqQbmXuL7RlXjIM18x0bGHy1407/85mQCLca4=
 github.com/btcsuite/btcwallet/wtxmgr v1.2.0 h1:ZUYPsSv8GjF9KK7lboB2OVHF0uYEcHxgrCfFWqPd9NA=
 github.com/btcsuite/btcwallet/wtxmgr v1.2.0/go.mod h1:h8hkcKUE3X7lMPzTUoGnNiw5g7VhGrKEW3KpR2r0VnY=
 github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd h1:R/opQEbFEy9JGkIguV40SvRY1uliPX8ifOvi6ICsFCw=
@@ -134,15 +131,14 @@ github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
-github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0 h1:Iju5GlWwrvL6UBg4zJJt3btmonfrMlCDdsejg4CZE7c=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.8.6 h1:XvND7+MPP7Jp+JpqSZ7naSl5nVZf6k0LbL1V3EKh0zc=
 github.com/grpc-ecosystem/grpc-gateway v1.8.6/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/grpc-ecosystem/grpc-gateway v1.14.3 h1:OCJlWkOUoTnl0neNGlf4fUm3TmbEtguw7vR+nGtnDjY=
-github.com/grpc-ecosystem/grpc-gateway v1.14.3/go.mod h1:6CwZWGDSPRJidgKAtJVvND6soZe6fT7iteq8wDPdhb0=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/jackpal/gateway v1.0.5 h1:qzXWUJfuMdlLMtt0a3Dgt+xkWQiA5itDEITVJtuSwMc=
@@ -153,12 +149,12 @@ github.com/jedib0t/go-pretty v4.3.0+incompatible/go.mod h1:XemHduiw8R651AF9Pt4Fw
 github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/jonboulle/clockwork v0.1.0 h1:VKV+ZcuP6l3yW9doeqz6ziZGgcynBVQO+obU0+0hcPo=
+github.com/jonboulle/clockwork v0.2.0 h1:J2SLSdy7HgElq8ekSl2Mxh6vrRNFxqbXGenYH2I02Vs=
-github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jonboulle/clockwork v0.2.0/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8=
 github.com/jrick/logrotate v1.0.0 h1:lQ1bL/n9mBNeIXoTUoYRlK4dHuNJVofX9oWqBtPnSzI=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
-github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
-github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/juju/clock v0.0.0-20190205081909-9c5c9712527c h1:3UvYABOQRhJAApj9MdCN+Ydv841ETSoy6xLzdmmr/9A=
 github.com/juju/clock v0.0.0-20190205081909-9c5c9712527c/go.mod h1:nD0vlnrUjcjJhqN5WuCWZyzfd5AHZAC9/ajvbSx69xA=
 github.com/juju/errors v0.0.0-20190806202954-0232dcc7464d h1:hJXjZMxj0SWlMoQkzeZDLi2cmeiWKa7y1B8Rg+qaoEc=
@@ -188,12 +184,8 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/lightninglabs/gozmq v0.0.0-20191113021534-d20a764486bf h1:HZKvJUHlcXI/f/O0Avg7t8sqkPo78HFzjmeYFl6DPnc=
 github.com/lightninglabs/gozmq v0.0.0-20191113021534-d20a764486bf/go.mod h1:vxmQPeIQxPf6Jf9rM8R+B4rKBqLA2AjttNxkFBL2Plk=
-github.com/lightninglabs/lndclient v0.0.0-20200618122423-5d815058a719 h1:RzyO65pK78xxSaekERq2V3g32GMBPc0MfxmM8MDMVmQ=
-github.com/lightninglabs/lndclient v0.0.0-20200618122423-5d815058a719/go.mod h1:WQU2oE0eJIp7jtBOUnL7CO5/YoWrAqyH23A6M1r31i8=
 github.com/lightninglabs/lndclient v1.0.1-0.20200708223031-76709c25d859 h1:MrKZJ35EuWPAXR1tS8KCGL+hcsGwhC2jtL0AqlXXOvY=
 github.com/lightninglabs/lndclient v1.0.1-0.20200708223031-76709c25d859/go.mod h1:nKEd6j54LxPYuIe3K/BUwQPus24sbvWTdoweoBcHas0=
-github.com/lightninglabs/loop v0.6.5-beta h1:KWAydG16aVI/D7gzFdKhwnprVCtJtbLiS4I/t3gkezA=
-github.com/lightninglabs/loop v0.6.5-beta/go.mod h1:Pgj7xTC6T3wbCCBxKyOVWBpvDv9mas4zpvW8jZiwG0U=
 github.com/lightninglabs/neutrino v0.11.0 h1:lPpYFCtsfJX2W5zI4pWycPmbbBdr7zU+BafYdLoD6k0=
 github.com/lightninglabs/neutrino v0.11.0/go.mod h1:CuhF0iuzg9Sp2HO6ZgXgayviFTn1QHdSTJlMncK80wg=
 github.com/lightninglabs/neutrino v0.11.1-0.20200316235139-bffc52e8f200 h1:j4iZ1XlUAPQmW6oSzMcJGILYsRHNs+4O3Gk+2Ms5Dww=
@@ -201,9 +193,6 @@ github.com/lightninglabs/neutrino v0.11.1-0.20200316235139-bffc52e8f200/go.mod h
 github.com/lightninglabs/protobuf-hex-display v1.3.3-0.20191212020323-b444784ce75d/go.mod h1:KDb67YMzoh4eudnzClmvs2FbiLG9vxISmLApUkCa4uI=
 github.com/lightningnetwork/lightning-onion v1.0.1 h1:qChGgS5+aPxFeR6JiUsGvanei1bn6WJpYbvosw/1604=
 github.com/lightningnetwork/lightning-onion v1.0.1/go.mod h1:rigfi6Af/KqsF7Za0hOgcyq2PNH4AN70AaMRxcJkff4=
-github.com/lightningnetwork/lightning-onion v1.0.2-0.20200501022730-3c8c8d0b89ea h1:oCj48NQ8u7Vz+MmzHqt0db6mxcFZo3Ho7M5gCJauY/k=
-github.com/lightningnetwork/lightning-onion v1.0.2-0.20200501022730-3c8c8d0b89ea/go.mod h1:rigfi6Af/KqsF7Za0hOgcyq2PNH4AN70AaMRxcJkff4=
-github.com/lightningnetwork/lnd v0.10.0-beta.rc6.0.20200615174244-103c59a4889f/go.mod h1:a2ejAHgjuwQ9YQJBzlMD8ZJHUcyWxXb8HRGe5QlJh9Y=
 github.com/lightningnetwork/lnd v0.10.3-beta h1:bS9+zMEH7DHAc8yzEml/xBMCiB0Xo5K7R84hKLvO4ao=
 github.com/lightningnetwork/lnd v0.10.3-beta/go.mod h1:4d02pduRVtZwgTJ+EimKJTsEAY0jDwi0SPE9h5aRneM=
 github.com/lightningnetwork/lnd/cert v1.0.2 h1:g2rEu+sM2Uyz0bpfuvwri/ks6R/26H5iY1NcGbpDJ+c=
@@ -277,13 +266,11 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
-github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20200122045848-3419fae592fc h1:yUaosFVTJwnltaHbSNC3i82I92quFs+OFPRl8kNMVwo=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20200122045848-3419fae592fc/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tv42/zbase32 v0.0.0-20160707012821-501572607d02 h1:tcJ6OjwOMvExLlzrAVZute09ocAGa7KqOON60++Gz4E=
 github.com/tv42/zbase32 v0.0.0-20160707012821-501572607d02/go.mod h1:tHlrkM198S068ZqfrO6S8HsoJq2bF3ETfTL+kt4tInY=
 github.com/urfave/cli v1.18.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
-github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2 h1:eY9dn8+vbi4tKz5Qo6v2eYzo7kUS51QINcR5jNpbZS8=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 go.etcd.io/bbolt v1.3.3 h1:MUGmc65QhB3pIlaQ5bB4LwqSj6GIonVJXpZiaKNyaKk=
@@ -297,8 +284,8 @@ go.uber.org/multierr v1.5.0 h1:KCa4XfM8CWFCpxXRGok+Q0SS/0XBhMDbHHGABQLvD2A=
 go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.14.1 h1:nYDKopTbvAPq/NrUVZwT15y2lpROBiLLyoRTbXOYWOo=
+go.uber.org/zap v1.15.0 h1:ZZCA22JRF2gQE5FoNmhmrf7jeJJ2uhqDUNRYKm8dvmM=
-go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
+go.uber.org/zap v1.15.0/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180723164146-c126467f60eb/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@@ -328,7 +315,6 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191112182307-2180aed22343 h1:00ohfJ4K98s3m6BGUoBd8nyfp4Yl0GoIKvw5abItTjI=
 golang.org/x/net v0.0.0-20191112182307-2180aed22343/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -347,7 +333,6 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd h1:DBH9mDw0zluJT/R+nGuV3jWFWLFaHyYZWD4tOT+cjn0=
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5 h1:LfCXLvNmTYH9kEmVgqbnsWfruoXZIrh4YBgqVHtDvw0=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -371,8 +356,6 @@ google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoA
 google.golang.org/genproto v0.0.0-20190201180003-4b09977fb922/go.mod h1:L3J43x8/uS+qIUoksaLKe6OS3nUKxOKuIFz1sl2/jx4=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2ElGhA4+qG2zF97qiUzTM+rQ0klBOcE=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c h1:hrpEMCZ2O7DR5gC1n2AJGVhrwiEjOi35+jxtIuZpTMo=
-google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
 google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
 google.golang.org/grpc v1.18.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
@@ -404,7 +387,6 @@ gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bl
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
@@ -412,6 +394,5 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
 sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
 sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=

internal/test/chainnotifier_mock.go

@@ -0,0 +1,160 @@
+package test
+
+import (
+	"bytes"
+	"sync"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightningnetwork/lnd/chainntnfs"
+	"golang.org/x/net/context"
+)
+
+type mockChainNotifier struct {
+	sync.Mutex
+	lnd               *LndMockServices
+	confRegistrations []*ConfRegistration
+	wg                sync.WaitGroup
+}
+
+// SpendRegistration contains registration details.
+type SpendRegistration struct {
+	Outpoint   *wire.OutPoint
+	PkScript   []byte
+	HeightHint int32
+}
+
+// ConfRegistration contains registration details.
+type ConfRegistration struct {
+	TxID       *chainhash.Hash
+	PkScript   []byte
+	HeightHint int32
+	NumConfs   int32
+	ConfChan   chan *chainntnfs.TxConfirmation
+}
+
+func (c *mockChainNotifier) RegisterSpendNtfn(ctx context.Context,
+	outpoint *wire.OutPoint, pkScript []byte, heightHint int32) (
+	chan *chainntnfs.SpendDetail, chan error, error) {
+
+	c.lnd.RegisterSpendChannel <- &SpendRegistration{
+		HeightHint: heightHint,
+		Outpoint:   outpoint,
+		PkScript:   pkScript,
+	}
+
+	spendChan := make(chan *chainntnfs.SpendDetail, 1)
+	errChan := make(chan error, 1)
+
+	c.wg.Add(1)
+	go func() {
+		defer c.wg.Done()
+
+		select {
+		case m := <-c.lnd.SpendChannel:
+			select {
+			case spendChan <- m:
+			case <-ctx.Done():
+			}
+		case <-ctx.Done():
+		}
+	}()
+
+	return spendChan, errChan, nil
+}
+
+func (c *mockChainNotifier) WaitForFinished() {
+	c.wg.Wait()
+}
+
+func (c *mockChainNotifier) RegisterBlockEpochNtfn(ctx context.Context) (
+	chan int32, chan error, error) {
+
+	blockErrorChan := make(chan error, 1)
+	blockEpochChan := make(chan int32)
+
+	c.wg.Add(1)
+	go func() {
+		defer c.wg.Done()
+
+		// Send initial block height
+		select {
+		case blockEpochChan <- c.lnd.Height:
+		case <-ctx.Done():
+			return
+		}
+
+		for {
+			select {
+			case m := <-c.lnd.epochChannel:
+				select {
+				case blockEpochChan <- m:
+				case <-ctx.Done():
+					return
+				}
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	return blockEpochChan, blockErrorChan, nil
+}
+
+func (c *mockChainNotifier) RegisterConfirmationsNtfn(ctx context.Context,
+	txid *chainhash.Hash, pkScript []byte, numConfs, heightHint int32) (
+	chan *chainntnfs.TxConfirmation, chan error, error) {
+
+	reg := &ConfRegistration{
+		PkScript:   pkScript,
+		TxID:       txid,
+		HeightHint: heightHint,
+		NumConfs:   numConfs,
+		ConfChan:   make(chan *chainntnfs.TxConfirmation, 1),
+	}
+
+	c.Lock()
+	c.confRegistrations = append(c.confRegistrations, reg)
+	c.Unlock()
+
+	errChan := make(chan error, 1)
+
+	c.wg.Add(1)
+	go func() {
+		defer c.wg.Done()
+
+		select {
+		case m := <-c.lnd.ConfChannel:
+			c.Lock()
+			for i := 0; i < len(c.confRegistrations); i++ {
+				r := c.confRegistrations[i]
+
+				// Whichever conf notifier catches the confirmation
+				// will forward it to all matching subscibers.
+				if bytes.Equal(m.Tx.TxOut[0].PkScript, r.PkScript) {
+					// Unregister the "notifier".
+					c.confRegistrations = append(
+						c.confRegistrations[:i], c.confRegistrations[i+1:]...,
+					)
+					i--
+
+					select {
+					case r.ConfChan <- m:
+					case <-ctx.Done():
+					}
+				}
+			}
+			c.Unlock()
+		case <-ctx.Done():
+		}
+	}()
+
+	select {
+	case c.lnd.RegisterConfChannel <- reg:
+	case <-time.After(Timeout):
+		return nil, nil, ErrTimeout
+	}
+
+	return reg.ConfChan, errChan, nil
+}

internal/test/context.go

@@ -0,0 +1,256 @@
+package test
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/zpay32"
+)
+
+// Context contains shared test context functions.
+type Context struct {
+	T              *testing.T
+	Lnd            *LndMockServices
+	FailedInvoices map[lntypes.Hash]struct{}
+	PaidInvoices   map[string]func(error)
+}
+
+// NewContext instanties a new common test context.
+func NewContext(t *testing.T,
+	lnd *LndMockServices) Context {
+
+	return Context{
+		T:              t,
+		Lnd:            lnd,
+		FailedInvoices: make(map[lntypes.Hash]struct{}),
+		PaidInvoices:   make(map[string]func(error)),
+	}
+}
+
+// ReceiveTx receives and decodes a published tx.
+func (ctx *Context) ReceiveTx() *wire.MsgTx {
+	ctx.T.Helper()
+
+	select {
+	case tx := <-ctx.Lnd.TxPublishChannel:
+		return tx
+	case <-time.After(Timeout):
+		ctx.T.Fatalf("sweep not published")
+		return nil
+	}
+}
+
+// NotifySpend simulates a spend.
+func (ctx *Context) NotifySpend(tx *wire.MsgTx, inputIndex uint32) {
+	ctx.T.Helper()
+
+	txHash := tx.TxHash()
+
+	select {
+	case ctx.Lnd.SpendChannel <- &chainntnfs.SpendDetail{
+		SpendingTx:        tx,
+		SpenderTxHash:     &txHash,
+		SpenderInputIndex: inputIndex,
+	}:
+	case <-time.After(Timeout):
+		ctx.T.Fatalf("htlc spend not consumed")
+
+	}
+}
+
+// NotifyConf simulates a conf.
+func (ctx *Context) NotifyConf(tx *wire.MsgTx) {
+	ctx.T.Helper()
+
+	select {
+	case ctx.Lnd.ConfChannel <- &chainntnfs.TxConfirmation{
+		Tx: tx,
+	}:
+	case <-time.After(Timeout):
+		ctx.T.Fatalf("htlc spend not consumed")
+
+	}
+}
+
+// AssertRegisterSpendNtfn asserts that a register for spend has been received.
+func (ctx *Context) AssertRegisterSpendNtfn(script []byte) {
+	ctx.T.Helper()
+
+	select {
+	case spendIntent := <-ctx.Lnd.RegisterSpendChannel:
+		if !bytes.Equal(spendIntent.PkScript, script) {
+			ctx.T.Fatalf("server not listening for published htlc script")
+		}
+	case <-time.After(Timeout):
+		DumpGoroutines()
+		ctx.T.Fatalf("spend not subscribed to")
+	}
+}
+
+// AssertTrackPayment asserts that a call was made to track payment, and
+// returns the track payment message so that it can be used to send updates
+// to the test.
+func (ctx *Context) AssertTrackPayment() TrackPaymentMessage {
+	ctx.T.Helper()
+
+	var msg TrackPaymentMessage
+	select {
+	case msg = <-ctx.Lnd.TrackPaymentChannel:
+
+	case <-time.After(Timeout):
+		DumpGoroutines()
+		ctx.T.Fatalf("payment not tracked")
+	}
+
+	return msg
+}
+
+// AssertRegisterConf asserts that a register for conf has been received.
+func (ctx *Context) AssertRegisterConf(expectTxHash bool) *ConfRegistration {
+	ctx.T.Helper()
+
+	// Expect client to register for conf
+	var confIntent *ConfRegistration
+	select {
+	case confIntent = <-ctx.Lnd.RegisterConfChannel:
+		switch {
+		case expectTxHash && confIntent.TxID == nil:
+			ctx.T.Fatalf("expected tx id for registration")
+
+		case !expectTxHash && confIntent.TxID != nil:
+			ctx.T.Fatalf("expected script only registration")
+		}
+	case <-time.After(Timeout):
+		ctx.T.Fatalf("htlc confirmed not subscribed to")
+	}
+
+	return confIntent
+}
+
+// AssertPaid asserts that the expected payment request has been paid. This
+// function returns a complete function to signal the final payment result.
+func (ctx *Context) AssertPaid(
+	expectedMemo string) func(error) {
+
+	ctx.T.Helper()
+
+	if done, ok := ctx.PaidInvoices[expectedMemo]; ok {
+		return done
+	}
+
+	// Assert that client pays swap invoice.
+	for {
+		var swapPayment RouterPaymentChannelMessage
+		select {
+		case swapPayment = <-ctx.Lnd.RouterSendPaymentChannel:
+		case <-time.After(Timeout):
+			ctx.T.Fatalf("no payment sent for invoice: %v",
+				expectedMemo)
+		}
+
+		payReq := ctx.DecodeInvoice(swapPayment.Invoice)
+
+		if _, ok := ctx.PaidInvoices[*payReq.Description]; ok {
+			ctx.T.Fatalf("duplicate invoice paid: %v",
+				*payReq.Description)
+		}
+
+		done := func(result error) {
+			if result != nil {
+				swapPayment.Errors <- result
+				return
+			}
+			swapPayment.Updates <- lndclient.PaymentStatus{
+				State: lnrpc.Payment_SUCCEEDED,
+			}
+		}
+
+		ctx.PaidInvoices[*payReq.Description] = done
+
+		if *payReq.Description == expectedMemo {
+			return done
+		}
+	}
+}
+
+// AssertSettled asserts that an invoice with the given hash is settled.
+func (ctx *Context) AssertSettled(
+	expectedHash lntypes.Hash) lntypes.Preimage {
+
+	ctx.T.Helper()
+
+	select {
+	case preimage := <-ctx.Lnd.SettleInvoiceChannel:
+		hash := sha256.Sum256(preimage[:])
+		if expectedHash != hash {
+			ctx.T.Fatalf("server claims with wrong preimage")
+		}
+
+		return preimage
+	case <-time.After(Timeout):
+	}
+	ctx.T.Fatalf("invoice not settled")
+	return lntypes.Preimage{}
+}
+
+// AssertFailed asserts that an invoice with the given hash is failed.
+func (ctx *Context) AssertFailed(expectedHash lntypes.Hash) {
+	ctx.T.Helper()
+
+	if _, ok := ctx.FailedInvoices[expectedHash]; ok {
+		return
+	}
+
+	for {
+		select {
+		case hash := <-ctx.Lnd.FailInvoiceChannel:
+			ctx.FailedInvoices[expectedHash] = struct{}{}
+			if expectedHash == hash {
+				return
+			}
+		case <-time.After(Timeout):
+			ctx.T.Fatalf("invoice not failed")
+		}
+	}
+}
+
+// DecodeInvoice decodes a payment request string.
+func (ctx *Context) DecodeInvoice(request string) *zpay32.Invoice {
+	ctx.T.Helper()
+
+	payReq, err := ctx.Lnd.DecodeInvoice(request)
+	if err != nil {
+		ctx.T.Fatal(err)
+	}
+	return payReq
+}
+
+// GetOutputIndex returns the index in the tx outs of the given script hash.
+func (ctx *Context) GetOutputIndex(tx *wire.MsgTx,
+	script []byte) int {
+
+	for idx, out := range tx.TxOut {
+		if bytes.Equal(out.PkScript, script) {
+			return idx
+		}
+	}
+
+	ctx.T.Fatal("htlc not present in tx")
+	return 0
+}
+
+// NotifyServerHeight notifies the server of the arrival of a new block and
+// waits for the notification to be processed by selecting on a
+// dedicated test channel.
+func (ctx *Context) NotifyServerHeight(height int32) {
+	if err := ctx.Lnd.NotifyHeight(height); err != nil {
+		ctx.T.Fatal(err)
+	}
+}

internal/test/invoices_mock.go

@@ -0,0 +1,110 @@
+package test
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
+	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/zpay32"
+)
+
+type mockInvoices struct {
+	lnd *LndMockServices
+	wg  sync.WaitGroup
+}
+
+func (s *mockInvoices) SettleInvoice(ctx context.Context,
+	preimage lntypes.Preimage) error {
+
+	logger.Infof("Settle invoice %v with preimage %v", preimage.Hash(),
+		preimage)
+
+	s.lnd.SettleInvoiceChannel <- preimage
+
+	return nil
+}
+
+func (s *mockInvoices) WaitForFinished() {
+	s.wg.Wait()
+}
+
+func (s *mockInvoices) CancelInvoice(ctx context.Context,
+	hash lntypes.Hash) error {
+
+	s.lnd.FailInvoiceChannel <- hash
+
+	return nil
+}
+
+func (s *mockInvoices) SubscribeSingleInvoice(ctx context.Context,
+	hash lntypes.Hash) (<-chan lndclient.InvoiceUpdate,
+	<-chan error, error) {
+
+	updateChan := make(chan lndclient.InvoiceUpdate, 2)
+	errChan := make(chan error)
+
+	select {
+	case s.lnd.SingleInvoiceSubcribeChannel <- &SingleInvoiceSubscription{
+		Update: updateChan,
+		Err:    errChan,
+		Hash:   hash,
+	}:
+	case <-ctx.Done():
+		return nil, nil, ctx.Err()
+	}
+
+	return updateChan, errChan, nil
+}
+
+func (s *mockInvoices) AddHoldInvoice(ctx context.Context,
+	in *invoicesrpc.AddInvoiceData) (string, error) {
+
+	s.lnd.lock.Lock()
+	defer s.lnd.lock.Unlock()
+
+	hash := in.Hash
+
+	// Create and encode the payment request as a bech32 (zpay32) string.
+	creationDate := time.Now()
+
+	payReq, err := zpay32.NewInvoice(
+		s.lnd.ChainParams, *hash, creationDate,
+		zpay32.Description(in.Memo),
+		zpay32.CLTVExpiry(in.CltvExpiry),
+		zpay32.Amount(in.Value),
+	)
+	if err != nil {
+		return "", err
+	}
+
+	privKey, err := btcec.NewPrivateKey(btcec.S256())
+	if err != nil {
+		return "", err
+	}
+
+	payReqString, err := payReq.Encode(
+		zpay32.MessageSigner{
+			SignCompact: func(hash []byte) ([]byte, error) {
+				// btcec.SignCompact returns a pubkey-recoverable signature
+				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 "", err
+	}
+
+	return payReqString, nil
+}

internal/test/keys.go

@@ -0,0 +1,17 @@
+package test
+
+import (
+	"github.com/btcsuite/btcd/btcec"
+)
+
+// CreateKey returns a deterministically generated key pair.
+func CreateKey(index int32) (*btcec.PrivateKey, *btcec.PublicKey) {
+	// Avoid all zeros, because it results in an invalid key.
+	privKey, pubKey := btcec.PrivKeyFromBytes(btcec.S256(),
+		[]byte{0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, byte(index + 1)})
+
+	return privKey, pubKey
+}

internal/test/lightning_client_mock.go

@@ -0,0 +1,240 @@
+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/zpay32"
+	"golang.org/x/net/context"
+)
+
+type mockLightningClient struct {
+	lnd *LndMockServices
+	wg  sync.WaitGroup
+}
+
+// PayInvoice pays an invoice.
+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
+		}
+	}
+
+	// Create and encode the payment request as a bech32 (zpay32) string.
+	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) {
+				// btcec.SignCompact returns a pubkey-recoverable signature
+				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
+	}
+
+	// Add the invoice we have created to our mock's set of invoices.
+	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
+}
+
+// LookupInvoice looks up an invoice in the mock's set of stored invoices.
+// If it is not found, this call will fail. Note that these invoices should
+// be settled using settleInvoice to have a preimage, settled state and settled
+// date set.
+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
+}
+
+// ListTransactions returns all known transactions of the backing lnd node.
+func (h *mockLightningClient) ListTransactions(
+	_ context.Context) ([]lndclient.Transaction, error) {
+
+	h.lnd.lock.Lock()
+	txs := h.lnd.Transactions
+	h.lnd.lock.Unlock()
+
+	return txs, nil
+}
+
+// ListChannels retrieves all channels of the backing lnd node.
+func (h *mockLightningClient) ListChannels(ctx context.Context) (
+	[]lndclient.ChannelInfo, error) {
+
+	return h.lnd.Channels, nil
+}
+
+// ClosedChannels returns a list of our closed channels.
+func (h *mockLightningClient) ClosedChannels(_ context.Context) ([]lndclient.ClosedChannel,
+	error) {
+
+	return h.lnd.ClosedChannels, nil
+}
+
+// ForwardingHistory returns the mock's set of forwarding events.
+func (h *mockLightningClient) ForwardingHistory(_ context.Context,
+	_ lndclient.ForwardingHistoryRequest) (*lndclient.ForwardingHistoryResponse,
+	error) {
+
+	return &lndclient.ForwardingHistoryResponse{
+		LastIndexOffset: 0,
+		Events:          h.lnd.ForwardingEvents,
+	}, nil
+}
+
+// ListInvoices returns our mock's invoices.
+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
+}
+
+// ListPayments makes a paginated call to our list payments endpoint.
+func (h *mockLightningClient) ListPayments(_ context.Context,
+	_ lndclient.ListPaymentsRequest) (*lndclient.ListPaymentsResponse,
+	error) {
+
+	return &lndclient.ListPaymentsResponse{
+		Payments: h.lnd.Payments,
+	}, nil
+}
+
+// ChannelBackup retrieves the backup for a particular channel. The
+// backup is returned as an encrypted chanbackup.Single payload.
+func (h *mockLightningClient) ChannelBackup(context.Context, wire.OutPoint) ([]byte, error) {
+	return nil, nil
+}
+
+// ChannelBackups retrieves backups for all existing pending open and
+// open channels. The backups are returned as an encrypted
+// chanbackup.Multi payload.
+func (h *mockLightningClient) ChannelBackups(ctx context.Context) ([]byte, error) {
+	return nil, nil
+}
+
+// DecodePaymentRequest decodes a payment request.
+func (h *mockLightningClient) DecodePaymentRequest(_ context.Context,
+	_ string) (*lndclient.PaymentRequest, error) {
+
+	return nil, nil
+}

internal/test/lnd_services_mock.go

@@ -0,0 +1,263 @@
+package test
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
+	"github.com/lightningnetwork/lnd/zpay32"
+)
+
+var (
+	testStartingHeight = int32(600)
+	testNodePubkey     = "03f5374b16f0b1f1b49101de1b9d89e0b460bc57ce9c2f9" +
+		"132b73dfc76d3704daa"
+	testSignature    = []byte{55, 66, 77, 88, 99}
+	testSignatureMsg = "test"
+)
+
+// NewMockLnd returns a new instance of LndMockServices that can be used in unit
+// tests.
+func NewMockLnd() *LndMockServices {
+	lightningClient := &mockLightningClient{}
+	walletKit := &mockWalletKit{
+		feeEstimates: make(map[int32]chainfee.SatPerKWeight),
+	}
+	chainNotifier := &mockChainNotifier{}
+	signer := &mockSigner{}
+	invoices := &mockInvoices{}
+	router := &mockRouter{}
+	versioner := newMockVersioner()
+
+	lnd := LndMockServices{
+		LndServices: lndclient.LndServices{
+			WalletKit:     walletKit,
+			Client:        lightningClient,
+			ChainNotifier: chainNotifier,
+			Signer:        signer,
+			Invoices:      invoices,
+			Router:        router,
+			ChainParams:   &chaincfg.TestNet3Params,
+			Versioner:     versioner,
+		},
+		SendPaymentChannel:           make(chan PaymentChannelMessage),
+		ConfChannel:                  make(chan *chainntnfs.TxConfirmation),
+		RegisterConfChannel:          make(chan *ConfRegistration),
+		RegisterSpendChannel:         make(chan *SpendRegistration),
+		SpendChannel:                 make(chan *chainntnfs.SpendDetail),
+		TxPublishChannel:             make(chan *wire.MsgTx),
+		SendOutputsChannel:           make(chan wire.MsgTx),
+		SettleInvoiceChannel:         make(chan lntypes.Preimage),
+		SingleInvoiceSubcribeChannel: make(chan *SingleInvoiceSubscription),
+
+		RouterSendPaymentChannel: make(chan RouterPaymentChannelMessage),
+		TrackPaymentChannel:      make(chan TrackPaymentMessage),
+
+		SignOutputRawChannel: make(chan SignOutputRawRequest),
+
+		FailInvoiceChannel: make(chan lntypes.Hash, 2),
+		epochChannel:       make(chan int32),
+		Height:             testStartingHeight,
+		NodePubkey:         testNodePubkey,
+		Signature:          testSignature,
+		SignatureMsg:       testSignatureMsg,
+		Invoices:           make(map[lntypes.Hash]*lndclient.Invoice),
+	}
+
+	lightningClient.lnd = &lnd
+	chainNotifier.lnd = &lnd
+	walletKit.lnd = &lnd
+	invoices.lnd = &lnd
+	router.lnd = &lnd
+	signer.lnd = &lnd
+
+	// Also simulate the cached info that is loaded on startup.
+	info, _ := lightningClient.GetInfo(context.Background())
+	version, _ := versioner.GetVersion(context.Background())
+	lnd.LndServices.NodeAlias = info.Alias
+	lnd.LndServices.NodePubkey = info.IdentityPubkey
+	lnd.LndServices.Version = version
+
+	lnd.WaitForFinished = func() {
+		chainNotifier.WaitForFinished()
+		lightningClient.WaitForFinished()
+		invoices.WaitForFinished()
+	}
+
+	return &lnd
+}
+
+// PaymentChannelMessage is the data that passed through SendPaymentChannel.
+type PaymentChannelMessage struct {
+	PaymentRequest string
+	Done           chan lndclient.PaymentResult
+}
+
+// TrackPaymentMessage is the data that passed through TrackPaymentChannel.
+type TrackPaymentMessage struct {
+	Hash lntypes.Hash
+
+	Updates chan lndclient.PaymentStatus
+	Errors  chan error
+}
+
+// RouterPaymentChannelMessage is the data that passed through RouterSendPaymentChannel.
+type RouterPaymentChannelMessage struct {
+	lndclient.SendPaymentRequest
+
+	TrackPaymentMessage
+}
+
+// SingleInvoiceSubscription contains the single invoice subscribers
+type SingleInvoiceSubscription struct {
+	Hash   lntypes.Hash
+	Update chan lndclient.InvoiceUpdate
+	Err    chan error
+}
+
+// SignOutputRawRequest contains input data for a tx signing request.
+type SignOutputRawRequest struct {
+	Tx              *wire.MsgTx
+	SignDescriptors []*input.SignDescriptor
+}
+
+// LndMockServices provides a full set of mocked lnd services.
+type LndMockServices struct {
+	lndclient.LndServices
+
+	SendPaymentChannel   chan PaymentChannelMessage
+	SpendChannel         chan *chainntnfs.SpendDetail
+	TxPublishChannel     chan *wire.MsgTx
+	SendOutputsChannel   chan wire.MsgTx
+	SettleInvoiceChannel chan lntypes.Preimage
+	FailInvoiceChannel   chan lntypes.Hash
+	epochChannel         chan int32
+
+	ConfChannel          chan *chainntnfs.TxConfirmation
+	RegisterConfChannel  chan *ConfRegistration
+	RegisterSpendChannel chan *SpendRegistration
+
+	SingleInvoiceSubcribeChannel chan *SingleInvoiceSubscription
+
+	RouterSendPaymentChannel chan RouterPaymentChannelMessage
+	TrackPaymentChannel      chan TrackPaymentMessage
+
+	SignOutputRawChannel chan SignOutputRawRequest
+
+	Height       int32
+	NodePubkey   string
+	Signature    []byte
+	SignatureMsg string
+
+	Transactions []lndclient.Transaction
+	Sweeps       []string
+
+	// Invoices is a set of invoices that have been created by the mock,
+	// keyed by hash string.
+	Invoices map[lntypes.Hash]*lndclient.Invoice
+
+	Channels         []lndclient.ChannelInfo
+	ClosedChannels   []lndclient.ClosedChannel
+	ForwardingEvents []lndclient.ForwardingEvent
+	Payments         []lndclient.Payment
+
+	WaitForFinished func()
+
+	lock sync.Mutex
+}
+
+// NotifyHeight notifies a new block height.
+func (s *LndMockServices) NotifyHeight(height int32) error {
+	s.Height = height
+
+	select {
+	case s.epochChannel <- height:
+	case <-time.After(Timeout):
+		return ErrTimeout
+	}
+	return nil
+}
+
+// AddRelevantTx marks the given transaction as relevant.
+func (s *LndMockServices) AddTx(tx *wire.MsgTx) {
+	s.lock.Lock()
+	s.Transactions = append(s.Transactions, lndclient.Transaction{
+		Tx: tx.Copy(),
+	})
+	s.lock.Unlock()
+}
+
+// IsDone checks whether all channels have been fully emptied. If not this may
+// indicate unexpected behaviour of the code under test.
+func (s *LndMockServices) IsDone() error {
+	select {
+	case <-s.SendPaymentChannel:
+		return errors.New("SendPaymentChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.SpendChannel:
+		return errors.New("SpendChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.TxPublishChannel:
+		return errors.New("TxPublishChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.SendOutputsChannel:
+		return errors.New("SendOutputsChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.SettleInvoiceChannel:
+		return errors.New("SettleInvoiceChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.ConfChannel:
+		return errors.New("ConfChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.RegisterConfChannel:
+		return errors.New("RegisterConfChannel not empty")
+	default:
+	}
+
+	select {
+	case <-s.RegisterSpendChannel:
+		return errors.New("RegisterSpendChannel not empty")
+	default:
+	}
+
+	return nil
+}
+
+// DecodeInvoice decodes a payment request string.
+func (s *LndMockServices) DecodeInvoice(request string) (*zpay32.Invoice,
+	error) {
+
+	return zpay32.Decode(request, s.ChainParams)
+}
+
+func (s *LndMockServices) SetFeeEstimate(confTarget int32,
+	feeEstimate chainfee.SatPerKWeight) {
+
+	s.WalletKit.(*mockWalletKit).feeEstimates[confTarget] = feeEstimate
+}

internal/test/log.go

@@ -0,0 +1,24 @@
+package test
+
+import (
+	"os"
+
+	"github.com/btcsuite/btclog"
+)
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var (
+	backendLog = btclog.NewBackend(logWriter{})
+	logger     = backendLog.Logger("TEST")
+)
+
+// logWriter implements an io.Writer that outputs to both standard output and
+// the write-end pipe of an initialized log rotator.
+type logWriter struct{}
+
+func (logWriter) Write(p []byte) (n int, err error) {
+	os.Stdout.Write(p)
+	return len(p), nil
+}

internal/test/router_mock.go

@@ -0,0 +1,43 @@
+package test
+
+import (
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/lntypes"
+	"golang.org/x/net/context"
+)
+
+type mockRouter struct {
+	lnd *LndMockServices
+}
+
+func (r *mockRouter) SendPayment(ctx context.Context,
+	request lndclient.SendPaymentRequest) (chan lndclient.PaymentStatus,
+	chan error, error) {
+
+	statusChan := make(chan lndclient.PaymentStatus)
+	errorChan := make(chan error)
+
+	r.lnd.RouterSendPaymentChannel <- RouterPaymentChannelMessage{
+		SendPaymentRequest: request,
+		TrackPaymentMessage: TrackPaymentMessage{
+			Updates: statusChan,
+			Errors:  errorChan,
+		},
+	}
+
+	return statusChan, errorChan, nil
+}
+
+func (r *mockRouter) TrackPayment(ctx context.Context,
+	hash lntypes.Hash) (chan lndclient.PaymentStatus, chan error, error) {
+
+	statusChan := make(chan lndclient.PaymentStatus)
+	errorChan := make(chan error)
+	r.lnd.TrackPaymentChannel <- TrackPaymentMessage{
+		Hash:    hash,
+		Updates: statusChan,
+		Errors:  errorChan,
+	}
+
+	return statusChan, errorChan, nil
+}

internal/test/signer_mock.go

@@ -0,0 +1,58 @@
+package test
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/keychain"
+)
+
+type mockSigner struct {
+	lnd *LndMockServices
+}
+
+func (s *mockSigner) SignOutputRaw(ctx context.Context, tx *wire.MsgTx,
+	signDescriptors []*input.SignDescriptor) ([][]byte, error) {
+
+	s.lnd.SignOutputRawChannel <- SignOutputRawRequest{
+		Tx:              tx,
+		SignDescriptors: signDescriptors,
+	}
+
+	rawSigs := [][]byte{{1, 2, 3}}
+
+	return rawSigs, nil
+}
+
+func (s *mockSigner) ComputeInputScript(ctx context.Context, tx *wire.MsgTx,
+	signDescriptors []*input.SignDescriptor) ([]*input.Script, error) {
+
+	return nil, fmt.Errorf("unimplemented")
+}
+
+func (s *mockSigner) SignMessage(ctx context.Context, msg []byte,
+	locator keychain.KeyLocator) ([]byte, error) {
+
+	return s.lnd.Signature, nil
+}
+
+func (s *mockSigner) VerifyMessage(ctx context.Context, msg, sig []byte,
+	pubkey [33]byte) (bool, error) {
+
+	// Make the mock somewhat functional by asserting that the message and
+	// signature is what we expect from the mock parameters.
+	mockAssertion := bytes.Equal(msg, []byte(s.lnd.SignatureMsg)) &&
+		bytes.Equal(sig, s.lnd.Signature)
+
+	return mockAssertion, nil
+}
+
+func (s *mockSigner) DeriveSharedKey(context.Context, *btcec.PublicKey,
+	*keychain.KeyLocator) ([32]byte, error) {
+
+	return [32]byte{4, 5, 6}, nil
+}

internal/test/testutils.go

@@ -0,0 +1,98 @@
+package test
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime/pprof"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcutil"
+	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/zpay32"
+)
+
+var (
+	// Timeout is the default timeout when tests wait for something to
+	// happen.
+	Timeout = time.Second * 5
+
+	// ErrTimeout is returned on timeout.
+	ErrTimeout = errors.New("test timeout")
+
+	testTime = time.Date(2018, time.January, 9, 14, 00, 00, 0, time.UTC)
+)
+
+// GetDestAddr deterministically generates a sweep address for testing.
+func GetDestAddr(t *testing.T, nr byte) btcutil.Address {
+	destAddr, err := btcutil.NewAddressScriptHash([]byte{nr},
+		&chaincfg.MainNetParams)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return destAddr
+}
+
+// EncodePayReq encodes a zpay32 invoice with a fixed key.
+func EncodePayReq(payReq *zpay32.Invoice) (string, error) {
+	privKey, _ := CreateKey(5)
+	reqString, err := payReq.Encode(
+		zpay32.MessageSigner{
+			SignCompact: func(hash []byte) ([]byte, error) {
+				// btcec.SignCompact returns a
+				// pubkey-recoverable signature
+				sig, err := btcec.SignCompact(
+					btcec.S256(),
+					privKey,
+					payReq.PaymentHash[:],
+					true,
+				)
+				if err != nil {
+					return nil, fmt.Errorf(
+						"can't sign the hash: %v", err)
+				}
+
+				return sig, nil
+			},
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	return reqString, nil
+}
+
+// GetInvoice creates a testnet payment request with the given parameters.
+func GetInvoice(hash lntypes.Hash, amt btcutil.Amount, memo string) (
+	string, error) {
+
+	req, err := zpay32.NewInvoice(
+		&chaincfg.TestNet3Params, hash, testTime,
+		zpay32.Description(memo),
+		zpay32.Amount(lnwire.NewMSatFromSatoshis(amt)),
+	)
+	if err != nil {
+		return "", err
+	}
+
+	reqString, err := EncodePayReq(req)
+	if err != nil {
+		return "", err
+	}
+
+	return reqString, nil
+}
+
+// DumpGoroutines dumps all currently running goroutines.
+func DumpGoroutines() {
+	err := pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
+	if err != nil {
+		panic(err)
+	}
+}

internal/test/timeout.go

@@ -0,0 +1,34 @@
+package test
+
+import (
+	"os"
+	"runtime/pprof"
+	"testing"
+	"time"
+
+	"github.com/fortytw2/leaktest"
+)
+
+// Guard implements a test level timeout.
+func Guard(t *testing.T) func() {
+	done := make(chan struct{})
+	go func() {
+		select {
+		case <-time.After(5 * time.Second):
+			err := pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
+			if err != nil {
+				panic(err)
+			}
+
+			panic("test timeout")
+		case <-done:
+		}
+	}()
+
+	fn := leaktest.Check(t)
+
+	return func() {
+		close(done)
+		fn()
+	}
+}

internal/test/versioner_mock.go

@@ -0,0 +1,51 @@
+package test
+
+import (
+	"context"
+
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/lnrpc/verrpc"
+)
+
+const (
+	defaultMockCommit        = "v0.99.9-beta"
+	defaultMockCommitHash    = "0000000000000000000000000000000000000000"
+	defaultMockVersion       = "v0.99.9-beta"
+	defaultMockAppMajor      = 0
+	defaultMockAppMinor      = 99
+	defaultMockAppPatch      = 9
+	defaultMockAppPrerelease = "beta"
+	defaultMockAppGoVersion  = "go1.99.9"
+)
+
+var (
+	defaultMockBuildTags = []string{
+		"signrpc", "walletrpc", "chainrpc", "invoicesrpc",
+	}
+)
+
+type mockVersioner struct {
+	version *verrpc.Version
+}
+
+var _ lndclient.VersionerClient = (*mockVersioner)(nil)
+
+func newMockVersioner() *mockVersioner {
+	return &mockVersioner{
+		version: &verrpc.Version{
+			Commit:        defaultMockCommit,
+			CommitHash:    defaultMockCommitHash,
+			Version:       defaultMockVersion,
+			AppMajor:      defaultMockAppMajor,
+			AppMinor:      defaultMockAppMinor,
+			AppPatch:      defaultMockAppPatch,
+			AppPreRelease: defaultMockAppPrerelease,
+			BuildTags:     defaultMockBuildTags,
+			GoVersion:     defaultMockAppGoVersion,
+		},
+	}
+}
+
+func (v *mockVersioner) GetVersion(_ context.Context) (*verrpc.Version, error) {
+	return v.version, nil
+}

internal/test/walletkit_mock.go

@@ -0,0 +1,133 @@
+package test
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+	"github.com/btcsuite/btcwallet/wtxmgr"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/keychain"
+	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
+)
+
+type mockWalletKit struct {
+	lnd          *LndMockServices
+	keyIndex     int32
+	feeEstimates map[int32]chainfee.SatPerKWeight
+}
+
+var _ lndclient.WalletKitClient = (*mockWalletKit)(nil)
+
+func (m *mockWalletKit) ListUnspent(ctx context.Context, minConfs,
+	maxConfs int32) ([]*lnwallet.Utxo, error) {
+
+	return nil, nil
+}
+
+func (m *mockWalletKit) LeaseOutput(ctx context.Context, lockID wtxmgr.LockID,
+	op wire.OutPoint) (time.Time, error) {
+
+	return time.Now(), nil
+}
+
+func (m *mockWalletKit) ReleaseOutput(ctx context.Context,
+	lockID wtxmgr.LockID, op wire.OutPoint) error {
+
+	return nil
+}
+
+func (m *mockWalletKit) DeriveNextKey(ctx context.Context, family int32) (
+	*keychain.KeyDescriptor, error) {
+
+	index := m.keyIndex
+
+	_, pubKey := CreateKey(index)
+	m.keyIndex++
+
+	return &keychain.KeyDescriptor{
+		KeyLocator: keychain.KeyLocator{
+			Family: keychain.KeyFamily(family),
+			Index:  uint32(index),
+		},
+		PubKey: pubKey,
+	}, nil
+}
+
+func (m *mockWalletKit) DeriveKey(ctx context.Context, in *keychain.KeyLocator) (
+	*keychain.KeyDescriptor, error) {
+
+	_, pubKey := CreateKey(int32(in.Index))
+
+	return &keychain.KeyDescriptor{
+		KeyLocator: *in,
+		PubKey:     pubKey,
+	}, nil
+}
+
+func (m *mockWalletKit) NextAddr(ctx context.Context) (btcutil.Address, error) {
+	addr, err := btcutil.NewAddressWitnessPubKeyHash(
+		make([]byte, 20), &chaincfg.TestNet3Params,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return addr, nil
+}
+
+func (m *mockWalletKit) PublishTransaction(ctx context.Context, tx *wire.MsgTx) error {
+	m.lnd.AddTx(tx)
+	m.lnd.TxPublishChannel <- tx
+	return nil
+}
+
+func (m *mockWalletKit) SendOutputs(ctx context.Context, outputs []*wire.TxOut,
+	feeRate chainfee.SatPerKWeight) (*wire.MsgTx, error) {
+
+	var inputTxHash chainhash.Hash
+
+	tx := wire.MsgTx{}
+	tx.AddTxIn(&wire.TxIn{
+		PreviousOutPoint: wire.OutPoint{
+			Hash:  inputTxHash,
+			Index: 0,
+		},
+	})
+
+	for _, out := range outputs {
+		tx.AddTxOut(&wire.TxOut{
+			PkScript: out.PkScript,
+			Value:    out.Value,
+		})
+	}
+
+	m.lnd.AddTx(&tx)
+	m.lnd.SendOutputsChannel <- tx
+
+	return &tx, nil
+}
+
+func (m *mockWalletKit) EstimateFee(ctx context.Context, confTarget int32) (
+	chainfee.SatPerKWeight, error) {
+
+	if confTarget <= 1 {
+		return 0, errors.New("conf target must be greater than 1")
+	}
+
+	feeEstimate, ok := m.feeEstimates[confTarget]
+	if !ok {
+		return 10000, nil
+	}
+
+	return feeEstimate, nil
+}
+
+// ListSweeps returns a list of the sweep transaction ids known to our node.
+func (m *mockWalletKit) ListSweeps(_ context.Context) ([]string, error) {
+	return m.lnd.Sweeps, nil
+}

lsat/client_interceptor_test.go

@@ -9,8 +9,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/lightninglabs/aperture/internal/test"
 	"github.com/lightninglabs/lndclient"
-	"github.com/lightninglabs/loop/test"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"google.golang.org/grpc"

lsat/header.go

@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"regexp"
 
-	"github.com/lightninglabs/loop/lsat"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"gopkg.in/macaroon.v2"
 )
@@ -111,7 +110,7 @@ func FromHeader(header *http.Header) (*macaroon.Macaroon, lntypes.Preimage, erro
 		return nil, lntypes.Preimage{}, fmt.Errorf("unable to "+
 			"unmarshal macaroon: %v", err)
 	}
-	preimageHex, ok := lsat.HasCaveat(mac, lsat.PreimageKey)
+	preimageHex, ok := HasCaveat(mac, PreimageKey)
 	if !ok {
 		return nil, lntypes.Preimage{}, errors.New("preimage caveat " +
 			"not found")