Update README.md

Building BTCPay LND 0.18.4

.custom-gcl.yml

@@ -1,4 +0,0 @@
-version: v1.57.0
-plugins:
-  - module: 'github.com/lightningnetwork/lnd/tools/linters'
-    path: ./tools/linters

.github/actions/setup-go/action.yml

@@ -7,26 +7,18 @@ inputs:
   key-prefix:
     description: "A prefix to use for the cache key, to separate cache entries from other workflows"
     required: false
-  use-build-cache: 
-    description: "Whether to use the build cache"
-    required: false
-    # Boolean values aren't supported in the workflow syntax, so we use a
-    # string. To not confuse the value with true/false, we use 'yes' and 'no'.
-    default: 'yes'
 
 runs:
   using: "composite"
 
   steps:
     - name: setup go ${{ inputs.go-version }}
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v3
       with:
         go-version: '${{ inputs.go-version }}'
-        cache: 'false'
 
     - name: go cache
-      if: ${{ inputs.use-build-cache == 'yes' }}
-      uses: actions/cache@v4
+      uses: actions/cache@v3
       with:
         # In order:
         # * Module download cache
@@ -38,39 +30,11 @@ runs:
           ~/.cache/go-build
           ~/Library/Caches/go-build
           ~\AppData\Local\go-build
-
-        # The key is used to create and later look up the cache. It's made of
-        # four parts:  
-        # - The base part is made from the OS name, Go version and a
-        #   job-specified key prefix. Example: `linux-go-1.23.12-unit-test-`.
-        #   It ensures that a job running on Linux with Go 1.23 only looks for
-        #   caches from the same environment.
-        # - The unique part is the `hashFiles('**/go.sum')`, which calculates a
-        #   hash (a fingerprint) of the go.sum file. 
-        key: ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-${{ hashFiles('**/go.sum') }}
-
-        # The restore-keys provides a list of fallback keys. If no cache
-        # matches the key exactly, the action will look for a cache where the
-        # key starts with one of the restore-keys. The action searches the
-        # restore-keys list in order and restores the most recently created
-        # cache that matches the prefix. Once the job is done, a new cache is
-        # created and saved using the new key. 
+        key: ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-${{ github.job }}-${{ hashFiles('**/go.sum') }}
         restore-keys: |
           ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-${{ github.job }}-
           ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-
 
-    - name: go module cache
-      if: ${{ inputs.use-build-cache == 'no' }}
-      uses: actions/cache@v4
-      with:
-        # Just the module download cache.
-        path: |
-          ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-no-build-cache-${{ github.job }}-${{ hashFiles('**/go.sum') }}
-        restore-keys: |
-          ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-no-build-cache-${{ github.job }}-
-          ${{ runner.os }}-go-${{ inputs.go-version }}-${{ inputs.key-prefix }}-no-build-cache-
-
     - name: set GOPATH
       shell: bash
       run: |

.github/pull_request_template.md

@@ -11,9 +11,8 @@ Steps for reviewers to follow to test the change.
 - [ ] Bug fixes contain tests triggering the bug to prevent regressions.
 
 ### Code Style and Documentation
-- [ ] The change is not [insubstantial](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md#substantial-contributions-only). Typo fixes are not accepted to fight bot spam.
-- [ ] The change obeys the [Code Documentation and Commenting](https://github.com/lightningnetwork/lnd/blob/master/docs/development_guidelines.md#code-documentation-and-commenting) guidelines, and lines wrap at 80.
-- [ ] Commits follow the [Ideal Git Commit Structure](https://github.com/lightningnetwork/lnd/blob/master/docs/development_guidelines.md#ideal-git-commit-structure).
+- [ ] The change obeys the [Code Documentation and Commenting](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md#CodeDocumentation) guidelines, and lines wrap at 80.
+- [ ] Commits follow the [Ideal Git Commit Structure](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md#IdealGitCommitStructure).
 - [ ] Any new logging statements use an appropriate subsystem and logging level.
 - [ ] Any new lncli commands have appropriate tags in the comments for the rpc in the proto file.
 - [ ] [There is a change description in the release notes](https://github.com/lightningnetwork/lnd/tree/master/docs/release-notes), or `[skip ci]` in the commit message for small changes.

.github/workflows/main.yml

@@ -21,20 +21,17 @@ defaults:
     shell: bash
 
 env:
-  BITCOIN_VERSION: "29"
+  BITCOIN_VERSION: "28"
   
-  # TRANCHES defines the number of tranches used in the itests.
-  TRANCHES: 16
+  TRANCHES: 8
 
-  # SMALL_TRANCHES defines the number of tranches used in the less stable itest
-  # builds
-  #
-  # TODO(yy): remove this value and use TRANCHES.
-  SMALL_TRANCHES: 8
-
-  # If you change this please also update GO_VERSION in Makefile (then run
-  # `make lint` to see where else it needs to be updated as well).
-  GO_VERSION: 1.23.12
+  # If you change this value, please change it in the following files as well:
+  # /.travis.yml
+  # /Dockerfile
+  # /dev.Dockerfile
+  # /make/builder.Dockerfile
+  # /.github/workflows/release.yml
+  GO_VERSION: 1.22.6
 
 jobs:
   ########################
@@ -44,11 +41,8 @@ jobs:
     name: Sqlc check
     runs-on: ubuntu-latest
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: setup go ${{ env.GO_VERSION }}
         uses: ./.github/actions/setup-go
@@ -70,11 +64,8 @@ jobs:
     name: RPC and mobile compilation check
     runs-on: ubuntu-latest
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: setup go ${{ env.GO_VERSION }}
         uses: ./.github/actions/setup-go
@@ -101,11 +92,8 @@ jobs:
     name: check commits
     runs-on: ubuntu-latest
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -127,11 +115,8 @@ jobs:
     name: lint code
     runs-on: ubuntu-latest
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -158,33 +143,18 @@ jobs:
   cross-compile:
     name: cross compilation
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: true
-      matrix:
-        # Please keep this list in sync with make/release_flags.mk!
-        include:
-          - name: i386
-            sys: freebsd-386 linux-386 windows-386
-          - name: amd64
-            sys: darwin-amd64 freebsd-amd64 linux-amd64 netbsd-amd64 openbsd-amd64 windows-amd64
-          - name: arm
-            sys: darwin-arm64 freebsd-arm linux-armv6 linux-armv7 linux-arm64 windows-arm
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: setup go ${{ env.GO_VERSION }}
         uses: ./.github/actions/setup-go
         with:
           go-version: '${{ env.GO_VERSION }}'
           key-prefix: cross-compile
-          use-build-cache: 'no'
 
       - name: build release for all architectures
-        run: make release sys="${{ matrix.sys }}"
+        run: make release
 
   ########################
   # sample configuration check
@@ -193,11 +163,8 @@ jobs:
     name: sample configuration check
     runs-on: ubuntu-latest
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: setup go ${{ env.GO_VERSION }}
         uses: ./.github/actions/setup-go
@@ -218,19 +185,16 @@ jobs:
       fail-fast: false
       matrix:
         unit_type:
-          - unit-cover
+          - btcd unit-cover
           - unit tags="kvdb_etcd"
           - unit tags="kvdb_postgres"
           - unit tags="kvdb_sqlite"
-          - unit-race
+          - btcd unit-race
           - unit-module
 
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -239,7 +203,7 @@ jobs:
         uses: ./.github/actions/rebase
 
       - name: git checkout fuzzing seeds
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           repository: lightninglabs/lnd-fuzz
           path: lnd-fuzz
@@ -259,26 +223,20 @@ jobs:
       - name: run ${{ matrix.unit_type }}
         run: make ${{ matrix.unit_type }}
 
-      - name: Clean coverage
-        run: grep -Ev '(\.pb\.go|\.pb\.json\.go|\.pb\.gw\.go)' coverage.txt > coverage-norpc.txt
-        if: matrix.unit_type == 'unit-cover'
-
       - name: Send coverage
-        uses: coverallsapp/github-action@v2
-        if: matrix.unit_type == 'unit-cover'
-        continue-on-error: true
+        uses: shogo82148/actions-goveralls@v1
+        if: matrix.unit_type == 'btcd unit-cover'
         with:
-          file: coverage-norpc.txt
+          path-to-profile: coverage.txt
           flag-name: 'unit'
-          format: 'golang'
           parallel: true
 
 
   ########################
-  # run integration tests with TRANCHES
+  # run ubuntu integration tests
   ########################
-  basic-integration-test:
-    name: basic itests
+  ubuntu-integration-test:
+    name: run ubuntu itests
     runs-on: ubuntu-latest
     if: '!contains(github.event.pull_request.labels.*.name, ''no-itest'')'
     strategy:
@@ -292,14 +250,23 @@ jobs:
             args: backend=bitcoind cover=1
           - name: bitcoind-notxindex
             args: backend="bitcoind notxindex"
+          - name: bitcoind-rpcpolling
+            args: backend="bitcoind rpcpolling" cover=1
+          - name: bitcoind-etcd
+            args: backend=bitcoind dbbackend=etcd
+          - name: bitcoind-postgres
+            args: backend=bitcoind dbbackend=postgres
+          - name: bitcoind-sqlite
+            args: backend=bitcoind dbbackend=sqlite
+          - name: bitcoind-postgres-nativesql
+            args: backend=bitcoind dbbackend=postgres nativesql=true
+          - name: bitcoind-sqlite-nativesql
+            args: backend=bitcoind dbbackend=sqlite nativesql=true
           - name: neutrino
             args: backend=neutrino cover=1
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -317,93 +284,14 @@ jobs:
         run: ./scripts/install_bitcoind.sh $BITCOIN_VERSION
 
       - name: run ${{ matrix.name }}
-        run: make itest-parallel tranches=${{ env.TRANCHES }} ${{ matrix.args }} shuffleseed=${{ github.run_id }}${{ strategy.job-index }}
-
-      - name: Clean coverage
-        run: grep -Ev '(\.pb\.go|\.pb\.json\.go|\.pb\.gw\.go)' coverage.txt > coverage-norpc.txt
-        if: ${{ contains(matrix.args, 'cover=1') }}
+        run: make itest-parallel tranches=${{ env.TRANCHES }} ${{ matrix.args }}
 
       - name: Send coverage
         if: ${{ contains(matrix.args, 'cover=1') }}
-        continue-on-error: true
-        uses: coverallsapp/github-action@v2
+        uses: shogo82148/actions-goveralls@v1
         with:
-          file: coverage-norpc.txt
+          path-to-profile: coverage.txt
           flag-name: 'itest-${{ matrix.name }}'
-          format: 'golang'
-          parallel: true
-
-      - name: Zip log files on failure
-        if: ${{ failure() }}
-        timeout-minutes: 5 # timeout after 5 minute
-        run: 7z a logs-itest-${{ matrix.name }}.zip itest/**/*.log itest/postgres.log
-
-      - name: Upload log files on failure
-        uses: actions/upload-artifact@v4
-        if: ${{ failure() }}
-        with:
-          name: logs-itest-${{ matrix.name }}
-          path: logs-itest-${{ matrix.name }}.zip
-          retention-days: 5
-
-  ########################
-  # run integration tests with SMALL_TRANCHES
-  ########################
-  integration-test:
-    name: itests
-    runs-on: ubuntu-latest
-    if: '!contains(github.event.pull_request.labels.*.name, ''no-itest'')'
-    strategy:
-      # Allow other tests in the matrix to continue if one fails.
-      fail-fast: false
-      matrix:
-        include:
-          - name: bitcoind-rpcpolling
-            args: backend="bitcoind rpcpolling"
-          - name: bitcoind-etcd
-            args: backend=bitcoind dbbackend=etcd
-          - name: bitcoind-sqlite
-            args: backend=bitcoind dbbackend=sqlite
-          - name: bitcoind-sqlite-nativesql
-            args: backend=bitcoind dbbackend=sqlite nativesql=true
-          - name: bitcoind-postgres
-            args: backend=bitcoind dbbackend=postgres
-          - name: bitcoind-postgres-nativesql
-            args: backend=bitcoind dbbackend=postgres nativesql=true
-    steps:
-      - name: git checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: fetch and rebase on ${{ github.base_ref }}
-        if: github.event_name == 'pull_request'
-        uses: ./.github/actions/rebase
-
-      - name: setup go ${{ env.GO_VERSION }}
-        uses: ./.github/actions/setup-go
-        with:
-          go-version: '${{ env.GO_VERSION }}'
-          key-prefix: integration-test
-
-      - name: install bitcoind
-        run: ./scripts/install_bitcoind.sh $BITCOIN_VERSION
-
-      - name: run ${{ matrix.name }}
-        run: make itest-parallel tranches=${{ env.SMALL_TRANCHES }} ${{ matrix.args }} shuffleseed=${{ github.run_id }}${{ strategy.job-index }}
-
-      - name: Clean coverage
-        run: grep -Ev '(\.pb\.go|\.pb\.json\.go|\.pb\.gw\.go)' coverage.txt > coverage-norpc.txt
-        if: ${{ contains(matrix.args, 'cover=1') }}
-
-      - name: Send coverage
-        if: ${{ contains(matrix.args, 'cover=1') }}
-        continue-on-error: true
-        uses: coverallsapp/github-action@v2
-        with:
-          file: coverage-norpc.txt
-          flag-name: 'itest-${{ matrix.name }}'
-          format: 'golang'
           parallel: true
 
       - name: Zip log files on failure
@@ -412,7 +300,7 @@ jobs:
         run: 7z a logs-itest-${{ matrix.name }}.zip itest/**/*.log
 
       - name: Upload log files on failure
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: ${{ failure() }}
         with:
           name: logs-itest-${{ matrix.name }}
@@ -424,12 +312,12 @@ jobs:
   # run windows integration test
   ########################
   windows-integration-test:
-    name: windows itest
+    name: run windows itest
     runs-on: windows-latest
     if: '!contains(github.event.pull_request.labels.*.name, ''no-itest'')'
     steps:
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -444,7 +332,7 @@ jobs:
           key-prefix: integration-test
 
       - name: run itest
-        run: make itest-parallel tranches=${{ env.SMALL_TRANCHES }} windows=1 shuffleseed=${{ github.run_id }}
+        run: make itest-parallel tranches=${{ env.TRANCHES }} windows=1
         
       - name: kill any remaining lnd processes
         if: ${{ failure() }}
@@ -457,7 +345,7 @@ jobs:
         run: 7z a logs-itest-windows.zip itest/**/*.log
 
       - name: Upload log files on failure
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: ${{ failure() }}
         with:
           name: logs-itest-windows
@@ -468,12 +356,12 @@ jobs:
   # run macOS integration test
   ########################
   macos-integration-test:
-    name: macOS itest
+    name: run macOS itest
     runs-on: macos-14
     if: '!contains(github.event.pull_request.labels.*.name, ''no-itest'')'
     steps:
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -487,8 +375,14 @@ jobs:
           go-version: '${{ env.GO_VERSION }}'
           key-prefix: integration-test
 
+      - name: install bitcoind
+        run: |
+          wget https://bitcoincore.org/bin/bitcoin-core-${BITCOIN_VERSION}.0/bitcoin-${BITCOIN_VERSION}.0-arm64-apple-darwin.tar.gz
+          tar zxvf bitcoin-${BITCOIN_VERSION}.0-arm64-apple-darwin.tar.gz
+          mv bitcoin-${BITCOIN_VERSION}.0 /tmp/bitcoin
+
       - name: run itest
-        run: make itest-parallel tranches=${{ env.SMALL_TRANCHES }} shuffleseed=${{ github.run_id }}
+        run: PATH=$PATH:/tmp/bitcoin/bin make itest-parallel tranches=${{ env.TRANCHES }} backend=bitcoind
 
       - name: Zip log files on failure
         if: ${{ failure() }}
@@ -496,7 +390,7 @@ jobs:
         run: 7z a logs-itest-macos.zip itest/**/*.log
 
       - name: Upload log files on failure
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: ${{ failure() }}
         with:
           name: logs-itest-macos
@@ -518,11 +412,8 @@ jobs:
           - github.com/golang/protobuf v1.5.3
 
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: ensure dependencies at correct version
         run: if ! grep -q "${{ matrix.pinned_dep }}" go.mod; then echo dependency ${{ matrix.pinned_dep }} should not be altered ; exit 1 ; fi
@@ -535,39 +426,18 @@ jobs:
     runs-on: ubuntu-latest
     if: '!contains(github.event.pull_request.labels.*.name, ''no-changelog'')'
     steps:
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache
-
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: release notes check
         run: scripts/check-release-notes.sh
-
-  ########################
-  # Backwards Compatibility Test
-  ########################
-  backwards-compatability-test:
-    name: backwards compatability test
-    runs-on: ubuntu-latest
-    steps:
-      - name: git checkout
-        uses: actions/checkout@v4
-
-      - name: 🐳 Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: 🛡️ backwards compatibility test
-        run: make backwards-compat-test
-
+  
   # Notify about the completion of all coverage collecting jobs.
   finish:
     if: ${{ always() }}
-    needs: [unit-test, basic-integration-test]
+    needs: [unit-test, ubuntu-integration-test]
     runs-on: ubuntu-latest
     steps:
-      - name: Send coverage
-        uses: coverallsapp/github-action@v2
-        continue-on-error: true
+      - uses: shogo82148/actions-goveralls@v1
         with:
           parallel-finished: true

.github/workflows/release.yaml

@@ -10,9 +10,12 @@ defaults:
     shell: bash
 
 env:
-  # If you change this please also update GO_VERSION in Makefile (then run
-  # `make lint` to see where else it needs to be updated as well).
-  GO_VERSION: 1.23.12
+  # If you change this value, please change it in the following files as well:
+  # /Dockerfile
+  # /dev.Dockerfile
+  # /make/builder.Dockerfile
+  # /.github/workflows/main.yml
+  GO_VERSION: 1.22.6
 
 jobs:
   main:
@@ -20,18 +23,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
 
-      - name: cleanup space
-        run: rm -rf /opt/hostedtoolcache && mkdir -p /opt/hostedtoolcache/go
-
       - name: setup go ${{ env.GO_VERSION }}
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
         with:
           go-version: '${{ env.GO_VERSION }}'
-          cache: 'false'
 
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
@@ -123,12 +122,10 @@ jobs:
             that `vendor.tar.gz` and `lnd-source-${{ env.RELEASE_VERSION }}.tar.gz` are in the current directory, follow these steps:
 
             ```
-            tar -xvzf lnd-source-${{ env.RELEASE_VERSION }}.tar.gz
-            mv vendor.tar.gz lnd-source/
-            cd lnd-source
             tar -xvzf vendor.tar.gz
-            go install -v -mod=vendor -ldflags "-X github.com/lightningnetwork/lnd/build.Commit=${{ env.RELEASE_VERSION }}" ./cmd/lnd
-            go install -v -mod=vendor -ldflags "-X github.com/lightningnetwork/lnd/build.Commit=${{ env.RELEASE_VERSION }}" ./cmd/lncli
+            tar -xvzf lnd-source-${{ env.RELEASE_VERSION }}.tar.gz
+            GO111MODULE=on go install -v -mod=vendor -ldflags "-X github.com/lightningnetwork/lnd/build.Commit=${{ env.RELEASE_VERSION }}" ./cmd/lnd
+            GO111MODULE=on go install -v -mod=vendor -ldflags "-X github.com/lightningnetwork/lnd/build.Commit=${{ env.RELEASE_VERSION }}" ./cmd/lncli
             ```
 
             The `-mod=vendor` flag tells the `go build` command that it doesn't need to fetch the dependencies, and instead, they're all enclosed in the local vendor directory. 

.gitignore

@@ -44,9 +44,6 @@ cmd/cmd
 *.key
 *.hex
 
-# Ignore the custom linter binary if it is built.
-custom-gcl
-
 cmd/lncli/lncli
 
 # Files from mobile build.
@@ -80,5 +77,3 @@ coverage.txt
 # Release build directory (to avoid build.vcs.modified Golang build tag to be
 # set to true by having untracked files in the working directory).
 /lnd-*/
-
-.aider*

.golangci.yml

@@ -1,7 +1,5 @@
 run:
-  # If you change this please also update GO_VERSION in Makefile (then run
-  # `make lint` to see where else it needs to be updated as well).
-  go: "1.23.12"
+  go: "1.22.6"
 
   # Abort after 10 minutes.
   timeout: 10m
@@ -22,22 +20,14 @@ run:
     - integration
 
 linters-settings:
-  custom:
-    ll:
-      type: "module"
-      description: "Custom lll linter with 'S' log line exclusion."
-      settings:
-        # Max line length, lines longer will be reported.
-        line-length: 80
-        # Tab width in spaces.
-        tab-width: 8
-        # The regex that we will use to detect the start of an `S` log line.
-        log-regex: "^\\s*.*(L|l)og\\.(Info|Debug|Trace|Warn|Error|Critical)S\\("
-
   errorlint:
     # Check for incorrect fmt.Errorf error wrapping.
     errorf: true
 
+  govet:
+    # Don't report about shadowed variables
+    check-shadowing: false
+
   gofmt:
     # simplify code: gofmt with `-s` option, true by default
     simplify: true
@@ -55,12 +45,16 @@ linters-settings:
     excludes:
       - G402 # Look for bad TLS connection settings.
       - G306 # Poor file permissions used when writing to a new file.
-      - G601 # Implicit memory aliasing in for loop.
-      - G115 # Integer overflow in conversion.
 
   staticcheck:
     checks: ["-SA1019"]
 
+  lll:
+    # Max line length, lines longer will be reported.
+    line-length: 80
+    # Tab width in spaces.
+    tab-width: 8
+
   funlen:
     # Checks the number of lines in a function.
     # If lower than 0, disable the check.
@@ -111,10 +105,6 @@ linters-settings:
 linters:
   enable-all: true
   disable:
-    # We instead use our own custom line length linter called `ll` since
-    # then we can ignore log lines.
-    - lll
-
     # Global variables are used in many places throughout the code base.
     - gochecknoglobals
 
@@ -142,13 +132,16 @@ linters:
     - unparam
     - wastedassign
 
+
     # Disable gofumpt as it has weird behavior regarding formatting multiple
     # lines for a function which is in conflict with our contribution
     # guidelines. See https://github.com/mvdan/gofumpt/issues/235.
     - gofumpt
 
     # Disable whitespace linter as it has conflict rules against our
-    # contribution guidelines.
+    # contribution guidelines. See https://github.com/bombsimon/wsl/issues/109.
+    #
+    # TODO(yy): bring it back when the above issue is fixed.
     - wsl
 
     # Allow using default empty values.
@@ -192,6 +185,7 @@ linters:
     
     # The linter is too aggressive and doesn't add much value since reviewers
     # will also catch magic numbers that make sense to extract.
+    - gomnd
     - mnd
 
     # Some of the tests cannot be parallelized. On the other hand, we don't
@@ -210,14 +204,11 @@ linters:
     - depguard
     - gosmopolitan
     - intrange
-    - goconst
 
-    # Deprecated linters that have been replaced by newer ones.
-    - tenv
 
 issues:
   # Only show newly introduced problems.
-  new-from-rev: 03eab4db64540aa5f789c617793e4459f4ba9e78
+  new-from-rev: 77c7f776d5cbf9e147edc81d65ae5ba177a684e5
 
   # Skip autogenerated files for mobile and gRPC as well as copied code for
   # internal use.

Dockerfile

@@ -1,6 +1,9 @@
-# If you change this please also update GO_VERSION in Makefile (then run
-# `make lint` to see where else it needs to be updated as well).
-FROM golang:1.24.11-alpine as builder
+# If you change this value, please change it in the following files as well:
+# /dev.Dockerfile
+# /make/builder.Dockerfile
+# /.github/workflows/main.yml
+# /.github/workflows/release.yml
+FROM golang:1.22.6-alpine as builder
 
 # Force Go to use the cgo based DNS resolver. This is required to ensure DNS
 # queries required to connect to linked containers succeed.
@@ -21,7 +24,7 @@ RUN apk add --no-cache --update alpine-sdk \
 &&  cd /go/src/github.com/lightningnetwork/lnd \
 &&  git checkout $checkout \
 &&  make release-install
- 
+
 # Start a new, final image.
 FROM alpine as final
 

Makefile

@@ -1,17 +1,19 @@
 PKG := github.com/lightningnetwork/lnd
+ESCPKG := github.com\/lightningnetwork\/lnd
 MOBILE_PKG := $(PKG)/mobile
 TOOLS_DIR := tools
 
-GOCC ?= go
 PREFIX ?= /usr/local
 
 BTCD_PKG := github.com/btcsuite/btcd
+GOACC_PKG := github.com/ory/go-acc
 GOIMPORTS_PKG := github.com/rinchsan/gosimports/cmd/gosimports
 
 GO_BIN := ${GOPATH}/bin
 BTCD_BIN := $(GO_BIN)/btcd
 GOIMPORTS_BIN := $(GO_BIN)/gosimports
 GOMOBILE_BIN := $(GO_BIN)/gomobile
+GOACC_BIN := $(GO_BIN)/go-acc
 
 MOBILE_BUILD_DIR :=${GOPATH}/src/$(MOBILE_PKG)/build
 IOS_BUILD_DIR := $(MOBILE_BUILD_DIR)/ios
@@ -25,17 +27,27 @@ COMMIT := $(subst -dirty,-fresh-btcpay,$(COMMIT))
 LDFLAGS := -ldflags "-X $(PKG)/build.Commit=$(COMMIT)"
 
 # Determine the minor version of the active Go installation.
-ACTIVE_GO_VERSION := $(shell $(GOCC) version | sed -nre 's/^[^0-9]*(([0-9]+\.)*[0-9]+).*/\1/p')
+ACTIVE_GO_VERSION := $(shell go version | sed -nre 's/^[^0-9]*(([0-9]+\.)*[0-9]+).*/\1/p')
 ACTIVE_GO_VERSION_MINOR := $(shell echo $(ACTIVE_GO_VERSION) | cut -d. -f2)
 
+LOOPVARFIX :=
+ifeq ($(shell expr $(ACTIVE_GO_VERSION_MINOR) \>= 21), 1)
+	LOOPVARFIX := GOEXPERIMENT=loopvar
+endif
+
+LOOPVARFIX :=
+ifeq ($(shell expr $(GO_VERSION_MINOR) \>= 21), 1)
+	LOOPVARFIX := GOEXPERIMENT=loopvar
+endif
+
 # GO_VERSION is the Go version used for the release build, docker files, and
 # GitHub Actions. This is the reference version for the project. All other Go
 # versions are checked against this version.
-GO_VERSION = 1.23.12
+GO_VERSION = 1.22.6
 
-GOBUILD := $(GOCC) build -v
-GOINSTALL := $(GOCC) install -v
-GOTEST := $(GOCC) test
+GOBUILD := $(LOOPVARFIX) go build -v
+GOINSTALL := $(LOOPVARFIX) go install -v
+GOTEST := $(LOOPVARFIX) go test
 
 GOFILES_NOVENDOR = $(shell find . -type f -name '*.go' -not -path "./vendor/*" -not -name "*pb.go" -not -name "*pb.gw.go" -not -name "*.pb.json.go")
 
@@ -69,8 +81,8 @@ endif
 
 DOCKER_TOOLS = docker run \
   --rm \
-  -v $(shell bash -c "$(GOCC) env GOCACHE || (mkdir -p /tmp/go-cache; echo /tmp/go-cache)"):/tmp/build/.cache \
-  -v $(shell bash -c "$(GOCC) env GOMODCACHE || (mkdir -p /tmp/go-modcache; echo /tmp/go-modcache)"):/tmp/build/.modcache \
+  -v $(shell bash -c "go env GOCACHE || (mkdir -p /tmp/go-cache; echo /tmp/go-cache)"):/tmp/build/.cache \
+  -v $(shell bash -c "go env GOMODCACHE || (mkdir -p /tmp/go-modcache; echo /tmp/go-modcache)"):/tmp/build/.modcache \
   -v $(shell bash -c "mkdir -p /tmp/go-lint-cache; echo /tmp/go-lint-cache"):/root/.cache/golangci-lint \
   -v $$(pwd):/build lnd-tools
 
@@ -87,13 +99,17 @@ all: scratch check install
 # ============
 # DEPENDENCIES
 # ============
+$(GOACC_BIN):
+	@$(call print, "Installing go-acc.")
+	cd $(TOOLS_DIR); go install -trimpath -tags=tools $(GOACC_PKG)
+
 $(BTCD_BIN):
 	@$(call print, "Installing btcd.")
-	cd $(TOOLS_DIR); $(GOCC) install -trimpath $(BTCD_PKG)
+	cd $(TOOLS_DIR); go install -trimpath $(BTCD_PKG)
 
 $(GOIMPORTS_BIN):
 	@$(call print, "Installing goimports.")
-	cd $(TOOLS_DIR); $(GOCC) install -trimpath $(GOIMPORTS_PKG)
+	cd $(TOOLS_DIR); go install -trimpath $(GOIMPORTS_PKG)
 
 # ============
 # INSTALLATION
@@ -154,7 +170,7 @@ release-install:
 release: clean-mobile
 	@$(call print, "Releasing lnd and lncli binaries.")
 	$(VERSION_CHECK)
-	./scripts/release.sh build-release "$(VERSION_TAG)" "$(BUILD_SYSTEM)" "$(RELEASE_TAGS)" "$(RELEASE_LDFLAGS)" "$(GO_VERSION)"
+	./scripts/release.sh build-release "$(VERSION_TAG)" "$(BUILD_SYSTEM)" "$(RELEASE_TAGS)" "$(RELEASE_LDFLAGS)"
 
 #? docker-release: Same as release but within a docker container to support reproducible builds on BSD/MacOS platforms
 docker-release:
@@ -187,32 +203,20 @@ ifeq ($(dbbackend),postgres)
 	docker rm lnd-postgres --force || echo "Starting new postgres container"
 
 	# Start a fresh postgres instance. Allow a maximum of 500 connections so
-	# that multiple lnd instances with a maximum number of connections of 20
-	# each can run concurrently. Note that many of the settings here are
-	# specifically for integration testing and are not fit for running
-	# production nodes. The increase in max connections ensures that there
-	# are enough entries allocated for the RWConflictPool to allow multiple
-	# conflicting transactions to track serialization conflicts. The
-	# increase in predicate locks and locks per transaction is to allow the
-	# queries to lock individual rows instead of entire tables, helping
-	# reduce serialization conflicts. Disabling sequential scan for small
-	# tables also helps prevent serialization conflicts by ensuring lookups
-	# lock only relevant rows in the index rather than the entire table.
-	docker run --name lnd-postgres -e POSTGRES_PASSWORD=postgres -p 6432:5432 -d postgres:13-alpine -N 1500 -c max_pred_locks_per_transaction=1024 -c max_locks_per_transaction=128 -c enable_seqscan=off
-	docker logs -f lnd-postgres >itest/postgres.log 2>&1 &
+	# that multiple lnd instances with a maximum number of connections of 50
+	# each can run concurrently.
+	docker run --name lnd-postgres -e POSTGRES_PASSWORD=postgres -p 6432:5432 -d postgres:13-alpine -N 500
+	docker logs -f lnd-postgres &
 
 	# Wait for the instance to be started.
 	sleep $(POSTGRES_START_DELAY)
 endif
 
-clean-itest-logs:
-	rm -rf itest/*.log itest/.logs-*
-
 #? itest-only: Only run integration tests without re-building binaries
-itest-only: clean-itest-logs db-instance
+itest-only: db-instance
 	@$(call print, "Running integration tests with ${backend} backend.")
-	date
-	EXEC_SUFFIX=$(EXEC_SUFFIX) scripts/itest_part.sh 0 1 $(SHUFFLE_SEED) $(TEST_FLAGS) $(ITEST_FLAGS) -test.v
+	rm -rf itest/*.log itest/.logs-*; date
+	EXEC_SUFFIX=$(EXEC_SUFFIX) scripts/itest_part.sh 0 1 $(TEST_FLAGS) $(ITEST_FLAGS)
 	$(COLLECT_ITEST_COVERAGE)
 
 #? itest: Build and run integration tests
@@ -222,10 +226,10 @@ itest: build-itest itest-only
 itest-race: build-itest-race itest-only
 
 #? itest-parallel: Build and run integration tests in parallel mode, running up to ITEST_PARALLELISM test tranches in parallel (default 4)
-itest-parallel: clean-itest-logs build-itest db-instance
+itest-parallel: build-itest db-instance
 	@$(call print, "Running tests")
-	date
-	EXEC_SUFFIX=$(EXEC_SUFFIX) scripts/itest_parallel.sh $(ITEST_PARALLELISM) $(NUM_ITEST_TRANCHES) $(SHUFFLE_SEED) $(TEST_FLAGS) $(ITEST_FLAGS)
+	rm -rf itest/*.log itest/.logs-*; date
+	EXEC_SUFFIX=$(EXEC_SUFFIX) scripts/itest_parallel.sh $(ITEST_PARALLELISM) $(NUM_ITEST_TRANCHES) $(TEST_FLAGS) $(ITEST_FLAGS)
 	$(COLLECT_ITEST_COVERAGE)
 
 #? itest-clean: Kill all running itest processes
@@ -249,12 +253,12 @@ unit-debug: $(BTCD_BIN)
 	$(UNIT_DEBUG)
 
 #? unit-cover: Run unit tests in coverage mode
-unit-cover: $(BTCD_BIN)
+unit-cover: $(GOACC_BIN)
 	@$(call print, "Running unit coverage tests.")
-	$(UNIT_COVER)
+	$(GOACC)
 
 #? unit-race: Run unit tests in race detector mode
-unit-race: $(BTCD_BIN)
+unit-race:
 	@$(call print, "Running unit race tests.")
 	env CGO_ENABLED=1 GORACE="history_size=7 halt_on_errors=1" $(UNIT_RACE)
 
@@ -267,18 +271,18 @@ unit-bench: $(BTCD_BIN)
 # FLAKE HUNTING
 # =============
 
-#? flakehunter-itest: Run the integration tests continuously until one fails
-flakehunter-itest: build-itest
+#? flakehunter: Run the integration tests continuously until one fails
+flakehunter: build-itest
 	@$(call print, "Flake hunting ${backend} integration tests.")
 	while [ $$? -eq 0 ]; do make itest-only icase='${icase}' backend='${backend}'; done
 
-#? flakehunter-unit: Run the unit tests continuously until one fails
-flakehunter-unit:
-	@$(call print, "Flake hunting unit test.")
-	scripts/unit-test-flake-hunter.sh ${pkg} ${case}
+#? flake-unit: Run the unit tests continuously until one fails
+flake-unit:
+	@$(call print, "Flake hunting unit tests.")
+	while [ $$? -eq 0 ]; do GOTRACEBACK=all $(UNIT) -count=1; done
 
-#? flakehunter-itest-parallel: Run the integration tests continuously until one fails, running up to ITEST_PARALLELISM test tranches in parallel (default 4)
-flakehunter-itest-parallel:
+#? flakehunter-parallel: Run the integration tests continuously until one fails, running up to ITEST_PARALLELISM test tranches in parallel (default 4)
+flakehunter-parallel:
 	@$(call print, "Flake hunting ${backend} integration tests in parallel.")
 	while [ $$? -eq 0 ]; do make itest-parallel tranches=1 parallel=${ITEST_PARALLELISM} icase='${icase}' backend='${backend}'; done
 
@@ -323,7 +327,7 @@ check-go-version: check-go-version-dockerfile check-go-version-yaml
 #? lint-source: Run static code analysis
 lint-source: docker-tools
 	@$(call print, "Linting source.")
-	$(DOCKER_TOOLS) custom-gcl run -v $(LINT_WORKERS)
+	$(DOCKER_TOOLS) golangci-lint run -v $(LINT_WORKERS)
 
 #? lint: Run static code analysis
 lint: check-go-version lint-source
@@ -355,11 +359,6 @@ help: Makefile
 	@$(call print, "Listing commands:")
 	@sed -n 's/^#?//p' $< | column -t -s ':' |  sort | sed -e 's/^/ /'
 
-#? backwards-compat-test: Run basic backwards compatibility test
-backwards-compat-test:
-	@$(call print, "Running backwards compatability test")
-	./scripts/bw-compatibility-test/test.sh
-
 #? sqlc: Generate sql models and queries in Go
 sqlc:
 	@$(call print, "Generating sql models and queries in Go")
@@ -404,7 +403,7 @@ mobile-rpc:
 #? vendor: Create a vendor directory with all dependencies
 vendor:
 	@$(call print, "Re-creating vendor directory.")
-	rm -r vendor/; $(GOCC) mod vendor
+	rm -r vendor/; go mod vendor
 
 #? apple: Build mobile RPC stubs and project template for iOS and macOS
 apple: mobile-rpc

README.md

@@ -1,101 +1,89 @@
-## Lightning Network Daemon
+# BTCPayServer LND 
 
-[![Release build](https://github.com/lightningnetwork/lnd/actions/workflows/release.yaml/badge.svg)](https://github.com/lightningnetwork/lnd/actions/workflows/release.yaml)
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/lightningnetwork/lnd/blob/master/LICENSE)
-[![Irc](https://img.shields.io/badge/chat-on%20libera-brightgreen.svg)](https://web.libera.chat/#lnd)
-[![Godoc](https://godoc.org/github.com/lightningnetwork/lnd?status.svg)](https://godoc.org/github.com/lightningnetwork/lnd)
-[![Go Report Card](https://goreportcard.com/badge/github.com/lightningnetwork/lnd)](https://goreportcard.com/report/github.com/lightningnetwork/lnd)
+This repository is used to build LND Docker container images that are distributed with BTCPayServer by default.
 
-<img src="logo.png">
+Docker images are published to https://hub.docker.com/r/btcpayserver/lnd/
 
-The Lightning Network Daemon (`lnd`) - is a complete implementation of a
-[Lightning Network](https://lightning.network) node.  `lnd` has several pluggable back-end
-chain services including [`btcd`](https://github.com/btcsuite/btcd) (a
-full-node), [`bitcoind`](https://github.com/bitcoin/bitcoin), and
-[`neutrino`](https://github.com/lightninglabs/neutrino) (a new experimental light client). The project's codebase uses the
-[btcsuite](https://github.com/btcsuite/) set of Bitcoin libraries, and also
-exports a large set of isolated re-usable Lightning Network related libraries
-within it.  In the current state `lnd` is capable of:
-* Creating channels.
-* Closing channels.
-* Completely managing all channel states (including the exceptional ones!).
-* Maintaining a fully authenticated+validated channel graph.
-* Performing path finding within the network, passively forwarding incoming payments.
-* Sending outgoing [onion-encrypted payments](https://github.com/lightningnetwork/lightning-onion)
-through the network.
-* Updating advertised fee schedules.
-* Automatic channel management ([`autopilot`](https://github.com/lightningnetwork/lnd/tree/master/autopilot)).
+Versions:
+ - [0.18.3-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.18.3-beta/images/sha256-513ddd55a5af44a14e27110ee14cb28f1c7a69205bcaa2fba4e66275c1f725e5?context=repo)
+    - Includes 0.28.7-beta Loop
+    - [Fix for lnd unlock password \n problem](https://github.com/btcpayserver/lnd/pull/7)
+ - [0.18.1-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.18.1-beta/images/sha256-5fbfa76a218ab59bf9206485f4c0c071a525f9f0906255a5672054741d043b79?context=repo)
+    - Includes 0.28.5-beta Loop
+ - [0.18.0-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.18.0-beta/images/sha256-e6043dddf0bdbd5c740e882447c441b37f87f2c736ebb08747a4aff5e100d9bf?context=repo)
+    - Includes 0.28.2-beta Loop
+ - [0.17.4-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.17.4-beta/images/sha256-b62ecff5ca71d37f9b4846f35b4d86ddc4faa3fc1dd0618ae9221d99f47708bd?context=explore)
+    - Includes 0.26.6-beta Loop
+ - [0.17.3-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.17.3-beta/images/sha256-141611de6c062835e9513dd1ec4155c779d7a7b55258eb1fe06e228b0835fa56?context=repo)
+    - Includes 0.26.6-beta Loop
+ - [0.17.2-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.17.2-beta/images/sha256-936767369b703a67daf6db6a008a3b53c15f407d29a7ad2327a0de28f5951b30?context=explore)
+    - Includes 0.26.5-beta Loop
+ - [0.17.1-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.17.1-beta/images/sha256-b5c106136bd33a422463c736a1db8bd3541f95ac6f277dae86ab2a01b0c3445a?context=explore)
+    - Includes 0.26.5-beta Loop
+ - [0.17.0-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.17.0-beta/images/sha256-58b98f983cd786bcb4d48ea8586144cafd44d58dc3018e26bfbfcf875f495368?context=explore)
+    - Includes 0.26.4-beta Loop
+ - [0.17.0-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.17.0-beta/images/sha256-58b98f983cd786bcb4d48ea8586144cafd44d58dc3018e26bfbfcf875f495368?context=explore)
+    - Includes 0.26.4-beta Loop
+ - [0.16.4-beta-1](https://hub.docker.com/layers/btcpayserver/lnd/v0.16.4-beta-1/images/sha256-9dd204b62d6c892485b3dd8a76e8f48545ceda5702c9d47329ba4bcbc535a8b4?context=explore)
+ - [0.16.3-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.16.3-beta/images/sha256-9ff34769378cfca18664c7d1da3747e7ad7fb7f38a9a7b82a3d4f85e5bfef7bf?context=explore)
+ - [0.16.2-beta-1](https://hub.docker.com/layers/btcpayserver/lnd/v0.16.2-beta-1/images/sha256-bfff9de84a0a4af9d643ff555125358861b70374976b970cc00d1e7fc44ed520?context=explore)
+ - [0.16.1-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.16.0-beta/images/sha256-f0eb70c20691aaa2ffc34fd5bd6c284299c84e96152cda5e46882a3aa4a3c6a2?context=explore)
+ - [0.16.0-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.16.0-beta/images/sha256-f0eb70c20691aaa2ffc34fd5bd6c284299c84e96152cda5e46882a3aa4a3c6a2?context=explore)
+ - [0.15.4-beta](https://hub.docker.com/layers/btcpayserver/lnd/v0.15.4-beta-1/images/sha256-cadbbff93cf36146e24fa4f32170b4b9d278a2e1acfdc50470790a94506ee9c3?context=explore)
+ - [Other versions are tagged](https://github.com/btcpayserver/lnd/tags), but obsoleted and not supported.
+    - All LND versions prior to 0.15.4 contain a consensus bug that prevents them from properly parsing transactions with more than 500,000 witness items per input (https://github.com/btcsuite/btcd/issues/1906)
+    - All LND versions prior to 0.15.2 contain a bug that prevents them from properly parsing Taproot transactions with script size over 11000 bytes (https://github.com/lightningnetwork/lnd/issues/7002)
+    - LND version 0.14.0-beta shipped with check that made it incompatable with c-lightning and eclair (https://github.com/lightningnetwork/lnd/issues/5890)
+    - All LND versions prior to 0.13.3 contain specification-level vulnerability (https://lists.linuxfoundation.org/pipermail/lightning-dev/2021-October/003257.html)
+    - All LND versions prior to 0.7 contain critical vulnerability (https://lists.linuxfoundation.org/pipermail/lightning-dev/2019-September/002174.html)
 
-## Lightning Network Specification Compliance
-`lnd` _fully_ conforms to the [Lightning Network specification
-(BOLTs)](https://github.com/lightningnetwork/lightning-rfc). BOLT stands for:
-Basis of Lightning Technology. The specifications are currently being drafted
-by several groups of implementers based around the world including the
-developers of `lnd`. The set of specification documents as well as our
-implementation of the specification are still a work-in-progress. With that
-said, the current status of `lnd`'s BOLT compliance is:
+Each version is marked with appropriate `basedon-vX.X.X-beta` tags. We are using `basedon` prefix in order not to conflict with LND tags from source repository.
 
-  - [X] BOLT 1: Base Protocol
-  - [X] BOLT 2: Peer Protocol for Channel Management
-  - [X] BOLT 3: Bitcoin Transaction and Script Formats
-  - [X] BOLT 4: Onion Routing Protocol
-  - [X] BOLT 5: Recommendations for On-chain Transaction Handling
-  - [X] BOLT 7: P2P Node and Channel Discovery
-  - [X] BOLT 8: Encrypted and Authenticated Transport
-  - [X] BOLT 9: Assigned Feature Flags
-  - [X] BOLT 10: DNS Bootstrap and Assisted Node Location
-  - [X] BOLT 11: Invoice Protocol for Lightning Payments
+## Updating LND version in BTCPay Server
 
-## Developer Resources
+1. **Update https://github.com/btcpayserver/lnd**
 
-The daemon has been designed to be as developer friendly as possible in order
-to facilitate application development on top of `lnd`. Two primary RPC
-interfaces are exported: an HTTP REST API, and a [gRPC](https://grpc.io/)
-service. The exported APIs are not yet stable, so be warned: they may change
-drastically in the near future.
+   a) Go to https://github.com/lightningnetwork/lnd/releases and find the commit on which we should add our resources.  
+   b) Checkout a new branch for that commit, usually in the format of `lnd/v0.18.3-beta`.  
+   c) Cherry-pick the `Adding BtcPayServer related files and resources` commit. [Example commit](https://github.com/btcpayserver/lnd/commit/ae4bb33c6a3db8b7cc01d18fdf46e600ead9bed4).  
+   d) Tag it with the `basedon-v*` prefix name and push it. For v0.18.1, the tag name was `basedon-v0.18.3-beta`.
+      i. Before you push the tag to CircleCI to build and publish image to Docker Hub, you can test if building the image works locally.
+      ii. You can do this for linuxamd64 for example by using command `docker build --pull -t local-lnd:test_version -f linuxamd64.Dockerfile .`
+   e) The build process will start (it [matches on tag format](.circleci/config.yml#L11)). Here is [an example CircleCI build](https://app.circleci.com/pipelines/github/btcpayserver/lnd/202/workflows/b90b5888-c0b8-4207-860e-a63ce21077af).  
+   f) The resulting image will be published to Docker Hub. Example [Docker Hub image for v0.18.3](https://hub.docker.com/layers/btcpayserver/lnd/v0.18.3-beta/images/sha256-513ddd55a5af44a14e27110ee14cb28f1c7a69205bcaa2fba4e66275c1f725e5?context=repo).
 
-An automatically generated set of documentation for the RPC APIs can be found
-at [api.lightning.community](https://api.lightning.community). A set of developer
-resources including guides, articles, example applications and community resources can be found at:
-[docs.lightning.engineering](https://docs.lightning.engineering).
+   Occasionally, there are problems with:
+   - Versioning of base Docker images used for building Go binaries. You may need to bump that base image - [example commit](https://github.com/btcpayserver/lnd/commit/c841954c515a9d067c24987291316b093b91c2f2).
+   - [Updating Loop](https://github.com/lightninglabs/loop) as part of the package, which needs to happen occasionally. [Example bump of Loop version](https://github.com/btcpayserver/lnd/commit/b3aecc7ac58280ef662e39ba99461573a30fe79a
 
-Finally, we also have an active
-[Slack](https://lightning.engineering/slack.html) where protocol developers, application developers, testers and users gather to
-discuss various aspects of `lnd` and also Lightning in general.
+3. **Update https://github.com/btcpayserver/BTCPayServer.Lightning**
 
-First-time contributors are [highly encouraged to start with code review
-first](docs/review.md), before creating their own Pull Requests.
+   Now we need to update the dependency in our Lightning library project. This library has tests, so we will know if something is broken.
 
-## Installation
-  In order to build from source, please see [the installation
-  instructions](docs/INSTALL.md).
+   a) Modify the `docker-compose.yml` file to reference the new LND version. [Example](https://github.com/btcpayserver/BTCPayServer.Lightning/pull/162/commits/413784ef9b2a8e7aa0496eb91f792ff0086c0ef7).  
+   b) Checkout a new branch for that commit, usually in the format of `feat/lnd-0.18.1`.  
+   c) Title the commit `Bumping LND to 0.18.1-beta`.  
+   d) Open a pull request and reference Docker Hub and Tag. [Example PR](https://github.com/btcpayserver/BTCPayServer.Lightning/pull/162).
+   e) Once tests pass, you can merge it.
 
-## Docker
-  To run lnd from Docker, please see the main [Docker instructions](docs/DOCKER.md)
+4. **Update https://github.com/btcpayserver/btcpayserver**
 
-## IRC
-  * irc.libera.chat
-  * channel #lnd
-  * [webchat](https://web.libera.chat/#lnd)
+   This will give access to LND to the whole dev team and allow for further testing on their dev machines if everything works as expected.
 
-## Safety
+   a) Modify 4 `docker-compose.yml` files in `BTCPayServer.Tests`. [Example pull request to emulate](https://github.com/btcpayserver/btcpayserver/pull/6795).  
+   b) When you open the PR, include the version and link to the BTCPayServer.Lightning PR.  
+   c) Once tests pass, you can merge it.
 
-When operating a mainnet `lnd` node, please refer to our [operational safety
-guidelines](docs/safety.md). It is important to note that `lnd` is still
-**beta** software and that ignoring these operational guidelines can lead to
-loss of funds.
+5. **Update https://github.com/btcpayserver/btcpayserver-docker**
 
-## Security
+   a) Now that everything is prepared, open a PR in the btcpayserver-docker repository to allow these changes to propagate to everyone. [Example pull request](https://github.com/btcpayserver/btcpayserver-docker/pull/911).  
+   b) Open the PR in DRAFT mode and tag @NicolasDorier and @Pavlenex as reviewers. They typically handle releases, and once they test that the LND version update works on their server, they can ACK the update and merge it as part of the release process.
 
-The developers of `lnd` take security _very_ seriously. The disclosure of
-security vulnerabilities helps us secure the health of `lnd`, privacy of our
-users, and also the health of the Lightning Network as a whole.  If you find
-any issues regarding security or privacy, please disclose the information
-responsibly by sending an email to security at lightning dot engineering,
-preferably encrypted using our designated PGP key
-(`91FE464CD75101DA6B6BAB60555C6465E5BCB3AF`) which can be found
-[here](https://gist.githubusercontent.com/Roasbeef/6fb5b52886183239e4aa558f83d085d3/raw/5fa96010af201628bcfa61e9309d9b13d23d220f/security@lightning.engineering).
+## Source repository
 
-## Further reading
-* [Step-by-step send payment guide with docker](https://github.com/lightningnetwork/lnd/tree/master/docker)
-* [Contribution guide](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md)
+https://github.com/lightningnetwork/lnd
+
+## Links
+* [BTCPayServer main repo](https://github.com/btcpayserver/btcpayserver)
+* [BTCPayServer-Docker repo](https://github.com/btcpayserver/btcpayserver-docker)
+* [BTCPayServer.Lightning](https://github.com/btcpayserver/BTCPayServer.Lightning)

accessman.go

@@ -1,664 +0,0 @@
-package lnd
-
-import (
-	"context"
-	"fmt"
-	"maps"
-	"sync"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btclog/v2"
-	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/lnutils"
-)
-
-// accessMan is responsible for managing the server's access permissions.
-type accessMan struct {
-	cfg *accessManConfig
-
-	// banScoreMtx is used for the server's ban tracking. If the server
-	// mutex is also going to be locked, ensure that this is locked after
-	// the server mutex.
-	banScoreMtx sync.RWMutex
-
-	// peerChanInfo is a mapping from remote public key to {bool, uint64}
-	// where the bool indicates that we have an open/closed channel with the
-	// peer and where the uint64 indicates the number of pending-open
-	// channels we currently have with them. This mapping will be used to
-	// determine access permissions for the peer. The map key is the
-	// string-version of the serialized public key.
-	//
-	// NOTE: This MUST be accessed with the banScoreMtx held.
-	peerChanInfo map[string]channeldb.ChanCount
-
-	// peerScores stores each connected peer's access status. The map key
-	// is the string-version of the serialized public key.
-	//
-	// NOTE: This MUST be accessed with the banScoreMtx held.
-	//
-	// TODO(yy): unify `peerScores` and `peerChanInfo` - there's no need to
-	// create two maps tracking essentially the same info. `numRestricted`
-	// can also be derived from `peerChanInfo`.
-	peerScores map[string]peerSlotStatus
-
-	// numRestricted tracks the number of peers with restricted access in
-	// peerScores. This MUST be accessed with the banScoreMtx held.
-	numRestricted int64
-}
-
-type accessManConfig struct {
-	// initAccessPerms checks the channeldb for initial access permissions
-	// and then populates the peerChanInfo and peerScores maps.
-	initAccessPerms func() (map[string]channeldb.ChanCount, error)
-
-	// shouldDisconnect determines whether we should disconnect a peer or
-	// not.
-	shouldDisconnect func(*btcec.PublicKey) (bool, error)
-
-	// maxRestrictedSlots is the number of restricted slots we'll allocate.
-	maxRestrictedSlots int64
-}
-
-func newAccessMan(cfg *accessManConfig) (*accessMan, error) {
-	a := &accessMan{
-		cfg:          cfg,
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	counts, err := a.cfg.initAccessPerms()
-	if err != nil {
-		return nil, err
-	}
-
-	// We'll populate the server's peerChanInfo map with the counts fetched
-	// via initAccessPerms. Also note that we haven't yet connected to the
-	// peers.
-	maps.Copy(a.peerChanInfo, counts)
-
-	acsmLog.Info("Access Manager initialized")
-
-	return a, nil
-}
-
-// hasPeer checks whether a given peer already exists in the internal maps.
-func (a *accessMan) hasPeer(ctx context.Context,
-	pub string) (peerAccessStatus, bool) {
-
-	// Lock banScoreMtx for reading so that we can read the banning maps
-	// below.
-	a.banScoreMtx.RLock()
-	defer a.banScoreMtx.RUnlock()
-
-	count, found := a.peerChanInfo[pub]
-	if found {
-		if count.HasOpenOrClosedChan {
-			acsmLog.DebugS(ctx, "Peer has open/closed channel, "+
-				"assigning protected access")
-
-			// Exit early if the peer is no longer restricted.
-			return peerStatusProtected, true
-		}
-
-		if count.PendingOpenCount != 0 {
-			acsmLog.DebugS(ctx, "Peer has pending channel(s), "+
-				"assigning temporary access")
-
-			// Exit early if the peer is no longer restricted.
-			return peerStatusTemporary, true
-		}
-
-		return peerStatusRestricted, true
-	}
-
-	// Check if the peer is found in the scores map.
-	status, found := a.peerScores[pub]
-	if found {
-		acsmLog.DebugS(ctx, "Peer already has access", "access",
-			status.state)
-
-		return status.state, true
-	}
-
-	return peerStatusRestricted, false
-}
-
-// assignPeerPerms assigns a new peer its permissions. This does not track the
-// access in the maps. This is intentional.
-func (a *accessMan) assignPeerPerms(remotePub *btcec.PublicKey) (
-	peerAccessStatus, error) {
-
-	ctx := btclog.WithCtx(
-		context.TODO(), lnutils.LogPubKey("peer", remotePub),
-	)
-
-	peerMapKey := string(remotePub.SerializeCompressed())
-
-	acsmLog.DebugS(ctx, "Assigning permissions")
-
-	// Default is restricted unless the below filters say otherwise.
-	access, peerExist := a.hasPeer(ctx, peerMapKey)
-
-	// Exit early if the peer is not restricted.
-	if access != peerStatusRestricted {
-		return access, nil
-	}
-
-	// If we are here, it means the peer has peerStatusRestricted.
-	//
-	// Check whether this peer is banned.
-	shouldDisconnect, err := a.cfg.shouldDisconnect(remotePub)
-	if err != nil {
-		acsmLog.ErrorS(ctx, "Error checking disconnect status", err)
-
-		// Access is restricted here.
-		return access, err
-	}
-
-	if shouldDisconnect {
-		acsmLog.WarnS(ctx, "Peer is banned, assigning restricted access",
-			ErrGossiperBan)
-
-		// Access is restricted here.
-		return access, ErrGossiperBan
-	}
-
-	// If we've reached this point and access hasn't changed from
-	// restricted, then we need to check if we even have a slot for this
-	// peer.
-	acsmLog.DebugS(ctx, "Peer has no channels, assigning restricted access")
-
-	// If this is an existing peer, there's no need to check for slot limit.
-	if peerExist {
-		acsmLog.DebugS(ctx, "Skipped slot check for existing peer")
-		return access, nil
-	}
-
-	a.banScoreMtx.RLock()
-	defer a.banScoreMtx.RUnlock()
-
-	if a.numRestricted >= a.cfg.maxRestrictedSlots {
-		acsmLog.WarnS(ctx, "No more restricted slots available, "+
-			"denying peer", ErrNoMoreRestrictedAccessSlots,
-			"num_restricted", a.numRestricted, "max_restricted",
-			a.cfg.maxRestrictedSlots)
-
-		return access, ErrNoMoreRestrictedAccessSlots
-	}
-
-	return access, nil
-}
-
-// newPendingOpenChan is called after the pending-open channel has been
-// committed to the database. This may transition a restricted-access peer to a
-// temporary-access peer.
-func (a *accessMan) newPendingOpenChan(remotePub *btcec.PublicKey) error {
-	a.banScoreMtx.Lock()
-	defer a.banScoreMtx.Unlock()
-
-	ctx := btclog.WithCtx(
-		context.TODO(), lnutils.LogPubKey("peer", remotePub),
-	)
-
-	acsmLog.DebugS(ctx, "Processing new pending open channel")
-
-	peerMapKey := string(remotePub.SerializeCompressed())
-
-	// Fetch the peer's access status from peerScores.
-	status, found := a.peerScores[peerMapKey]
-	if !found {
-		acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)
-
-		// If we didn't find the peer, we'll return an error.
-		return ErrNoPeerScore
-	}
-
-	switch status.state {
-	case peerStatusProtected:
-		acsmLog.DebugS(ctx, "Peer already protected, no change")
-
-		// If this peer's access status is protected, we don't need to
-		// do anything.
-		return nil
-
-	case peerStatusTemporary:
-		// If this peer's access status is temporary, we'll need to
-		// update the peerChanInfo map. The peer's access status will
-		// stay temporary.
-		peerCount, found := a.peerChanInfo[peerMapKey]
-		if !found {
-			// Error if we did not find any info in peerChanInfo.
-			acsmLog.ErrorS(ctx, "Pending peer info not found",
-				ErrNoPendingPeerInfo)
-
-			return ErrNoPendingPeerInfo
-		}
-
-		// Increment the pending channel amount.
-		peerCount.PendingOpenCount += 1
-		a.peerChanInfo[peerMapKey] = peerCount
-
-		acsmLog.DebugS(ctx, "Peer is temporary, incremented "+
-			"pending count",
-			"pending_count", peerCount.PendingOpenCount)
-
-	case peerStatusRestricted:
-		// If the peer's access status is restricted, then we can
-		// transition it to a temporary-access peer. We'll need to
-		// update numRestricted and also peerScores. We'll also need to
-		// update peerChanInfo.
-		peerCount := channeldb.ChanCount{
-			HasOpenOrClosedChan: false,
-			PendingOpenCount:    1,
-		}
-
-		a.peerChanInfo[peerMapKey] = peerCount
-
-		// A restricted-access slot has opened up.
-		oldRestricted := a.numRestricted
-		a.numRestricted -= 1
-
-		a.peerScores[peerMapKey] = peerSlotStatus{
-			state: peerStatusTemporary,
-		}
-
-		acsmLog.InfoS(ctx, "Peer transitioned restricted -> "+
-			"temporary (pending open)",
-			"old_restricted", oldRestricted,
-			"new_restricted", a.numRestricted)
-
-	default:
-		// This should not be possible.
-		err := fmt.Errorf("invalid peer access status %v for %x",
-			status.state, peerMapKey)
-		acsmLog.ErrorS(ctx, "Invalid peer access status", err)
-
-		return err
-	}
-
-	return nil
-}
-
-// newPendingCloseChan is called when a pending-open channel prematurely closes
-// before the funding transaction has confirmed. This potentially demotes a
-// temporary-access peer to a restricted-access peer. If no restricted-access
-// slots are available, the peer will be disconnected.
-func (a *accessMan) newPendingCloseChan(remotePub *btcec.PublicKey) error {
-	a.banScoreMtx.Lock()
-	defer a.banScoreMtx.Unlock()
-
-	ctx := btclog.WithCtx(
-		context.TODO(), lnutils.LogPubKey("peer", remotePub),
-	)
-
-	acsmLog.DebugS(ctx, "Processing pending channel close")
-
-	peerMapKey := string(remotePub.SerializeCompressed())
-
-	// Fetch the peer's access status from peerScores.
-	status, found := a.peerScores[peerMapKey]
-	if !found {
-		acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)
-
-		return ErrNoPeerScore
-	}
-
-	switch status.state {
-	case peerStatusProtected:
-		// If this peer is protected, we don't do anything.
-		acsmLog.DebugS(ctx, "Peer is protected, no change")
-
-		return nil
-
-	case peerStatusTemporary:
-		// If this peer is temporary, we need to check if it will
-		// revert to a restricted-access peer.
-		peerCount, found := a.peerChanInfo[peerMapKey]
-		if !found {
-			acsmLog.ErrorS(ctx, "Pending peer info not found",
-				ErrNoPendingPeerInfo)
-
-			// Error if we did not find any info in peerChanInfo.
-			return ErrNoPendingPeerInfo
-		}
-
-		currentNumPending := peerCount.PendingOpenCount - 1
-
-		acsmLog.DebugS(ctx, "Peer is temporary, decrementing "+
-			"pending count",
-			"pending_count", currentNumPending)
-
-		if currentNumPending == 0 {
-			// Remove the entry from peerChanInfo.
-			delete(a.peerChanInfo, peerMapKey)
-
-			// If this is the only pending-open channel for this
-			// peer and it's getting removed, attempt to demote
-			// this peer to a restricted peer.
-			if a.numRestricted == a.cfg.maxRestrictedSlots {
-				// There are no available restricted slots, so
-				// we need to disconnect this peer. We leave
-				// this up to the caller.
-				acsmLog.WarnS(ctx, "Peer last pending "+
-					"channel closed: ",
-					ErrNoMoreRestrictedAccessSlots,
-					"num_restricted", a.numRestricted,
-					"max_restricted", a.cfg.maxRestrictedSlots)
-
-				return ErrNoMoreRestrictedAccessSlots
-			}
-
-			// Otherwise, there is an available restricted-access
-			// slot, so we can demote this peer.
-			a.peerScores[peerMapKey] = peerSlotStatus{
-				state: peerStatusRestricted,
-			}
-
-			// Update numRestricted.
-			oldRestricted := a.numRestricted
-			a.numRestricted++
-
-			acsmLog.InfoS(ctx, "Peer transitioned "+
-				"temporary -> restricted "+
-				"(last pending closed)",
-				"old_restricted", oldRestricted,
-				"new_restricted", a.numRestricted)
-
-			return nil
-		}
-
-		// Else, we don't need to demote this peer since it has other
-		// pending-open channels with us.
-		peerCount.PendingOpenCount = currentNumPending
-		a.peerChanInfo[peerMapKey] = peerCount
-
-		acsmLog.DebugS(ctx, "Peer still has other pending channels",
-			"pending_count", currentNumPending)
-
-		return nil
-
-	case peerStatusRestricted:
-		// This should not be possible. This indicates an error.
-		err := fmt.Errorf("invalid peer access state transition: "+
-			"pending close for restricted peer %x", peerMapKey)
-		acsmLog.ErrorS(ctx, "Invalid peer access state transition", err)
-
-		return err
-
-	default:
-		// This should not be possible.
-		err := fmt.Errorf("invalid peer access status %v for %x",
-			status.state, peerMapKey)
-		acsmLog.ErrorS(ctx, "Invalid peer access status", err)
-
-		return err
-	}
-}
-
-// newOpenChan is called when a pending-open channel becomes an open channel
-// (i.e. the funding transaction has confirmed). If the remote peer is a
-// temporary-access peer, it will be promoted to a protected-access peer.
-func (a *accessMan) newOpenChan(remotePub *btcec.PublicKey) error {
-	a.banScoreMtx.Lock()
-	defer a.banScoreMtx.Unlock()
-
-	ctx := btclog.WithCtx(
-		context.TODO(), lnutils.LogPubKey("peer", remotePub),
-	)
-
-	acsmLog.DebugS(ctx, "Processing new open channel")
-
-	peerMapKey := string(remotePub.SerializeCompressed())
-
-	// Fetch the peer's access status from peerScores.
-	status, found := a.peerScores[peerMapKey]
-	if !found {
-		// If we didn't find the peer, we'll return an error.
-		acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)
-
-		return ErrNoPeerScore
-	}
-
-	switch status.state {
-	case peerStatusProtected:
-		acsmLog.DebugS(ctx, "Peer already protected, no change")
-
-		// If the peer's state is already protected, we don't need to do
-		// anything more.
-		return nil
-
-	case peerStatusTemporary:
-		// If the peer's state is temporary, we'll upgrade the peer to
-		// a protected peer.
-		peerCount, found := a.peerChanInfo[peerMapKey]
-		if !found {
-			// Error if we did not find any info in peerChanInfo.
-			acsmLog.ErrorS(ctx, "Pending peer info not found",
-				ErrNoPendingPeerInfo)
-
-			return ErrNoPendingPeerInfo
-		}
-
-		peerCount.HasOpenOrClosedChan = true
-		peerCount.PendingOpenCount -= 1
-
-		a.peerChanInfo[peerMapKey] = peerCount
-
-		newStatus := peerSlotStatus{
-			state: peerStatusProtected,
-		}
-		a.peerScores[peerMapKey] = newStatus
-
-		acsmLog.InfoS(ctx, "Peer transitioned temporary -> "+
-			"protected (channel opened)")
-
-		return nil
-
-	case peerStatusRestricted:
-		// This should not be possible. For the server to receive a
-		// state-transition event via NewOpenChan, the server must have
-		// previously granted this peer "temporary" access. This
-		// temporary access would not have been revoked or downgraded
-		// without `CloseChannel` being called with the pending
-		// argument set to true. This means that an open-channel state
-		// transition would be impossible. Therefore, we can return an
-		// error.
-		err := fmt.Errorf("invalid peer access status: new open "+
-			"channel for restricted peer %x", peerMapKey)
-
-		acsmLog.ErrorS(ctx, "Invalid peer access status", err)
-
-		return err
-
-	default:
-		// This should not be possible.
-		err := fmt.Errorf("invalid peer access status %v for %x",
-			status.state, peerMapKey)
-
-		acsmLog.ErrorS(ctx, "Invalid peer access status", err)
-
-		return err
-	}
-}
-
-// checkAcceptIncomingConn checks whether, given the remote's public hex-
-// encoded key, we should not accept this incoming connection or immediately
-// disconnect. This does not assign to the server's peerScores maps. This is
-// just an inbound filter that the brontide listeners use.
-//
-// TODO(yy): We should also consider removing this `checkAcceptIncomingConn`
-// check as a) it doesn't check for ban score; and b) we should, and already
-// have this check when we handle incoming connection in `InboundPeerConnected`.
-func (a *accessMan) checkAcceptIncomingConn(remotePub *btcec.PublicKey) (
-	bool, error) {
-
-	ctx := btclog.WithCtx(
-		context.TODO(), lnutils.LogPubKey("peer", remotePub),
-	)
-
-	peerMapKey := string(remotePub.SerializeCompressed())
-
-	acsmLog.TraceS(ctx, "Checking incoming connection ban score")
-
-	a.banScoreMtx.RLock()
-	defer a.banScoreMtx.RUnlock()
-
-	_, found := a.peerChanInfo[peerMapKey]
-
-	// Exit early if found.
-	if found {
-		acsmLog.DebugS(ctx, "Peer found (protected/temporary), "+
-			"accepting")
-
-		return true, nil
-	}
-
-	_, found = a.peerScores[peerMapKey]
-
-	// Exit early if found.
-	if found {
-		acsmLog.DebugS(ctx, "Found existing peer, accepting")
-
-		return true, nil
-	}
-
-	acsmLog.DebugS(ctx, "Peer not found in counts, checking restricted "+
-		"slots")
-
-	// Check numRestricted to see if there is an available slot. In
-	// the future, it's possible to add better heuristics.
-	if a.numRestricted < a.cfg.maxRestrictedSlots {
-		// There is an available slot.
-		acsmLog.DebugS(ctx, "Restricted slot available, accepting ",
-			"num_restricted", a.numRestricted, "max_restricted",
-			a.cfg.maxRestrictedSlots)
-
-		return true, nil
-	}
-
-	// If there are no slots left, then we reject this connection.
-	acsmLog.WarnS(ctx, "No restricted slots available, rejecting ",
-		ErrNoMoreRestrictedAccessSlots, "num_restricted",
-		a.numRestricted, "max_restricted", a.cfg.maxRestrictedSlots)
-
-	return false, ErrNoMoreRestrictedAccessSlots
-}
-
-// addPeerAccess tracks a peer's access in the maps. This should be called when
-// the peer has fully connected.
-func (a *accessMan) addPeerAccess(remotePub *btcec.PublicKey,
-	access peerAccessStatus, inbound bool) {
-
-	ctx := btclog.WithCtx(
-		context.TODO(), lnutils.LogPubKey("peer", remotePub),
-	)
-
-	acsmLog.DebugS(ctx, "Adding peer access", "access", access)
-
-	// Add the remote public key to peerScores.
-	a.banScoreMtx.Lock()
-	defer a.banScoreMtx.Unlock()
-
-	peerMapKey := string(remotePub.SerializeCompressed())
-
-	// Exit early if this is an existing peer, which means it won't take
-	// another slot.
-	_, found := a.peerScores[peerMapKey]
-	if found {
-		acsmLog.DebugS(ctx, "Skipped taking restricted slot for "+
-			"existing peer")
-
-		return
-	}
-
-	a.peerScores[peerMapKey] = peerSlotStatus{state: access}
-
-	// Exit early if this is not a restricted peer.
-	if access != peerStatusRestricted {
-		acsmLog.DebugS(ctx, "Skipped taking restricted slot as peer "+
-			"already has access", "access", access)
-
-		return
-	}
-
-	// Increment numRestricted if this is an inbound connection.
-	if inbound {
-		oldRestricted := a.numRestricted
-		a.numRestricted++
-
-		acsmLog.DebugS(ctx, "Incremented restricted slots",
-			"old_restricted", oldRestricted,
-			"new_restricted", a.numRestricted)
-
-		return
-	}
-
-	// Otherwise, this is a newly created outbound connection. We won't
-	// place any restriction on it, instead, we will do a hot upgrade here
-	// to move it from restricted to temporary.
-	peerCount := channeldb.ChanCount{
-		HasOpenOrClosedChan: false,
-		PendingOpenCount:    0,
-	}
-
-	a.peerChanInfo[peerMapKey] = peerCount
-	a.peerScores[peerMapKey] = peerSlotStatus{
-		state: peerStatusTemporary,
-	}
-
-	acsmLog.InfoS(ctx, "Upgraded outbound peer: restricted -> temporary")
-}
-
-// removePeerAccess removes the peer's access from the maps. This should be
-// called when the peer has been disconnected.
-func (a *accessMan) removePeerAccess(ctx context.Context, peerPubKey string) {
-	acsmLog.DebugS(ctx, "Removing access:")
-
-	a.banScoreMtx.Lock()
-	defer a.banScoreMtx.Unlock()
-
-	status, found := a.peerScores[peerPubKey]
-	if !found {
-		acsmLog.InfoS(ctx, "Peer score not found during removal")
-		return
-	}
-
-	if status.state == peerStatusRestricted {
-		// If the status is restricted, then we decrement from
-		// numRestrictedSlots.
-		oldRestricted := a.numRestricted
-		a.numRestricted--
-
-		acsmLog.DebugS(ctx, "Decremented restricted slots",
-			"old_restricted", oldRestricted,
-			"new_restricted", a.numRestricted)
-	}
-
-	acsmLog.TraceS(ctx, "Deleting from peerScores:")
-
-	delete(a.peerScores, peerPubKey)
-
-	// We now check whether this peer has channels with us or not.
-	info, found := a.peerChanInfo[peerPubKey]
-	if !found {
-		acsmLog.DebugS(ctx, "Chan info not found during removal:")
-		return
-	}
-
-	// Exit early if the peer has channel(s) with us.
-	if info.HasOpenOrClosedChan {
-		acsmLog.DebugS(ctx, "Skipped removing peer with channels:")
-		return
-	}
-
-	// Skip removing the peer if it has pending open/close with us.
-	if info.PendingOpenCount != 0 {
-		acsmLog.DebugS(ctx, "Skipped removing peer with pending "+
-			"channels:")
-		return
-	}
-
-	// Given this peer has no channels with us, we can now remove it.
-	delete(a.peerChanInfo, peerPubKey)
-	acsmLog.TraceS(ctx, "Removed peer from peerChanInfo:")
-}

accessman_test.go

@@ -1,814 +0,0 @@
-package lnd
-
-import (
-	"context"
-	"testing"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/stretchr/testify/require"
-)
-
-// assertInboundConnection asserts that we're able to accept an inbound
-// connection successfully without any access permissions being violated.
-func assertInboundConnection(t *testing.T, a *accessMan,
-	remotePub *btcec.PublicKey, status peerAccessStatus) {
-
-	remotePubSer := string(remotePub.SerializeCompressed())
-
-	isSlotAvailable, err := a.checkAcceptIncomingConn(remotePub)
-	require.NoError(t, err)
-	require.True(t, isSlotAvailable)
-
-	peerAccess, err := a.assignPeerPerms(remotePub)
-	require.NoError(t, err)
-	require.Equal(t, status, peerAccess)
-
-	a.addPeerAccess(remotePub, peerAccess, true)
-	peerScore, ok := a.peerScores[remotePubSer]
-	require.True(t, ok)
-	require.Equal(t, status, peerScore.state)
-}
-
-func assertAccessState(t *testing.T, a *accessMan, remotePub *btcec.PublicKey,
-	expectedStatus peerAccessStatus) {
-
-	remotePubSer := string(remotePub.SerializeCompressed())
-	peerScore, ok := a.peerScores[remotePubSer]
-	require.True(t, ok)
-	require.Equal(t, expectedStatus, peerScore.state)
-}
-
-// TestAccessManRestrictedSlots tests that the configurable number of
-// restricted slots are properly allocated. It also tests that certain peers
-// with access permissions are allowed to bypass the slot mechanism.
-func TestAccessManRestrictedSlots(t *testing.T) {
-	t.Parallel()
-
-	// We'll pre-populate the map to mock the database fetch. We'll make
-	// three peers. One has an open/closed channel. One has both an open
-	// / closed channel and a pending channel. The last one has only a
-	// pending channel.
-	peerPriv1, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	peerKey1 := peerPriv1.PubKey()
-	peerKeySer1 := string(peerKey1.SerializeCompressed())
-
-	peerPriv2, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	peerKey2 := peerPriv2.PubKey()
-	peerKeySer2 := string(peerKey2.SerializeCompressed())
-
-	peerPriv3, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	peerKey3 := peerPriv3.PubKey()
-	peerKeySer3 := string(peerKey3.SerializeCompressed())
-
-	var (
-		peer1PendingCount = 0
-		peer2PendingCount = 1
-		peer3PendingCount = 1
-	)
-
-	initPerms := func() (map[string]channeldb.ChanCount, error) {
-		return map[string]channeldb.ChanCount{
-			peerKeySer1: {
-				HasOpenOrClosedChan: true,
-				PendingOpenCount:    uint64(peer1PendingCount),
-			},
-			peerKeySer2: {
-				HasOpenOrClosedChan: true,
-				PendingOpenCount:    uint64(peer2PendingCount),
-			},
-			peerKeySer3: {
-				HasOpenOrClosedChan: false,
-				PendingOpenCount:    uint64(peer3PendingCount),
-			},
-		}, nil
-	}
-
-	disconnect := func(*btcec.PublicKey) (bool, error) {
-		return false, nil
-	}
-
-	cfg := &accessManConfig{
-		initAccessPerms:    initPerms,
-		shouldDisconnect:   disconnect,
-		maxRestrictedSlots: 1,
-	}
-
-	a, err := newAccessMan(cfg)
-	require.NoError(t, err)
-
-	// Check that the peerChanInfo map is correctly populated with three
-	// peers.
-	require.Equal(t, 0, int(a.numRestricted))
-	require.Equal(t, 3, len(a.peerChanInfo))
-
-	peerCount1, ok := a.peerChanInfo[peerKeySer1]
-	require.True(t, ok)
-	require.True(t, peerCount1.HasOpenOrClosedChan)
-	require.Equal(t, peer1PendingCount, int(peerCount1.PendingOpenCount))
-
-	peerCount2, ok := a.peerChanInfo[peerKeySer2]
-	require.True(t, ok)
-	require.True(t, peerCount2.HasOpenOrClosedChan)
-	require.Equal(t, peer2PendingCount, int(peerCount2.PendingOpenCount))
-
-	peerCount3, ok := a.peerChanInfo[peerKeySer3]
-	require.True(t, ok)
-	require.False(t, peerCount3.HasOpenOrClosedChan)
-	require.Equal(t, peer3PendingCount, int(peerCount3.PendingOpenCount))
-
-	// We'll now start to connect the peers. We'll add a new fourth peer
-	// that will take up the restricted slot. The first three peers should
-	// be able to bypass this restricted slot mechanism.
-	peerPriv4, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	peerKey4 := peerPriv4.PubKey()
-
-	// Follow the normal process of an incoming connection. We check if we
-	// can accommodate this peer in checkAcceptIncomingConn and then we
-	// assign its access permissions and then insert into the map.
-	assertInboundConnection(t, a, peerKey4, peerStatusRestricted)
-
-	// Connect the three peers. This should happen without any issue.
-	assertInboundConnection(t, a, peerKey1, peerStatusProtected)
-	assertInboundConnection(t, a, peerKey2, peerStatusProtected)
-	assertInboundConnection(t, a, peerKey3, peerStatusTemporary)
-
-	// Check that a pending-open channel promotes the restricted peer.
-	err = a.newPendingOpenChan(peerKey4)
-	require.NoError(t, err)
-	assertAccessState(t, a, peerKey4, peerStatusTemporary)
-
-	// Assert that accessman's internal state is updated with peer4. We
-	// expect this new peer to have 1 pending open count.
-	peerCount4, ok := a.peerChanInfo[string(peerKey4.SerializeCompressed())]
-	require.True(t, ok)
-	require.False(t, peerCount4.HasOpenOrClosedChan)
-	require.Equal(t, 1, int(peerCount4.PendingOpenCount))
-
-	// Check that an open channel promotes the temporary peer.
-	err = a.newOpenChan(peerKey3)
-	require.NoError(t, err)
-	assertAccessState(t, a, peerKey3, peerStatusProtected)
-
-	// Assert that accessman's internal state is updated with peer3. We
-	// expect this existing peer to decrement its pending open count and the
-	// flag `HasOpenOrClosedChan` should be true.
-	peerCount3, ok = a.peerChanInfo[peerKeySer3]
-	require.True(t, ok)
-	require.True(t, peerCount3.HasOpenOrClosedChan)
-	require.Equal(t, peer3PendingCount-1, int(peerCount3.PendingOpenCount))
-
-	// We should be able to accommodate a new peer.
-	peerPriv5, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	peerKey5 := peerPriv5.PubKey()
-
-	assertInboundConnection(t, a, peerKey5, peerStatusRestricted)
-
-	// Check that a pending-close channel event for peer 4 demotes the
-	// peer.
-	err = a.newPendingCloseChan(peerKey4)
-	require.ErrorIs(t, err, ErrNoMoreRestrictedAccessSlots)
-
-	// Assert that peer4 is removed.
-	_, ok = a.peerChanInfo[string(peerKey4.SerializeCompressed())]
-	require.False(t, ok)
-}
-
-// TestAssignPeerPerms asserts that the peer's access status is correctly
-// assigned.
-func TestAssignPeerPerms(t *testing.T) {
-	t.Parallel()
-
-	// genPeerPub is a helper closure that generates a random public key.
-	genPeerPub := func() *btcec.PublicKey {
-		peerPriv, err := btcec.NewPrivateKey()
-		require.NoError(t, err)
-
-		return peerPriv.PubKey()
-	}
-
-	disconnect := func(_ *btcec.PublicKey) (bool, error) {
-		return true, nil
-	}
-
-	noDisconnect := func(_ *btcec.PublicKey) (bool, error) {
-		return false, nil
-	}
-
-	var testCases = []struct {
-		name             string
-		peerPub          *btcec.PublicKey
-		chanCount        channeldb.ChanCount
-		shouldDisconnect func(*btcec.PublicKey) (bool, error)
-		numRestricted    int
-
-		expectedStatus peerAccessStatus
-		expectedErr    error
-	}{
-		// peer1 has a channel with us, and we expect it to have a
-		// protected status.
-		{
-			name:    "peer with channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: true,
-			},
-			shouldDisconnect: noDisconnect,
-			expectedStatus:   peerStatusProtected,
-			expectedErr:      nil,
-		},
-		// peer2 has a channel open and a pending channel with us, we
-		// expect it to have a protected status.
-		{
-			name:    "peer with channels and pending channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: true,
-				PendingOpenCount:    1,
-			},
-			shouldDisconnect: noDisconnect,
-			expectedStatus:   peerStatusProtected,
-			expectedErr:      nil,
-		},
-		// peer3 has a pending channel with us, and we expect it to have
-		// a temporary status.
-		{
-			name:    "peer with pending channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: false,
-				PendingOpenCount:    1,
-			},
-			shouldDisconnect: noDisconnect,
-			expectedStatus:   peerStatusTemporary,
-			expectedErr:      nil,
-		},
-		// peer4 has no channel with us, and we expect it to have a
-		// restricted status.
-		{
-			name:    "peer with no channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: false,
-				PendingOpenCount:    0,
-			},
-			shouldDisconnect: noDisconnect,
-			expectedStatus:   peerStatusRestricted,
-			expectedErr:      nil,
-		},
-		// peer5 has no channel with us, and we expect it to have a
-		// restricted status. We also expect the error `ErrGossiperBan`
-		// to be returned given we will use a mocked `shouldDisconnect`
-		// in this test to disconnect on peer5 only.
-		{
-			name:    "peer with no channels and banned",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: false,
-				PendingOpenCount:    0,
-			},
-			shouldDisconnect: disconnect,
-			expectedStatus:   peerStatusRestricted,
-			expectedErr:      ErrGossiperBan,
-		},
-		// peer6 has no channel with us, and we expect it to have a
-		// restricted status. Since this peer is seen, we don't expect
-		// the error `ErrNoMoreRestrictedAccessSlots` to be returned.
-		{
-			name:    "peer with no channels and restricted",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: false,
-				PendingOpenCount:    0,
-			},
-			shouldDisconnect: noDisconnect,
-			numRestricted:    1,
-
-			expectedStatus: peerStatusRestricted,
-			expectedErr:    nil,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			peerStr := string(tc.peerPub.SerializeCompressed())
-
-			initPerms := func() (map[string]channeldb.ChanCount,
-				error) {
-
-				return map[string]channeldb.ChanCount{
-					peerStr: tc.chanCount,
-				}, nil
-			}
-
-			cfg := &accessManConfig{
-				initAccessPerms:    initPerms,
-				shouldDisconnect:   tc.shouldDisconnect,
-				maxRestrictedSlots: 1,
-			}
-
-			a, err := newAccessMan(cfg)
-			require.NoError(t, err)
-
-			// Initialize the internal state of the accessman.
-			a.numRestricted = int64(tc.numRestricted)
-
-			status, err := a.assignPeerPerms(tc.peerPub)
-			require.Equal(t, tc.expectedStatus, status)
-			require.ErrorIs(t, tc.expectedErr, err)
-		})
-	}
-}
-
-// TestAssignPeerPermsBypassRestriction asserts that when a peer has a channel
-// with us, either it being open, pending, or closed, no restriction is placed
-// on this peer.
-func TestAssignPeerPermsBypassRestriction(t *testing.T) {
-	t.Parallel()
-
-	// genPeerPub is a helper closure that generates a random public key.
-	genPeerPub := func() *btcec.PublicKey {
-		peerPriv, err := btcec.NewPrivateKey()
-		require.NoError(t, err)
-
-		return peerPriv.PubKey()
-	}
-
-	// Mock shouldDisconnect to always return true and assert that it has no
-	// effect on the peer.
-	disconnect := func(_ *btcec.PublicKey) (bool, error) {
-		return true, nil
-	}
-
-	var testCases = []struct {
-		name           string
-		peerPub        *btcec.PublicKey
-		chanCount      channeldb.ChanCount
-		expectedStatus peerAccessStatus
-	}{
-		// peer1 has a channel with us, and we expect it to have a
-		// protected status.
-		{
-			name:    "peer with channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: true,
-			},
-			expectedStatus: peerStatusProtected,
-		},
-		// peer2 has a channel open and a pending channel with us, we
-		// expect it to have a protected status.
-		{
-			name:    "peer with channels and pending channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: true,
-				PendingOpenCount:    1,
-			},
-			expectedStatus: peerStatusProtected,
-		},
-		// peer3 has a pending channel with us, and we expect it to have
-		// a temporary status.
-		{
-			name:    "peer with pending channels",
-			peerPub: genPeerPub(),
-			chanCount: channeldb.ChanCount{
-				HasOpenOrClosedChan: false,
-				PendingOpenCount:    1,
-			},
-			expectedStatus: peerStatusTemporary,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			peerStr := string(tc.peerPub.SerializeCompressed())
-
-			initPerms := func() (map[string]channeldb.ChanCount,
-				error) {
-
-				return map[string]channeldb.ChanCount{
-					peerStr: tc.chanCount,
-				}, nil
-			}
-
-			// Config the accessman such that it has zero max slots
-			// and always return true on `shouldDisconnect`. We
-			// should see the peers in this test are not affected by
-			// these checks.
-			cfg := &accessManConfig{
-				initAccessPerms:    initPerms,
-				shouldDisconnect:   disconnect,
-				maxRestrictedSlots: 0,
-			}
-
-			a, err := newAccessMan(cfg)
-			require.NoError(t, err)
-
-			status, err := a.assignPeerPerms(tc.peerPub)
-			require.NoError(t, err)
-			require.Equal(t, tc.expectedStatus, status)
-		})
-	}
-}
-
-// TestAssignPeerPermsBypassExisting asserts that when the peer is a
-// pre-existing peer, it won't be restricted.
-func TestAssignPeerPermsBypassExisting(t *testing.T) {
-	t.Parallel()
-
-	// genPeerPub is a helper closure that generates a random public key.
-	genPeerPub := func() *btcec.PublicKey {
-		peerPriv, err := btcec.NewPrivateKey()
-		require.NoError(t, err)
-
-		return peerPriv.PubKey()
-	}
-
-	// peer1 exists in `peerChanInfo` map.
-	peer1 := genPeerPub()
-	peer1Str := string(peer1.SerializeCompressed())
-
-	// peer2 exists in `peerScores` map.
-	peer2 := genPeerPub()
-	peer2Str := string(peer2.SerializeCompressed())
-
-	// peer3 is a new peer.
-	peer3 := genPeerPub()
-
-	// Create params to init the accessman.
-	initPerms := func() (map[string]channeldb.ChanCount, error) {
-		return map[string]channeldb.ChanCount{
-			peer1Str: {},
-		}, nil
-	}
-
-	disconnect := func(*btcec.PublicKey) (bool, error) {
-		return false, nil
-	}
-
-	cfg := &accessManConfig{
-		initAccessPerms:    initPerms,
-		shouldDisconnect:   disconnect,
-		maxRestrictedSlots: 0,
-	}
-
-	a, err := newAccessMan(cfg)
-	require.NoError(t, err)
-
-	// Add peer2 to the `peerScores`.
-	a.peerScores[peer2Str] = peerSlotStatus{
-		state: peerStatusTemporary,
-	}
-
-	// Assigning to peer1 should not return an error.
-	status, err := a.assignPeerPerms(peer1)
-	require.NoError(t, err)
-	require.Equal(t, peerStatusRestricted, status)
-
-	// Assigning to peer2 should not return an error.
-	status, err = a.assignPeerPerms(peer2)
-	require.NoError(t, err)
-	require.Equal(t, peerStatusTemporary, status)
-
-	// Assigning to peer3 should return an error.
-	status, err = a.assignPeerPerms(peer3)
-	require.ErrorIs(t, err, ErrNoMoreRestrictedAccessSlots)
-	require.Equal(t, peerStatusRestricted, status)
-}
-
-// TestHasPeer asserts `hasPeer` returns the correct results.
-func TestHasPeer(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-
-	// Create a testing accessMan.
-	a := &accessMan{
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	// peer1 exists with an open channel.
-	peer1 := "peer1"
-	a.peerChanInfo[peer1] = channeldb.ChanCount{
-		HasOpenOrClosedChan: true,
-	}
-	peer1Access := peerStatusProtected
-
-	// peer2 exists with a pending channel.
-	peer2 := "peer2"
-	a.peerChanInfo[peer2] = channeldb.ChanCount{
-		PendingOpenCount: 1,
-	}
-	peer2Access := peerStatusTemporary
-
-	// peer3 exists without any channels.
-	peer3 := "peer3"
-	a.peerChanInfo[peer3] = channeldb.ChanCount{}
-	peer3Access := peerStatusRestricted
-
-	// peer4 exists with a score.
-	peer4 := "peer4"
-	peer4Access := peerStatusTemporary
-	a.peerScores[peer4] = peerSlotStatus{state: peer4Access}
-
-	// peer5 doesn't exist.
-	peer5 := "peer5"
-
-	// We now assert `hasPeer` returns the correct results.
-	//
-	// peer1 should be found with peerStatusProtected.
-	access, found := a.hasPeer(ctx, peer1)
-	require.True(t, found)
-	require.Equal(t, peer1Access, access)
-
-	// peer2 should be found with peerStatusTemporary.
-	access, found = a.hasPeer(ctx, peer2)
-	require.True(t, found)
-	require.Equal(t, peer2Access, access)
-
-	// peer3 should be found with peerStatusRestricted.
-	access, found = a.hasPeer(ctx, peer3)
-	require.True(t, found)
-	require.Equal(t, peer3Access, access)
-
-	// peer4 should be found with peerStatusTemporary.
-	access, found = a.hasPeer(ctx, peer4)
-	require.True(t, found)
-	require.Equal(t, peer4Access, access)
-
-	// peer5 should NOT be found.
-	access, found = a.hasPeer(ctx, peer5)
-	require.False(t, found)
-	require.Equal(t, peerStatusRestricted, access)
-}
-
-// TestAddPeerAccessInbound asserts the num of slots is correctly incremented
-// only for a new inbound peer with restricted access.
-func TestAddPeerAccessInbound(t *testing.T) {
-	t.Parallel()
-
-	// Create a testing accessMan.
-	a := &accessMan{
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	// Create a testing key.
-	priv, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	pub := priv.PubKey()
-	pubStr := string(pub.SerializeCompressed())
-
-	// Add this peer as an inbound peer with peerStatusRestricted.
-	a.addPeerAccess(pub, peerStatusRestricted, true)
-
-	// Assert the accessMan's internal state.
-	//
-	// We expect to see one peer found in the score map, and one slot is
-	// taken, and this peer is not found in the counts map.
-	require.Len(t, a.peerScores, 1)
-	require.Equal(t, int64(1), a.numRestricted)
-	require.NotContains(t, a.peerChanInfo, pubStr)
-
-	// The peer should be found in the score map.
-	score, ok := a.peerScores[pubStr]
-	require.True(t, ok)
-
-	expecedScore := peerSlotStatus{state: peerStatusRestricted}
-	require.Equal(t, expecedScore, score)
-
-	// Add this peer again, we expect the available slots to stay unchanged.
-	a.addPeerAccess(pub, peerStatusRestricted, true)
-
-	// Assert the internal state is not changed.
-	require.Len(t, a.peerScores, 1)
-	require.Equal(t, int64(1), a.numRestricted)
-	require.NotContains(t, a.peerChanInfo, pubStr)
-
-	// Reset the accessMan.
-	a = &accessMan{
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	// Add this peer as an inbound peer with peerStatusTemporary.
-	a.addPeerAccess(pub, peerStatusTemporary, true)
-
-	// Assert the accessMan's internal state.
-	//
-	// We expect to see one peer found in the score map, and no slot is
-	// taken since this peer is not restricted.
-	require.Len(t, a.peerScores, 1)
-	require.Equal(t, int64(0), a.numRestricted)
-
-	// NOTE: in reality this is not possible as the peer must have been put
-	// into the map `peerChanInfo` before its perm can be upgraded.
-	require.NotContains(t, a.peerChanInfo, pubStr)
-
-	// The peer should be found in the score map.
-	score, ok = a.peerScores[pubStr]
-	require.True(t, ok)
-
-	expecedScore = peerSlotStatus{state: peerStatusTemporary}
-	require.Equal(t, expecedScore, score)
-}
-
-// TestAddPeerAccessOutbound asserts that outbound peer is not restricted and
-// its perm is upgraded when it has peerStatusRestricted.
-func TestAddPeerAccessOutbound(t *testing.T) {
-	t.Parallel()
-
-	// Create a testing accessMan.
-	a := &accessMan{
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	// Create a testing key.
-	priv, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	pub := priv.PubKey()
-	pubStr := string(pub.SerializeCompressed())
-
-	// Add this peer as an outbound peer with peerStatusRestricted.
-	a.addPeerAccess(pub, peerStatusRestricted, false)
-
-	// Assert the accessMan's internal state.
-	//
-	// We expect to see one peer found in the score map, and no slot is
-	// taken, and this peer is found in the counts map.
-	require.Len(t, a.peerScores, 1)
-	require.Equal(t, int64(0), a.numRestricted)
-	require.Contains(t, a.peerChanInfo, pubStr)
-
-	// The peer should be found in the score map.
-	score, ok := a.peerScores[pubStr]
-	require.True(t, ok)
-
-	// Its perm should be upgraded to temporary.
-	expecedScore := peerSlotStatus{state: peerStatusTemporary}
-	require.Equal(t, expecedScore, score)
-
-	// The peer should be found in the peer counts map.
-	count, ok := a.peerChanInfo[pubStr]
-	require.True(t, ok)
-
-	// The peer's count should be initialized correctly.
-	require.Zero(t, count.PendingOpenCount)
-	require.False(t, count.HasOpenOrClosedChan)
-
-	// Add this peer again, we expect the available slots to stay unchanged.
-	a.addPeerAccess(pub, peerStatusRestricted, true)
-
-	// Assert the internal state is not changed.
-	require.Len(t, a.peerScores, 1)
-	require.Equal(t, int64(0), a.numRestricted)
-	require.Contains(t, a.peerChanInfo, pubStr)
-
-	// Reset the accessMan.
-	a = &accessMan{
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	// Add this peer as an inbound peer with peerStatusTemporary.
-	a.addPeerAccess(pub, peerStatusTemporary, true)
-
-	// Assert the accessMan's internal state.
-	//
-	// We expect to see one peer found in the score map, and no slot is
-	// taken since this peer is not restricted.
-	require.Len(t, a.peerScores, 1)
-	require.Equal(t, int64(0), a.numRestricted)
-
-	// NOTE: in reality this is not possible as the peer must have been put
-	// into the map `peerChanInfo` before its perm can be upgraded.
-	require.NotContains(t, a.peerChanInfo, pubStr)
-
-	// The peer should be found in the score map.
-	score, ok = a.peerScores[pubStr]
-	require.True(t, ok)
-
-	expecedScore = peerSlotStatus{state: peerStatusTemporary}
-	require.Equal(t, expecedScore, score)
-}
-
-// TestRemovePeerAccess asserts `removePeerAccess` correctly update the
-// accessman's internal state based on the peer's status.
-func TestRemovePeerAccess(t *testing.T) {
-	t.Parallel()
-	ctx := context.Background()
-
-	// Create a testing accessMan.
-	a := &accessMan{
-		peerChanInfo: make(map[string]channeldb.ChanCount),
-		peerScores:   make(map[string]peerSlotStatus),
-	}
-
-	// numRestrictedExpected specifies the final value to expect once the
-	// test finishes.
-	var numRestrictedExpected int
-
-	// peer1 exists with an open channel, which should not be removed. Since
-	// it has protected status, the numRestricted should stay unchanged.
-	peer1 := "peer1"
-	a.peerChanInfo[peer1] = channeldb.ChanCount{
-		HasOpenOrClosedChan: true,
-	}
-	peer1Access := peerStatusProtected
-	a.peerScores[peer1] = peerSlotStatus{state: peer1Access}
-
-	// peer2 exists with a pending channel, which should not be removed.
-	// Since it has temporary status, the numRestricted should stay
-	// unchanged.
-	peer2 := "peer2"
-	a.peerChanInfo[peer2] = channeldb.ChanCount{
-		PendingOpenCount: 1,
-	}
-	peer2Access := peerStatusTemporary
-	a.peerScores[peer2] = peerSlotStatus{state: peer2Access}
-
-	// peer3 exists without any channels, which will be removed. Since it
-	// has restricted status, the numRestricted should be decremented.
-	peer3 := "peer3"
-	a.peerChanInfo[peer3] = channeldb.ChanCount{}
-	peer3Access := peerStatusRestricted
-	a.peerScores[peer3] = peerSlotStatus{state: peer3Access}
-	numRestrictedExpected--
-
-	// peer4 exists with a score and a temporary status, which will be
-	// removed.
-	peer4 := "peer4"
-	peer4Access := peerStatusTemporary
-	a.peerScores[peer4] = peerSlotStatus{state: peer4Access}
-
-	// peer5 doesn't exist, removing it will be a NOOP.
-	peer5 := "peer5"
-
-	// We now assert `removePeerAccess` behaves as expected.
-	//
-	// Remove peer1 should change nothing.
-	a.removePeerAccess(ctx, peer1)
-
-	// peer1 should be removed from peerScores but not peerChanInfo.
-	_, found := a.peerScores[peer1]
-	require.False(t, found)
-	_, found = a.peerChanInfo[peer1]
-	require.True(t, found)
-
-	// Remove peer2 should change nothing.
-	a.removePeerAccess(ctx, peer2)
-
-	// peer2 should be removed from peerScores but not peerChanInfo.
-	_, found = a.peerScores[peer2]
-	require.False(t, found)
-	_, found = a.peerChanInfo[peer2]
-	require.True(t, found)
-
-	// Remove peer3 should remove it from the maps.
-	a.removePeerAccess(ctx, peer3)
-
-	// peer3 should be removed from peerScores and peerChanInfo.
-	_, found = a.peerScores[peer3]
-	require.False(t, found)
-	_, found = a.peerChanInfo[peer3]
-	require.False(t, found)
-
-	// Remove peer4 should remove it from the maps.
-	a.removePeerAccess(ctx, peer4)
-
-	// peer4 should be removed from peerScores and NOT be found in
-	// peerChanInfo.
-	_, found = a.peerScores[peer4]
-	require.False(t, found)
-	_, found = a.peerChanInfo[peer4]
-	require.False(t, found)
-
-	// Remove peer5 should be NOOP.
-	a.removePeerAccess(ctx, peer5)
-
-	// peer5 should NOT be found.
-	_, found = a.peerScores[peer5]
-	require.False(t, found)
-	_, found = a.peerChanInfo[peer5]
-	require.False(t, found)
-
-	// Finally, assert the numRestricted is decremented as expected. Given
-	// we only have peer3 which has restricted access, it should decrement
-	// once.
-	//
-	// NOTE: The value is actually negative here, which is allowed in
-	// accessman.
-	require.EqualValues(t, numRestrictedExpected, a.numRestricted)
-}

aliasmgr/aliasmgr.go

@@ -3,14 +3,13 @@ package aliasmgr
 import (
 	"encoding/binary"
 	"fmt"
-	"maps"
-	"slices"
 	"sync"
 
-	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/htlcswitch/hop"
 	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"golang.org/x/exp/maps"
 )
 
 // UpdateLinkAliases is a function type for a function that locates the active
@@ -433,9 +432,9 @@ func (m *Manager) DeleteLocalAlias(alias,
 	}
 
 	// We'll filter the alias set and remove the alias from it.
-	aliasSet = fn.Filter(aliasSet, func(a lnwire.ShortChannelID) bool {
+	aliasSet = fn.Filter(func(a lnwire.ShortChannelID) bool {
 		return a.ToUint64() != alias.ToUint64()
-	})
+	}, aliasSet)
 
 	// If the alias set is empty, we'll delete the base SCID from the
 	// baseToSet map.
@@ -515,17 +514,11 @@ func (m *Manager) RequestAlias() (lnwire.ShortChannelID, error) {
 	// haveAlias returns true if the passed alias is already assigned to a
 	// channel in the baseToSet map.
 	haveAlias := func(maybeNextAlias lnwire.ShortChannelID) bool {
-		return fn.Any(
-			slices.Collect(maps.Values(m.baseToSet)),
-			func(aliasList []lnwire.ShortChannelID) bool {
-				return fn.Any(
-					aliasList,
-					func(alias lnwire.ShortChannelID) bool {
-						return alias == maybeNextAlias
-					},
-				)
-			},
-		)
+		return fn.Any(func(aliasList []lnwire.ShortChannelID) bool {
+			return fn.Any(func(alias lnwire.ShortChannelID) bool {
+				return alias == maybeNextAlias
+			}, aliasList)
+		}, maps.Values(m.baseToSet))
 	}
 
 	err := kvdb.Update(m.backend, func(tx kvdb.RwTx) error {

aliasmgr/aliasmgr_test.go

@@ -19,7 +19,6 @@ func TestAliasStorePeerAlias(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "testdb")
 	db, err := kvdb.Create(
 		kvdb.BoltBackendName, dbPath, true, kvdb.DefaultDBTimeout,
-		false,
 	)
 	require.NoError(t, err)
 	defer db.Close()
@@ -53,7 +52,6 @@ func TestAliasStoreRequest(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "testdb")
 	db, err := kvdb.Create(
 		kvdb.BoltBackendName, dbPath, true, kvdb.DefaultDBTimeout,
-		false,
 	)
 	require.NoError(t, err)
 	defer db.Close()
@@ -86,7 +84,6 @@ func TestAliasLifecycle(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "testdb")
 	db, err := kvdb.Create(
 		kvdb.BoltBackendName, dbPath, true, kvdb.DefaultDBTimeout,
-		false,
 	)
 	require.NoError(t, err)
 	defer db.Close()

autopilot/agent.go

@@ -2,7 +2,6 @@ package autopilot
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"math/rand"
 	"net"
@@ -12,7 +11,6 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/davecgh/go-spew/spew"
-	"github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
 
@@ -168,9 +166,8 @@ type Agent struct {
 	pendingOpens map[NodeID]LocalChannel
 	pendingMtx   sync.Mutex
 
-	quit   chan struct{}
-	wg     sync.WaitGroup
-	cancel fn.Option[context.CancelFunc]
+	quit chan struct{}
+	wg   sync.WaitGroup
 }
 
 // New creates a new instance of the Agent instantiated using the passed
@@ -205,20 +202,17 @@ func New(cfg Config, initialState []LocalChannel) (*Agent, error) {
 func (a *Agent) Start() error {
 	var err error
 	a.started.Do(func() {
-		ctx, cancel := context.WithCancel(context.Background())
-		a.cancel = fn.Some(cancel)
-
-		err = a.start(ctx)
+		err = a.start()
 	})
 	return err
 }
 
-func (a *Agent) start(ctx context.Context) error {
+func (a *Agent) start() error {
 	rand.Seed(time.Now().Unix())
 	log.Infof("Autopilot Agent starting")
 
 	a.wg.Add(1)
-	go a.controller(ctx)
+	go a.controller()
 
 	return nil
 }
@@ -236,7 +230,6 @@ func (a *Agent) Stop() error {
 func (a *Agent) stop() error {
 	log.Infof("Autopilot Agent stopping")
 
-	a.cancel.WhenSome(func(fn context.CancelFunc) { fn() })
 	close(a.quit)
 	a.wg.Wait()
 
@@ -408,7 +401,7 @@ func mergeChanState(pendingChans map[NodeID]LocalChannel,
 // and external state changes as a result of decisions it makes w.r.t channel
 // allocation, or attributes affecting its control loop being updated by the
 // backing Lightning Node.
-func (a *Agent) controller(ctx context.Context) {
+func (a *Agent) controller() {
 	defer a.wg.Done()
 
 	// We'll start off by assigning our starting balance, and injecting
@@ -509,9 +502,6 @@ func (a *Agent) controller(ctx context.Context) {
 		// immediately.
 		case <-a.quit:
 			return
-
-		case <-ctx.Done():
-			return
 		}
 
 		a.pendingMtx.Lock()
@@ -549,7 +539,7 @@ func (a *Agent) controller(ctx context.Context) {
 		log.Infof("Triggering attachment directive dispatch, "+
 			"total_funds=%v", a.totalBalance)
 
-		err := a.openChans(ctx, availableFunds, numChans, totalChans)
+		err := a.openChans(availableFunds, numChans, totalChans)
 		if err != nil {
 			log.Errorf("Unable to open channels: %v", err)
 		}
@@ -558,8 +548,8 @@ func (a *Agent) controller(ctx context.Context) {
 
 // openChans queries the agent's heuristic for a set of channel candidates, and
 // attempts to open channels to them.
-func (a *Agent) openChans(ctx context.Context, availableFunds btcutil.Amount,
-	numChans uint32, totalChans []LocalChannel) error {
+func (a *Agent) openChans(availableFunds btcutil.Amount, numChans uint32,
+	totalChans []LocalChannel) error {
 
 	// As channel size we'll use the maximum channel size available.
 	chanSize := a.cfg.Constraints.MaxChanSize()
@@ -608,9 +598,7 @@ func (a *Agent) openChans(ctx context.Context, availableFunds btcutil.Amount,
 	selfPubBytes := a.cfg.Self.SerializeCompressed()
 	nodes := make(map[NodeID]struct{})
 	addresses := make(map[NodeID][]net.Addr)
-	if err := a.cfg.Graph.ForEachNode(ctx, func(_ context.Context,
-		node Node) error {
-
+	if err := a.cfg.Graph.ForEachNode(func(node Node) error {
 		nID := NodeID(node.PubKey())
 
 		// If we come across ourselves, them we'll continue in
@@ -648,7 +636,7 @@ func (a *Agent) openChans(ctx context.Context, availableFunds btcutil.Amount,
 	// graph.
 	log.Debugf("Scoring %d nodes for chan_size=%v", len(nodes), chanSize)
 	scores, err := a.cfg.Heuristic.NodeScores(
-		ctx, a.cfg.Graph, totalChans, chanSize, nodes,
+		a.cfg.Graph, totalChans, chanSize, nodes,
 	)
 	if err != nil {
 		return fmt.Errorf("unable to calculate node scores : %w", err)

autopilot/agent_test.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"net"
@@ -86,9 +85,9 @@ func (m *mockHeuristic) Name() string {
 	return "mock"
 }
 
-func (m *mockHeuristic) NodeScores(_ context.Context, g ChannelGraph,
-	chans []LocalChannel, chanSize btcutil.Amount,
-	nodes map[NodeID]struct{}) (map[NodeID]*NodeScore, error) {
+func (m *mockHeuristic) NodeScores(g ChannelGraph, chans []LocalChannel,
+	chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
+	map[NodeID]*NodeScore, error) {
 
 	if m.nodeScoresArgs != nil {
 		directive := directiveArg{

autopilot/betweenness_centrality.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"fmt"
 	"sync"
 )
@@ -169,10 +168,8 @@ func betweennessCentrality(g *SimpleGraph, s int, centrality []float64) {
 }
 
 // Refresh recalculates and stores centrality values.
-func (bc *BetweennessCentrality) Refresh(ctx context.Context,
-	graph ChannelGraph) error {
-
-	cache, err := NewSimpleGraph(ctx, graph)
+func (bc *BetweennessCentrality) Refresh(graph ChannelGraph) error {
+	cache, err := NewSimpleGraph(graph)
 	if err != nil {
 		return err
 	}

autopilot/betweenness_centrality_test.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"fmt"
 	"testing"
 
@@ -31,9 +30,6 @@ func TestBetweennessCentralityMetricConstruction(t *testing.T) {
 
 // Tests that empty graph results in empty centrality result.
 func TestBetweennessCentralityEmptyGraph(t *testing.T) {
-	t.Parallel()
-	ctx := context.Background()
-
 	centralityMetric, err := NewBetweennessCentralityMetric(1)
 	require.NoError(
 		t, err,
@@ -46,7 +42,7 @@ func TestBetweennessCentralityEmptyGraph(t *testing.T) {
 		require.NoError(t, err, "unable to create graph")
 
 		success := t.Run(chanGraph.name, func(t1 *testing.T) {
-			err = centralityMetric.Refresh(ctx, graph)
+			err = centralityMetric.Refresh(graph)
 			require.NoError(t1, err)
 
 			centrality := centralityMetric.GetMetric(false)
@@ -63,9 +59,6 @@ func TestBetweennessCentralityEmptyGraph(t *testing.T) {
 
 // Test betweenness centrality calculating using an example graph.
 func TestBetweennessCentralityWithNonEmptyGraph(t *testing.T) {
-	t.Parallel()
-	ctx := context.Background()
-
 	workers := []int{1, 3, 9, 100}
 
 	tests := []struct {
@@ -107,7 +100,7 @@ func TestBetweennessCentralityWithNonEmptyGraph(t *testing.T) {
 					t1, graph, centralityTestGraph,
 				)
 
-				err = metric.Refresh(ctx, graph)
+				err = metric.Refresh(graph)
 				require.NoError(t1, err)
 
 				for _, expected := range tests {

autopilot/combinedattach.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/btcsuite/btcd/btcutil"
@@ -71,9 +70,9 @@ func (c *WeightedCombAttachment) Name() string {
 // is the maximum possible improvement in connectivity.
 //
 // NOTE: This is a part of the AttachmentHeuristic interface.
-func (c *WeightedCombAttachment) NodeScores(ctx context.Context, g ChannelGraph,
-	chans []LocalChannel, chanSize btcutil.Amount,
-	nodes map[NodeID]struct{}) (map[NodeID]*NodeScore, error) {
+func (c *WeightedCombAttachment) NodeScores(g ChannelGraph, chans []LocalChannel,
+	chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
+	map[NodeID]*NodeScore, error) {
 
 	// We now query each heuristic to determine the score they give to the
 	// nodes for the given channel size.
@@ -82,7 +81,7 @@ func (c *WeightedCombAttachment) NodeScores(ctx context.Context, g ChannelGraph,
 		log.Tracef("Getting scores from sub heuristic %v", h.Name())
 
 		s, err := h.NodeScores(
-			ctx, g, chans, chanSize, nodes,
+			g, chans, chanSize, nodes,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to get sub score: %w",

autopilot/externalscoreattach.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"fmt"
 	"sync"
 
@@ -81,9 +80,9 @@ func (s *ExternalScoreAttachment) SetNodeScores(targetHeuristic string,
 // not known will get a score of 0.
 //
 // NOTE: This is a part of the AttachmentHeuristic interface.
-func (s *ExternalScoreAttachment) NodeScores(_ context.Context, g ChannelGraph,
-	chans []LocalChannel, chanSize btcutil.Amount,
-	nodes map[NodeID]struct{}) (map[NodeID]*NodeScore, error) {
+func (s *ExternalScoreAttachment) NodeScores(g ChannelGraph, chans []LocalChannel,
+	chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
+	map[NodeID]*NodeScore, error) {
 
 	existingPeers := make(map[NodeID]struct{})
 	for _, c := range chans {

autopilot/externalscoreattach_test.go

@@ -1,7 +1,6 @@
 package autopilot_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2"
@@ -23,7 +22,6 @@ func randKey() (*btcec.PublicKey, error) {
 // ExternalScoreAttachment correctly reflects the scores we set last.
 func TestSetNodeScores(t *testing.T) {
 	t.Parallel()
-	ctx := context.Background()
 
 	const name = "externalscore"
 
@@ -64,7 +62,7 @@ func TestSetNodeScores(t *testing.T) {
 		q[nID] = struct{}{}
 	}
 	resp, err := h.NodeScores(
-		ctx, nil, nil, btcutil.Amount(btcutil.SatoshiPerBitcoin), q,
+		nil, nil, btcutil.Amount(btcutil.SatoshiPerBitcoin), q,
 	)
 	if err != nil {
 		t.Fatal(err)

autopilot/graph.go

@@ -1,16 +1,19 @@
 package autopilot
 
 import (
-	"context"
+	"bytes"
 	"encoding/hex"
 	"net"
 	"sort"
+	"sync/atomic"
+	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
 	"github.com/btcsuite/btcd/btcutil"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
-	"github.com/lightningnetwork/lnd/graph/db/models"
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/models"
+	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
 )
@@ -32,7 +35,7 @@ var (
 //
 // TODO(roasbeef): move inmpl to main package?
 type databaseChannelGraph struct {
-	db GraphSource
+	db *channeldb.ChannelGraph
 }
 
 // A compile time assertion to ensure databaseChannelGraph meets the
@@ -40,8 +43,8 @@ type databaseChannelGraph struct {
 var _ ChannelGraph = (*databaseChannelGraph)(nil)
 
 // ChannelGraphFromDatabase returns an instance of the autopilot.ChannelGraph
-// backed by a GraphSource.
-func ChannelGraphFromDatabase(db GraphSource) ChannelGraph {
+// backed by a live, open channeldb instance.
+func ChannelGraphFromDatabase(db *channeldb.ChannelGraph) ChannelGraph {
 	return &databaseChannelGraph{
 		db: db,
 	}
@@ -51,7 +54,11 @@ func ChannelGraphFromDatabase(db GraphSource) ChannelGraph {
 // channeldb.LightningNode. The wrapper method implement the autopilot.Node
 // interface.
 type dbNode struct {
-	tx graphdb.NodeRTx
+	db *channeldb.ChannelGraph
+
+	tx kvdb.RTx
+
+	node *channeldb.LightningNode
 }
 
 // A compile time assertion to ensure dbNode meets the autopilot.Node
@@ -64,7 +71,7 @@ var _ Node = (*dbNode)(nil)
 //
 // NOTE: Part of the autopilot.Node interface.
 func (d *dbNode) PubKey() [33]byte {
-	return d.tx.Node().PubKeyBytes
+	return d.node.PubKeyBytes
 }
 
 // Addrs returns a slice of publicly reachable public TCP addresses that the
@@ -72,7 +79,7 @@ func (d *dbNode) PubKey() [33]byte {
 //
 // NOTE: Part of the autopilot.Node interface.
 func (d *dbNode) Addrs() []net.Addr {
-	return d.tx.Node().Addresses
+	return d.node.Addresses
 }
 
 // ForEachChannel is a higher-order function that will be used to iterate
@@ -81,38 +88,44 @@ func (d *dbNode) Addrs() []net.Addr {
 // describes the active channel.
 //
 // NOTE: Part of the autopilot.Node interface.
-func (d *dbNode) ForEachChannel(ctx context.Context,
-	cb func(context.Context, ChannelEdge) error) error {
+func (d *dbNode) ForEachChannel(cb func(ChannelEdge) error) error {
+	return d.db.ForEachNodeChannelTx(d.tx, d.node.PubKeyBytes,
+		func(tx kvdb.RTx, ei *models.ChannelEdgeInfo, ep,
+			_ *models.ChannelEdgePolicy) error {
 
-	return d.tx.ForEachChannel(func(ei *models.ChannelEdgeInfo, ep,
-		_ *models.ChannelEdgePolicy) error {
+			// Skip channels for which no outgoing edge policy is
+			// available.
+			//
+			// TODO(joostjager): Ideally the case where channels
+			// have a nil policy should be supported, as autopilot
+			// is not looking at the policies. For now, it is not
+			// easily possible to get a reference to the other end
+			// LightningNode object without retrieving the policy.
+			if ep == nil {
+				return nil
+			}
 
-		// Skip channels for which no outgoing edge policy is available.
-		//
-		// TODO(joostjager): Ideally the case where channels have a nil
-		// policy should be supported, as autopilot is not looking at
-		// the policies. For now, it is not easily possible to get a
-		// reference to the other end LightningNode object without
-		// retrieving the policy.
-		if ep == nil {
-			return nil
-		}
+			node, err := d.db.FetchLightningNodeTx(
+				tx, ep.ToNode,
+			)
+			if err != nil {
+				return err
+			}
 
-		node, err := d.tx.FetchNode(ep.ToNode)
-		if err != nil {
-			return err
-		}
+			edge := ChannelEdge{
+				ChanID: lnwire.NewShortChanIDFromInt(
+					ep.ChannelID,
+				),
+				Capacity: ei.Capacity,
+				Peer: &dbNode{
+					tx:   tx,
+					db:   d.db,
+					node: node,
+				},
+			}
 
-		edge := ChannelEdge{
-			ChanID:   lnwire.NewShortChanIDFromInt(ep.ChannelID),
-			Capacity: ei.Capacity,
-			Peer: &dbNode{
-				tx: node,
-			},
-		}
-
-		return cb(ctx, edge)
-	})
+			return cb(edge)
+		})
 }
 
 // ForEachNode is a higher-order function that should be called once for each
@@ -120,29 +133,352 @@ func (d *dbNode) ForEachChannel(ctx context.Context,
 // error, then execution should be terminated.
 //
 // NOTE: Part of the autopilot.ChannelGraph interface.
-func (d *databaseChannelGraph) ForEachNode(ctx context.Context,
-	cb func(context.Context, Node) error) error {
-
-	return d.db.ForEachNode(func(nodeTx graphdb.NodeRTx) error {
+func (d *databaseChannelGraph) ForEachNode(cb func(Node) error) error {
+	return d.db.ForEachNode(func(tx kvdb.RTx, n *channeldb.LightningNode) error {
 		// We'll skip over any node that doesn't have any advertised
 		// addresses. As we won't be able to reach them to actually
 		// open any channels.
-		if len(nodeTx.Node().Addresses) == 0 {
+		if len(n.Addresses) == 0 {
 			return nil
 		}
 
 		node := &dbNode{
-			tx: nodeTx,
+			db:   d.db,
+			tx:   tx,
+			node: n,
+		}
+		return cb(node)
+	})
+}
+
+// addRandChannel creates a new channel two target nodes. This function is
+// meant to aide in the generation of random graphs for use within test cases
+// the exercise the autopilot package.
+func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
+	capacity btcutil.Amount) (*ChannelEdge, *ChannelEdge, error) {
+
+	fetchNode := func(pub *btcec.PublicKey) (*channeldb.LightningNode, error) {
+		if pub != nil {
+			vertex, err := route.NewVertexFromBytes(
+				pub.SerializeCompressed(),
+			)
+			if err != nil {
+				return nil, err
+			}
+
+			dbNode, err := d.db.FetchLightningNode(vertex)
+			switch {
+			case err == channeldb.ErrGraphNodeNotFound:
+				fallthrough
+			case err == channeldb.ErrGraphNotFound:
+				graphNode := &channeldb.LightningNode{
+					HaveNodeAnnouncement: true,
+					Addresses: []net.Addr{
+						&net.TCPAddr{
+							IP: bytes.Repeat([]byte("a"), 16),
+						},
+					},
+					Features: lnwire.NewFeatureVector(
+						nil, lnwire.Features,
+					),
+					AuthSigBytes: testSig.Serialize(),
+				}
+				graphNode.AddPubKey(pub)
+				if err := d.db.AddLightningNode(graphNode); err != nil {
+					return nil, err
+				}
+			case err != nil:
+				return nil, err
+			}
+
+			return dbNode, nil
 		}
 
-		return cb(ctx, node)
-	})
+		nodeKey, err := randKey()
+		if err != nil {
+			return nil, err
+		}
+		dbNode := &channeldb.LightningNode{
+			HaveNodeAnnouncement: true,
+			Addresses: []net.Addr{
+				&net.TCPAddr{
+					IP: bytes.Repeat([]byte("a"), 16),
+				},
+			},
+			Features: lnwire.NewFeatureVector(
+				nil, lnwire.Features,
+			),
+			AuthSigBytes: testSig.Serialize(),
+		}
+		dbNode.AddPubKey(nodeKey)
+		if err := d.db.AddLightningNode(dbNode); err != nil {
+			return nil, err
+		}
+
+		return dbNode, nil
+	}
+
+	vertex1, err := fetchNode(node1)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	vertex2, err := fetchNode(node2)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var lnNode1, lnNode2 *btcec.PublicKey
+	if bytes.Compare(vertex1.PubKeyBytes[:], vertex2.PubKeyBytes[:]) == -1 {
+		lnNode1, _ = vertex1.PubKey()
+		lnNode2, _ = vertex2.PubKey()
+	} else {
+		lnNode1, _ = vertex2.PubKey()
+		lnNode2, _ = vertex1.PubKey()
+	}
+
+	chanID := randChanID()
+	edge := &models.ChannelEdgeInfo{
+		ChannelID: chanID.ToUint64(),
+		Capacity:  capacity,
+	}
+	edge.AddNodeKeys(lnNode1, lnNode2, lnNode1, lnNode2)
+	if err := d.db.AddChannelEdge(edge); err != nil {
+		return nil, nil, err
+	}
+	edgePolicy := &models.ChannelEdgePolicy{
+		SigBytes:                  testSig.Serialize(),
+		ChannelID:                 chanID.ToUint64(),
+		LastUpdate:                time.Now(),
+		TimeLockDelta:             10,
+		MinHTLC:                   1,
+		MaxHTLC:                   lnwire.NewMSatFromSatoshis(capacity),
+		FeeBaseMSat:               10,
+		FeeProportionalMillionths: 10000,
+		MessageFlags:              1,
+		ChannelFlags:              0,
+	}
+
+	if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
+		return nil, nil, err
+	}
+	edgePolicy = &models.ChannelEdgePolicy{
+		SigBytes:                  testSig.Serialize(),
+		ChannelID:                 chanID.ToUint64(),
+		LastUpdate:                time.Now(),
+		TimeLockDelta:             10,
+		MinHTLC:                   1,
+		MaxHTLC:                   lnwire.NewMSatFromSatoshis(capacity),
+		FeeBaseMSat:               10,
+		FeeProportionalMillionths: 10000,
+		MessageFlags:              1,
+		ChannelFlags:              1,
+	}
+	if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
+		return nil, nil, err
+	}
+
+	return &ChannelEdge{
+			ChanID:   chanID,
+			Capacity: capacity,
+			Peer: &dbNode{
+				db:   d.db,
+				node: vertex1,
+			},
+		},
+		&ChannelEdge{
+			ChanID:   chanID,
+			Capacity: capacity,
+			Peer: &dbNode{
+				db:   d.db,
+				node: vertex2,
+			},
+		},
+		nil
+}
+
+func (d *databaseChannelGraph) addRandNode() (*btcec.PublicKey, error) {
+	nodeKey, err := randKey()
+	if err != nil {
+		return nil, err
+	}
+	dbNode := &channeldb.LightningNode{
+		HaveNodeAnnouncement: true,
+		Addresses: []net.Addr{
+			&net.TCPAddr{
+				IP: bytes.Repeat([]byte("a"), 16),
+			},
+		},
+		Features: lnwire.NewFeatureVector(
+			nil, lnwire.Features,
+		),
+		AuthSigBytes: testSig.Serialize(),
+	}
+	dbNode.AddPubKey(nodeKey)
+	if err := d.db.AddLightningNode(dbNode); err != nil {
+		return nil, err
+	}
+
+	return nodeKey, nil
+
+}
+
+// memChannelGraph is an implementation of the autopilot.ChannelGraph backed by
+// an in-memory graph.
+type memChannelGraph struct {
+	graph map[NodeID]*memNode
+}
+
+// A compile time assertion to ensure memChannelGraph meets the
+// autopilot.ChannelGraph interface.
+var _ ChannelGraph = (*memChannelGraph)(nil)
+
+// newMemChannelGraph creates a new blank in-memory channel graph
+// implementation.
+func newMemChannelGraph() *memChannelGraph {
+	return &memChannelGraph{
+		graph: make(map[NodeID]*memNode),
+	}
+}
+
+// ForEachNode is a higher-order function that should be called once for each
+// connected node within the channel graph. If the passed callback returns an
+// error, then execution should be terminated.
+//
+// NOTE: Part of the autopilot.ChannelGraph interface.
+func (m memChannelGraph) ForEachNode(cb func(Node) error) error {
+	for _, node := range m.graph {
+		if err := cb(node); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// randChanID generates a new random channel ID.
+func randChanID() lnwire.ShortChannelID {
+	id := atomic.AddUint64(&chanIDCounter, 1)
+	return lnwire.NewShortChanIDFromInt(id)
+}
+
+// randKey returns a random public key.
+func randKey() (*btcec.PublicKey, error) {
+	priv, err := btcec.NewPrivateKey()
+	if err != nil {
+		return nil, err
+	}
+
+	return priv.PubKey(), nil
+}
+
+// addRandChannel creates a new channel two target nodes. This function is
+// meant to aide in the generation of random graphs for use within test cases
+// the exercise the autopilot package.
+func (m *memChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
+	capacity btcutil.Amount) (*ChannelEdge, *ChannelEdge, error) {
+
+	var (
+		vertex1, vertex2 *memNode
+		ok               bool
+	)
+
+	if node1 != nil {
+		vertex1, ok = m.graph[NewNodeID(node1)]
+		if !ok {
+			vertex1 = &memNode{
+				pub: node1,
+				addrs: []net.Addr{
+					&net.TCPAddr{
+						IP: bytes.Repeat([]byte("a"), 16),
+					},
+				},
+			}
+		}
+	} else {
+		newPub, err := randKey()
+		if err != nil {
+			return nil, nil, err
+		}
+		vertex1 = &memNode{
+			pub: newPub,
+			addrs: []net.Addr{
+				&net.TCPAddr{
+					IP: bytes.Repeat([]byte("a"), 16),
+				},
+			},
+		}
+	}
+
+	if node2 != nil {
+		vertex2, ok = m.graph[NewNodeID(node2)]
+		if !ok {
+			vertex2 = &memNode{
+				pub: node2,
+				addrs: []net.Addr{
+					&net.TCPAddr{
+						IP: bytes.Repeat([]byte("a"), 16),
+					},
+				},
+			}
+		}
+	} else {
+		newPub, err := randKey()
+		if err != nil {
+			return nil, nil, err
+		}
+		vertex2 = &memNode{
+			pub: newPub,
+			addrs: []net.Addr{
+				&net.TCPAddr{
+					IP: bytes.Repeat([]byte("a"), 16),
+				},
+			},
+		}
+	}
+
+	edge1 := ChannelEdge{
+		ChanID:   randChanID(),
+		Capacity: capacity,
+		Peer:     vertex2,
+	}
+	vertex1.chans = append(vertex1.chans, edge1)
+
+	edge2 := ChannelEdge{
+		ChanID:   randChanID(),
+		Capacity: capacity,
+		Peer:     vertex1,
+	}
+	vertex2.chans = append(vertex2.chans, edge2)
+
+	m.graph[NewNodeID(vertex1.pub)] = vertex1
+	m.graph[NewNodeID(vertex2.pub)] = vertex2
+
+	return &edge1, &edge2, nil
+}
+
+func (m *memChannelGraph) addRandNode() (*btcec.PublicKey, error) {
+	newPub, err := randKey()
+	if err != nil {
+		return nil, err
+	}
+	vertex := &memNode{
+		pub: newPub,
+		addrs: []net.Addr{
+			&net.TCPAddr{
+				IP: bytes.Repeat([]byte("a"), 16),
+			},
+		},
+	}
+	m.graph[NewNodeID(newPub)] = vertex
+
+	return newPub, nil
 }
 
 // databaseChannelGraphCached wraps a channeldb.ChannelGraph instance with the
 // necessary API to properly implement the autopilot.ChannelGraph interface.
 type databaseChannelGraphCached struct {
-	db GraphSource
+	db *channeldb.ChannelGraph
 }
 
 // A compile time assertion to ensure databaseChannelGraphCached meets the
@@ -151,7 +487,7 @@ var _ ChannelGraph = (*databaseChannelGraphCached)(nil)
 
 // ChannelGraphFromCachedDatabase returns an instance of the
 // autopilot.ChannelGraph backed by a live, open channeldb instance.
-func ChannelGraphFromCachedDatabase(db GraphSource) ChannelGraph {
+func ChannelGraphFromCachedDatabase(db *channeldb.ChannelGraph) ChannelGraph {
 	return &databaseChannelGraphCached{
 		db: db,
 	}
@@ -162,7 +498,7 @@ func ChannelGraphFromCachedDatabase(db GraphSource) ChannelGraph {
 // interface.
 type dbNodeCached struct {
 	node     route.Vertex
-	channels map[uint64]*graphdb.DirectedChannel
+	channels map[uint64]*channeldb.DirectedChannel
 }
 
 // A compile time assertion to ensure dbNodeCached meets the autopilot.Node
@@ -191,9 +527,7 @@ func (nc dbNodeCached) Addrs() []net.Addr {
 // describes the active channel.
 //
 // NOTE: Part of the autopilot.Node interface.
-func (nc dbNodeCached) ForEachChannel(ctx context.Context,
-	cb func(context.Context, ChannelEdge) error) error {
-
+func (nc dbNodeCached) ForEachChannel(cb func(ChannelEdge) error) error {
 	for cid, channel := range nc.channels {
 		edge := ChannelEdge{
 			ChanID:   lnwire.NewShortChanIDFromInt(cid),
@@ -203,7 +537,7 @@ func (nc dbNodeCached) ForEachChannel(ctx context.Context,
 			},
 		}
 
-		if err := cb(ctx, edge); err != nil {
+		if err := cb(edge); err != nil {
 			return err
 		}
 	}
@@ -216,19 +550,16 @@ func (nc dbNodeCached) ForEachChannel(ctx context.Context,
 // error, then execution should be terminated.
 //
 // NOTE: Part of the autopilot.ChannelGraph interface.
-func (dc *databaseChannelGraphCached) ForEachNode(ctx context.Context,
-	cb func(context.Context, Node) error) error {
-
+func (dc *databaseChannelGraphCached) ForEachNode(cb func(Node) error) error {
 	return dc.db.ForEachNodeCached(func(n route.Vertex,
-		channels map[uint64]*graphdb.DirectedChannel) error {
+		channels map[uint64]*channeldb.DirectedChannel) error {
 
 		if len(channels) > 0 {
 			node := dbNodeCached{
 				node:     n,
 				channels: channels,
 			}
-
-			return cb(ctx, node)
+			return cb(node)
 		}
 		return nil
 	})
@@ -273,11 +604,9 @@ func (m memNode) Addrs() []net.Addr {
 // describes the active channel.
 //
 // NOTE: Part of the autopilot.Node interface.
-func (m memNode) ForEachChannel(ctx context.Context,
-	cb func(context.Context, ChannelEdge) error) error {
-
+func (m memNode) ForEachChannel(cb func(ChannelEdge) error) error {
 	for _, channel := range m.chans {
-		if err := cb(ctx, channel); err != nil {
+		if err := cb(channel); err != nil {
 			return err
 		}
 	}

autopilot/interface.go

@@ -1,15 +1,12 @@
 package autopilot
 
 import (
-	"context"
 	"net"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/wire"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/lnwire"
-	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 // DefaultConfTarget is the default confirmation target for autopilot channels.
@@ -36,8 +33,7 @@ type Node interface {
 	// iterate through all edges emanating from/to the target node. For
 	// each active channel, this function should be called with the
 	// populated ChannelEdge that describes the active channel.
-	ForEachChannel(context.Context, func(context.Context,
-		ChannelEdge) error) error
+	ForEachChannel(func(ChannelEdge) error) error
 }
 
 // LocalChannel is a simple struct which contains relevant details of a
@@ -85,7 +81,7 @@ type ChannelGraph interface {
 	// ForEachNode is a higher-order function that should be called once
 	// for each connected node within the channel graph. If the passed
 	// callback returns an error, then execution should be terminated.
-	ForEachNode(context.Context, func(context.Context, Node) error) error
+	ForEachNode(func(Node) error) error
 }
 
 // NodeScore is a tuple mapping a NodeID to a score indicating the preference
@@ -144,7 +140,7 @@ type AttachmentHeuristic interface {
 	//
 	// NOTE: A NodeID not found in the returned map is implicitly given a
 	// score of 0.
-	NodeScores(ctx context.Context, g ChannelGraph, chans []LocalChannel,
+	NodeScores(g ChannelGraph, chans []LocalChannel,
 		chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
 		map[NodeID]*NodeScore, error)
 }
@@ -157,7 +153,7 @@ type NodeMetric interface {
 	Name() string
 
 	// Refresh refreshes the metric values based on the current graph.
-	Refresh(ctx context.Context, graph ChannelGraph) error
+	Refresh(graph ChannelGraph) error
 
 	// GetMetric returns the latest value of this metric. Values in the
 	// map are per node and can be in arbitrary domain. If normalize is
@@ -220,20 +216,3 @@ type ChannelController interface {
 	// TODO(roasbeef): add force option?
 	CloseChannel(chanPoint *wire.OutPoint) error
 }
-
-// GraphSource represents read access to the channel graph.
-type GraphSource interface {
-	// ForEachNode iterates through all the stored vertices/nodes in the
-	// graph, executing the passed callback with each node encountered. If
-	// the callback returns an error, then the transaction is aborted and
-	// the iteration stops early. Any operations performed on the NodeTx
-	// passed to the call-back are executed under the same read transaction.
-	ForEachNode(func(graphdb.NodeRTx) error) error
-
-	// ForEachNodeCached is similar to ForEachNode, but it utilizes the
-	// channel graph cache if one is available. It is less consistent than
-	// ForEachNode since any further calls are made across multiple
-	// transactions.
-	ForEachNodeCached(cb func(node route.Vertex,
-		chans map[uint64]*graphdb.DirectedChannel) error) error
-}

autopilot/log.go

@@ -1,7 +1,7 @@
 package autopilot
 
 import (
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 )
 

autopilot/manager.go

@@ -1,13 +1,12 @@
 package autopilot
 
 import (
-	"context"
 	"fmt"
 	"sync"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
+	"github.com/lightningnetwork/lnd/graph"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
@@ -37,7 +36,7 @@ type ManagerCfg struct {
 
 	// SubscribeTopology is used to get a subscription for topology changes
 	// on the network.
-	SubscribeTopology func() (*graphdb.TopologyClient, error)
+	SubscribeTopology func() (*graph.TopologyClient, error)
 }
 
 // Manager is struct that manages an autopilot agent, making it possible to
@@ -267,8 +266,8 @@ func (m *Manager) StopAgent() error {
 }
 
 // QueryHeuristics queries the available autopilot heuristics for node scores.
-func (m *Manager) QueryHeuristics(ctx context.Context, nodes []NodeID,
-	localState bool) (HeuristicScores, error) {
+func (m *Manager) QueryHeuristics(nodes []NodeID, localState bool) (
+	HeuristicScores, error) {
 
 	m.Lock()
 	defer m.Unlock()
@@ -279,8 +278,7 @@ func (m *Manager) QueryHeuristics(ctx context.Context, nodes []NodeID,
 	}
 
 	log.Debugf("Querying heuristics for %d nodes", len(n))
-
-	return m.queryHeuristics(ctx, n, localState)
+	return m.queryHeuristics(n, localState)
 }
 
 // HeuristicScores is an alias for a map that maps heuristic names to a map of
@@ -291,8 +289,8 @@ type HeuristicScores map[string]map[NodeID]float64
 // the agent's current active heuristic.
 //
 // NOTE: Must be called with the manager's lock.
-func (m *Manager) queryHeuristics(ctx context.Context,
-	nodes map[NodeID]struct{}, localState bool) (HeuristicScores, error) {
+func (m *Manager) queryHeuristics(nodes map[NodeID]struct{}, localState bool) (
+	HeuristicScores, error) {
 
 	// If we want to take the local state into action when querying the
 	// heuristics, we fetch it. If not we'll just pass an empty slice to
@@ -340,7 +338,7 @@ func (m *Manager) queryHeuristics(ctx context.Context,
 		}
 
 		s, err := h.NodeScores(
-			ctx, m.cfg.PilotCfg.Graph, totalChans, chanSize, nodes,
+			m.cfg.PilotCfg.Graph, totalChans, chanSize, nodes,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to get sub score: %w",

autopilot/prefattach.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	prand "math/rand"
 	"time"
 
@@ -79,9 +78,9 @@ func (p *PrefAttachment) Name() string {
 // given to nodes already having high connectivity in the graph.
 //
 // NOTE: This is a part of the AttachmentHeuristic interface.
-func (p *PrefAttachment) NodeScores(ctx context.Context, g ChannelGraph,
-	chans []LocalChannel, chanSize btcutil.Amount,
-	nodes map[NodeID]struct{}) (map[NodeID]*NodeScore, error) {
+func (p *PrefAttachment) NodeScores(g ChannelGraph, chans []LocalChannel,
+	chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
+	map[NodeID]*NodeScore, error) {
 
 	// We first run though the graph once in order to find the median
 	// channel size.
@@ -89,10 +88,8 @@ func (p *PrefAttachment) NodeScores(ctx context.Context, g ChannelGraph,
 		allChans  []btcutil.Amount
 		seenChans = make(map[uint64]struct{})
 	)
-	if err := g.ForEachNode(ctx, func(ctx context.Context, n Node) error {
-		err := n.ForEachChannel(ctx, func(_ context.Context,
-			e ChannelEdge) error {
-
+	if err := g.ForEachNode(func(n Node) error {
+		err := n.ForEachChannel(func(e ChannelEdge) error {
 			if _, ok := seenChans[e.ChanID.ToUint64()]; ok {
 				return nil
 			}
@@ -117,19 +114,15 @@ func (p *PrefAttachment) NodeScores(ctx context.Context, g ChannelGraph,
 	// the graph.
 	var maxChans int
 	nodeChanNum := make(map[NodeID]int)
-	if err := g.ForEachNode(ctx, func(ctx context.Context, n Node) error {
+	if err := g.ForEachNode(func(n Node) error {
 		var nodeChans int
-		err := n.ForEachChannel(ctx, func(_ context.Context,
-			e ChannelEdge) error {
-
+		err := n.ForEachChannel(func(e ChannelEdge) error {
 			// Since connecting to nodes with a lot of small
 			// channels actually worsens our connectivity in the
 			// graph (we will potentially waste time trying to use
 			// these useless channels in path finding), we decrease
 			// the counter for such channels.
-			if e.Capacity <
-				medianChanSize/minMedianChanSizeFraction {
-
+			if e.Capacity < medianChanSize/minMedianChanSizeFraction {
 				nodeChans--
 				return nil
 			}

autopilot/prefattach_test.go

@@ -2,21 +2,13 @@ package autopilot
 
 import (
 	"bytes"
-	"context"
-	"errors"
 	prand "math/rand"
-	"net"
-	"sync/atomic"
 	"testing"
 	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
-	"github.com/lightningnetwork/lnd/graph/db/models"
-	"github.com/lightningnetwork/lnd/kvdb"
-	"github.com/lightningnetwork/lnd/lnwire"
-	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/stretchr/testify/require"
 )
 
@@ -31,39 +23,22 @@ type testGraph interface {
 	addRandNode() (*btcec.PublicKey, error)
 }
 
-type testDBGraph struct {
-	db *graphdb.ChannelGraph
-	databaseChannelGraph
-}
-
 func newDiskChanGraph(t *testing.T) (testGraph, error) {
-	backend, err := kvdb.GetBoltBackend(&kvdb.BoltBackendConfig{
-		DBPath:            t.TempDir(),
-		DBFileName:        "graph.db",
-		NoFreelistSync:    true,
-		AutoCompact:       false,
-		AutoCompactMinAge: kvdb.DefaultBoltAutoCompactMinAge,
-		DBTimeout:         kvdb.DefaultDBTimeout,
-	})
-	require.NoError(t, err)
-
-	graphDB, err := graphdb.NewChannelGraph(&graphdb.Config{KVDB: backend})
-	require.NoError(t, err)
-
-	require.NoError(t, graphDB.Start())
+	// Next, create channeldb for the first time.
+	cdb, err := channeldb.Open(t.TempDir())
+	if err != nil {
+		return nil, err
+	}
 	t.Cleanup(func() {
-		require.NoError(t, graphDB.Stop())
+		require.NoError(t, cdb.Close())
 	})
 
-	return &testDBGraph{
-		db: graphDB,
-		databaseChannelGraph: databaseChannelGraph{
-			db: graphDB,
-		},
+	return &databaseChannelGraph{
+		db: cdb.ChannelGraph(),
 	}, nil
 }
 
-var _ testGraph = (*testDBGraph)(nil)
+var _ testGraph = (*databaseChannelGraph)(nil)
 
 func newMemChanGraph(_ *testing.T) (testGraph, error) {
 	return newMemChannelGraph(), nil
@@ -88,8 +63,6 @@ var chanGraphs = []struct {
 // TestPrefAttachmentSelectEmptyGraph ensures that when passed an
 // empty graph, the NodeSores function always returns a score of 0.
 func TestPrefAttachmentSelectEmptyGraph(t *testing.T) {
-	t.Parallel()
-	ctx := context.Background()
 	prefAttach := NewPrefAttachment()
 
 	// Create a random public key, which we will query to get a score for.
@@ -110,7 +83,7 @@ func TestPrefAttachmentSelectEmptyGraph(t *testing.T) {
 			// attempt to get the score for this one node.
 			const walletFunds = btcutil.SatoshiPerBitcoin
 			scores, err := prefAttach.NodeScores(
-				ctx, graph, nil, walletFunds, nodes,
+				graph, nil, walletFunds, nodes,
 			)
 			require.NoError(t1, err)
 
@@ -129,7 +102,6 @@ func TestPrefAttachmentSelectEmptyGraph(t *testing.T) {
 // and the funds are appropriately allocated across each peer.
 func TestPrefAttachmentSelectTwoVertexes(t *testing.T) {
 	t.Parallel()
-	ctx := context.Background()
 
 	prand.Seed(time.Now().Unix())
 
@@ -160,12 +132,10 @@ func TestPrefAttachmentSelectTwoVertexes(t *testing.T) {
 			// Get the score for all nodes found in the graph at
 			// this point.
 			nodes := make(map[NodeID]struct{})
-			err = graph.ForEachNode(ctx,
-				func(_ context.Context, n Node) error {
-					nodes[n.PubKey()] = struct{}{}
-					return nil
-				},
-			)
+			err = graph.ForEachNode(func(n Node) error {
+				nodes[n.PubKey()] = struct{}{}
+				return nil
+			})
 			require.NoError(t1, err)
 
 			require.Len(t1, nodes, 3)
@@ -174,7 +144,7 @@ func TestPrefAttachmentSelectTwoVertexes(t *testing.T) {
 			// attempt to get our candidates channel score given
 			// the current state of the graph.
 			candidates, err := prefAttach.NodeScores(
-				ctx, graph, nil, maxChanSize, nodes,
+				graph, nil, maxChanSize, nodes,
 			)
 			require.NoError(t1, err)
 
@@ -213,7 +183,6 @@ func TestPrefAttachmentSelectTwoVertexes(t *testing.T) {
 // allocate all funds to each vertex (up to the max channel size).
 func TestPrefAttachmentSelectGreedyAllocation(t *testing.T) {
 	t.Parallel()
-	ctx := context.Background()
 
 	prand.Seed(time.Now().Unix())
 
@@ -252,25 +221,22 @@ func TestPrefAttachmentSelectGreedyAllocation(t *testing.T) {
 			numNodes := 0
 			twoChans := false
 			nodes := make(map[NodeID]struct{})
-			err = graph.ForEachNode(
-				ctx, func(ctx context.Context, n Node) error {
-					numNodes++
-					nodes[n.PubKey()] = struct{}{}
-					numChans := 0
-					err := n.ForEachChannel(ctx,
-						func(_ context.Context, c ChannelEdge) error { //nolint:ll
-							numChans++
-							return nil
-						},
-					)
-					if err != nil {
-						return err
-					}
-
-					twoChans = twoChans || (numChans == 2)
-
+			err = graph.ForEachNode(func(n Node) error {
+				numNodes++
+				nodes[n.PubKey()] = struct{}{}
+				numChans := 0
+				err := n.ForEachChannel(func(c ChannelEdge) error {
+					numChans++
 					return nil
 				})
+				if err != nil {
+					return err
+				}
+
+				twoChans = twoChans || (numChans == 2)
+
+				return nil
+			})
 			require.NoError(t1, err)
 
 			require.EqualValues(t1, 3, numNodes)
@@ -282,7 +248,7 @@ func TestPrefAttachmentSelectGreedyAllocation(t *testing.T) {
 			// result, the heuristic should try to greedily
 			// allocate funds to channels.
 			scores, err := prefAttach.NodeScores(
-				ctx, graph, nil, maxChanSize, nodes,
+				graph, nil, maxChanSize, nodes,
 			)
 			require.NoError(t1, err)
 
@@ -300,7 +266,7 @@ func TestPrefAttachmentSelectGreedyAllocation(t *testing.T) {
 			// candidates of that size.
 			const remBalance = btcutil.SatoshiPerBitcoin * 0.5
 			scores, err = prefAttach.NodeScores(
-				ctx, graph, nil, remBalance, nodes,
+				graph, nil, remBalance, nodes,
 			)
 			require.NoError(t1, err)
 
@@ -323,7 +289,6 @@ func TestPrefAttachmentSelectGreedyAllocation(t *testing.T) {
 // of zero during scoring.
 func TestPrefAttachmentSelectSkipNodes(t *testing.T) {
 	t.Parallel()
-	ctx := context.Background()
 
 	prand.Seed(time.Now().Unix())
 
@@ -346,13 +311,10 @@ func TestPrefAttachmentSelectSkipNodes(t *testing.T) {
 			require.NoError(t1, err)
 
 			nodes := make(map[NodeID]struct{})
-			err = graph.ForEachNode(
-				ctx, func(_ context.Context, n Node) error {
-					nodes[n.PubKey()] = struct{}{}
-
-					return nil
-				},
-			)
+			err = graph.ForEachNode(func(n Node) error {
+				nodes[n.PubKey()] = struct{}{}
+				return nil
+			})
 			require.NoError(t1, err)
 
 			require.Len(t1, nodes, 2)
@@ -360,7 +322,7 @@ func TestPrefAttachmentSelectSkipNodes(t *testing.T) {
 			// With our graph created, we'll now get the scores for
 			// all nodes in the graph.
 			scores, err := prefAttach.NodeScores(
-				ctx, graph, nil, maxChanSize, nodes,
+				graph, nil, maxChanSize, nodes,
 			)
 			require.NoError(t1, err)
 
@@ -388,7 +350,7 @@ func TestPrefAttachmentSelectSkipNodes(t *testing.T) {
 			// then all nodes should have a score of zero, since we
 			// already got channels to them.
 			scores, err = prefAttach.NodeScores(
-				ctx, graph, chans, maxChanSize, nodes,
+				graph, chans, maxChanSize, nodes,
 			)
 			require.NoError(t1, err)
 
@@ -401,359 +363,3 @@ func TestPrefAttachmentSelectSkipNodes(t *testing.T) {
 		}
 	}
 }
-
-// addRandChannel creates a new channel two target nodes. This function is
-// meant to aide in the generation of random graphs for use within test cases
-// the exercise the autopilot package.
-func (d *testDBGraph) addRandChannel(node1, node2 *btcec.PublicKey,
-	capacity btcutil.Amount) (*ChannelEdge, *ChannelEdge, error) {
-
-	fetchNode := func(pub *btcec.PublicKey) (*models.LightningNode, error) {
-		if pub != nil {
-			vertex, err := route.NewVertexFromBytes(
-				pub.SerializeCompressed(),
-			)
-			if err != nil {
-				return nil, err
-			}
-
-			dbNode, err := d.db.FetchLightningNode(vertex)
-			switch {
-			case errors.Is(err, graphdb.ErrGraphNodeNotFound):
-				fallthrough
-			case errors.Is(err, graphdb.ErrGraphNotFound):
-				graphNode := &models.LightningNode{
-					HaveNodeAnnouncement: true,
-					Addresses: []net.Addr{&net.TCPAddr{
-						IP: bytes.Repeat(
-							[]byte("a"), 16,
-						),
-					}},
-					Features: lnwire.NewFeatureVector(
-						nil, lnwire.Features,
-					),
-					AuthSigBytes: testSig.Serialize(),
-				}
-				graphNode.AddPubKey(pub)
-				err := d.db.AddLightningNode(graphNode)
-				if err != nil {
-					return nil, err
-				}
-			case err != nil:
-				return nil, err
-			}
-
-			return dbNode, nil
-		}
-
-		nodeKey, err := randKey()
-		if err != nil {
-			return nil, err
-		}
-		dbNode := &models.LightningNode{
-			HaveNodeAnnouncement: true,
-			Addresses: []net.Addr{
-				&net.TCPAddr{
-					IP: bytes.Repeat([]byte("a"), 16),
-				},
-			},
-			Features: lnwire.NewFeatureVector(
-				nil, lnwire.Features,
-			),
-			AuthSigBytes: testSig.Serialize(),
-		}
-		dbNode.AddPubKey(nodeKey)
-		if err := d.db.AddLightningNode(dbNode); err != nil {
-			return nil, err
-		}
-
-		return dbNode, nil
-	}
-
-	vertex1, err := fetchNode(node1)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	vertex2, err := fetchNode(node2)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var lnNode1, lnNode2 *btcec.PublicKey
-	if bytes.Compare(vertex1.PubKeyBytes[:], vertex2.PubKeyBytes[:]) == -1 {
-		lnNode1, _ = vertex1.PubKey()
-		lnNode2, _ = vertex2.PubKey()
-	} else {
-		lnNode1, _ = vertex2.PubKey()
-		lnNode2, _ = vertex1.PubKey()
-	}
-
-	chanID := randChanID()
-	edge := &models.ChannelEdgeInfo{
-		ChannelID: chanID.ToUint64(),
-		Capacity:  capacity,
-	}
-	edge.AddNodeKeys(lnNode1, lnNode2, lnNode1, lnNode2)
-	if err := d.db.AddChannelEdge(edge); err != nil {
-		return nil, nil, err
-	}
-	edgePolicy := &models.ChannelEdgePolicy{
-		SigBytes:                  testSig.Serialize(),
-		ChannelID:                 chanID.ToUint64(),
-		LastUpdate:                time.Now(),
-		TimeLockDelta:             10,
-		MinHTLC:                   1,
-		MaxHTLC:                   lnwire.NewMSatFromSatoshis(capacity),
-		FeeBaseMSat:               10,
-		FeeProportionalMillionths: 10000,
-		MessageFlags:              1,
-		ChannelFlags:              0,
-	}
-
-	if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
-		return nil, nil, err
-	}
-	edgePolicy = &models.ChannelEdgePolicy{
-		SigBytes:                  testSig.Serialize(),
-		ChannelID:                 chanID.ToUint64(),
-		LastUpdate:                time.Now(),
-		TimeLockDelta:             10,
-		MinHTLC:                   1,
-		MaxHTLC:                   lnwire.NewMSatFromSatoshis(capacity),
-		FeeBaseMSat:               10,
-		FeeProportionalMillionths: 10000,
-		MessageFlags:              1,
-		ChannelFlags:              1,
-	}
-	if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
-		return nil, nil, err
-	}
-
-	return &ChannelEdge{
-			ChanID:   chanID,
-			Capacity: capacity,
-			Peer: &dbNode{tx: &testNodeTx{
-				db:   d,
-				node: vertex1,
-			}},
-		},
-		&ChannelEdge{
-			ChanID:   chanID,
-			Capacity: capacity,
-			Peer: &dbNode{tx: &testNodeTx{
-				db:   d,
-				node: vertex2,
-			}},
-		},
-		nil
-}
-
-func (d *testDBGraph) addRandNode() (*btcec.PublicKey, error) {
-	nodeKey, err := randKey()
-	if err != nil {
-		return nil, err
-	}
-	dbNode := &models.LightningNode{
-		HaveNodeAnnouncement: true,
-		Addresses: []net.Addr{
-			&net.TCPAddr{
-				IP: bytes.Repeat([]byte("a"), 16),
-			},
-		},
-		Features: lnwire.NewFeatureVector(
-			nil, lnwire.Features,
-		),
-		AuthSigBytes: testSig.Serialize(),
-	}
-	dbNode.AddPubKey(nodeKey)
-	if err := d.db.AddLightningNode(dbNode); err != nil {
-		return nil, err
-	}
-
-	return nodeKey, nil
-}
-
-// memChannelGraph is an implementation of the autopilot.ChannelGraph backed by
-// an in-memory graph.
-type memChannelGraph struct {
-	graph map[NodeID]*memNode
-}
-
-// A compile time assertion to ensure memChannelGraph meets the
-// autopilot.ChannelGraph interface.
-var _ ChannelGraph = (*memChannelGraph)(nil)
-
-// newMemChannelGraph creates a new blank in-memory channel graph
-// implementation.
-func newMemChannelGraph() *memChannelGraph {
-	return &memChannelGraph{
-		graph: make(map[NodeID]*memNode),
-	}
-}
-
-// ForEachNode is a higher-order function that should be called once for each
-// connected node within the channel graph. If the passed callback returns an
-// error, then execution should be terminated.
-//
-// NOTE: Part of the autopilot.ChannelGraph interface.
-func (m *memChannelGraph) ForEachNode(ctx context.Context,
-	cb func(context.Context, Node) error) error {
-
-	for _, node := range m.graph {
-		if err := cb(ctx, node); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// randChanID generates a new random channel ID.
-func randChanID() lnwire.ShortChannelID {
-	id := atomic.AddUint64(&chanIDCounter, 1)
-	return lnwire.NewShortChanIDFromInt(id)
-}
-
-// randKey returns a random public key.
-func randKey() (*btcec.PublicKey, error) {
-	priv, err := btcec.NewPrivateKey()
-	if err != nil {
-		return nil, err
-	}
-
-	return priv.PubKey(), nil
-}
-
-// addRandChannel creates a new channel two target nodes. This function is
-// meant to aide in the generation of random graphs for use within test cases
-// the exercise the autopilot package.
-func (m *memChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
-	capacity btcutil.Amount) (*ChannelEdge, *ChannelEdge, error) {
-
-	var (
-		vertex1, vertex2 *memNode
-		ok               bool
-	)
-
-	if node1 != nil {
-		vertex1, ok = m.graph[NewNodeID(node1)]
-		if !ok {
-			vertex1 = &memNode{
-				pub: node1,
-				addrs: []net.Addr{&net.TCPAddr{
-					IP: bytes.Repeat([]byte("a"), 16),
-				}},
-			}
-		}
-	} else {
-		newPub, err := randKey()
-		if err != nil {
-			return nil, nil, err
-		}
-		vertex1 = &memNode{
-			pub: newPub,
-			addrs: []net.Addr{
-				&net.TCPAddr{
-					IP: bytes.Repeat([]byte("a"), 16),
-				},
-			},
-		}
-	}
-
-	if node2 != nil {
-		vertex2, ok = m.graph[NewNodeID(node2)]
-		if !ok {
-			vertex2 = &memNode{
-				pub: node2,
-				addrs: []net.Addr{&net.TCPAddr{
-					IP: bytes.Repeat([]byte("a"), 16),
-				}},
-			}
-		}
-	} else {
-		newPub, err := randKey()
-		if err != nil {
-			return nil, nil, err
-		}
-		vertex2 = &memNode{
-			pub: newPub,
-			addrs: []net.Addr{
-				&net.TCPAddr{
-					IP: bytes.Repeat([]byte("a"), 16),
-				},
-			},
-		}
-	}
-
-	edge1 := ChannelEdge{
-		ChanID:   randChanID(),
-		Capacity: capacity,
-		Peer:     vertex2,
-	}
-	vertex1.chans = append(vertex1.chans, edge1)
-
-	edge2 := ChannelEdge{
-		ChanID:   randChanID(),
-		Capacity: capacity,
-		Peer:     vertex1,
-	}
-	vertex2.chans = append(vertex2.chans, edge2)
-
-	m.graph[NewNodeID(vertex1.pub)] = vertex1
-	m.graph[NewNodeID(vertex2.pub)] = vertex2
-
-	return &edge1, &edge2, nil
-}
-
-func (m *memChannelGraph) addRandNode() (*btcec.PublicKey, error) {
-	newPub, err := randKey()
-	if err != nil {
-		return nil, err
-	}
-	vertex := &memNode{
-		pub: newPub,
-		addrs: []net.Addr{
-			&net.TCPAddr{
-				IP: bytes.Repeat([]byte("a"), 16),
-			},
-		},
-	}
-	m.graph[NewNodeID(newPub)] = vertex
-
-	return newPub, nil
-}
-
-type testNodeTx struct {
-	db   *testDBGraph
-	node *models.LightningNode
-}
-
-func (t *testNodeTx) Node() *models.LightningNode {
-	return t.node
-}
-
-func (t *testNodeTx) ForEachChannel(f func(*models.ChannelEdgeInfo,
-	*models.ChannelEdgePolicy, *models.ChannelEdgePolicy) error) error {
-
-	return t.db.db.ForEachNodeChannel(t.node.PubKeyBytes, func(
-		edge *models.ChannelEdgeInfo, policy1,
-		policy2 *models.ChannelEdgePolicy) error {
-
-		return f(edge, policy1, policy2)
-	})
-}
-
-func (t *testNodeTx) FetchNode(pub route.Vertex) (graphdb.NodeRTx, error) {
-	node, err := t.db.db.FetchLightningNode(pub)
-	if err != nil {
-		return nil, err
-	}
-
-	return &testNodeTx{
-		db:   t.db,
-		node: node,
-	}, nil
-}
-
-var _ graphdb.NodeRTx = (*testNodeTx)(nil)

autopilot/simple_graph.go

@@ -1,7 +1,5 @@
 package autopilot
 
-import "context"
-
 // diameterCutoff is used to discard nodes in the diameter calculation.
 // It is the multiplier for the eccentricity of the highest-degree node,
 // serving as a cutoff to discard all nodes with a smaller hop distance. This
@@ -22,7 +20,7 @@ type SimpleGraph struct {
 // NewSimpleGraph creates a simplified graph from the current channel graph.
 // Returns an error if the channel graph iteration fails due to underlying
 // failure.
-func NewSimpleGraph(ctx context.Context, g ChannelGraph) (*SimpleGraph, error) {
+func NewSimpleGraph(g ChannelGraph) (*SimpleGraph, error) {
 	nodes := make(map[NodeID]int)
 	adj := make(map[int][]int)
 	nextIndex := 0
@@ -44,22 +42,17 @@ func NewSimpleGraph(ctx context.Context, g ChannelGraph) (*SimpleGraph, error) {
 		return nodeIndex
 	}
 
-	// Iterate over each node and each channel and update the adj and the
-	// node index.
-	err := g.ForEachNode(ctx, func(ctx context.Context, node Node) error {
+	// Iterate over each node and each channel and update the adj and the node
+	// index.
+	err := g.ForEachNode(func(node Node) error {
 		u := getNodeIndex(node)
 
-		return node.ForEachChannel(
-			ctx, func(_ context.Context,
-				edge ChannelEdge) error {
+		return node.ForEachChannel(func(edge ChannelEdge) error {
+			v := getNodeIndex(edge.Peer)
 
-				v := getNodeIndex(edge.Peer)
-
-				adj[u] = append(adj[u], v)
-
-				return nil
-			},
-		)
+			adj[u] = append(adj[u], v)
+			return nil
+		})
 	})
 	if err != nil {
 		return nil, err
@@ -92,7 +85,9 @@ func NewSimpleGraph(ctx context.Context, g ChannelGraph) (*SimpleGraph, error) {
 func maxVal(mapping map[int]uint32) uint32 {
 	maxValue := uint32(0)
 	for _, value := range mapping {
-		maxValue = max(maxValue, value)
+		if maxValue < value {
+			maxValue = value
+		}
 	}
 	return maxValue
 }

autopilot/top_centrality.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"runtime"
 
 	"github.com/btcsuite/btcd/btcutil"
@@ -51,12 +50,12 @@ func (g *TopCentrality) Name() string {
 // As our current implementation of betweenness centrality is non-incremental,
 // NodeScores will recalculate the centrality values on every call, which is
 // slow for large graphs.
-func (g *TopCentrality) NodeScores(ctx context.Context, graph ChannelGraph,
-	chans []LocalChannel, chanSize btcutil.Amount,
-	nodes map[NodeID]struct{}) (map[NodeID]*NodeScore, error) {
+func (g *TopCentrality) NodeScores(graph ChannelGraph, chans []LocalChannel,
+	chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
+	map[NodeID]*NodeScore, error) {
 
 	// Calculate betweenness centrality for the whole graph.
-	if err := g.centralityMetric.Refresh(ctx, graph); err != nil {
+	if err := g.centralityMetric.Refresh(graph); err != nil {
 		return nil, err
 	}
 

autopilot/top_centrality_test.go

@@ -1,7 +1,6 @@
 package autopilot
 
 import (
-	"context"
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2"
@@ -59,7 +58,7 @@ func testTopCentrality(t *testing.T, graph testGraph,
 		// Attempt to get centrality scores and expect
 		// that the result equals with the expected set.
 		scores, err := topCentrality.NodeScores(
-			context.Background(), graph, channels, chanSize, nodes,
+			graph, channels, chanSize, nodes,
 		)
 
 		require.NoError(t, err)

batch/batch.go

@@ -5,7 +5,6 @@ import (
 	"sync"
 
 	"github.com/lightningnetwork/lnd/kvdb"
-	"github.com/lightningnetwork/lnd/sqldb"
 )
 
 // errSolo is a sentinel error indicating that the requester should re-run the
@@ -56,20 +55,8 @@ func (b *batch) run() {
 			for i, req := range b.reqs {
 				err := req.Update(tx)
 				if err != nil {
-					// If we get a serialization error, we
-					// want the underlying SQL retry
-					// mechanism to retry the entire batch.
-					// Otherwise, we can succeed in an
-					// sqldb retry and still re-execute the
-					// failing request individually.
-					dbErr := sqldb.MapSQLError(err)
-					if !sqldb.IsSerializationError(dbErr) {
-						failIdx = i
-
-						return err
-					}
-
-					return dbErr
+					failIdx = i
+					return err
 				}
 			}
 			return nil

batch/batch_test.go

@@ -1,74 +0,0 @@
-package batch
-
-import (
-	"errors"
-	"path/filepath"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/btcsuite/btcwallet/walletdb"
-	"github.com/lightningnetwork/lnd/kvdb"
-	"github.com/stretchr/testify/require"
-)
-
-func TestRetry(t *testing.T) {
-	dbDir := t.TempDir()
-
-	dbName := filepath.Join(dbDir, "weks.db")
-	db, err := walletdb.Create(
-		"bdb", dbName, true, kvdb.DefaultDBTimeout, false,
-	)
-	if err != nil {
-		t.Fatalf("unable to create walletdb: %v", err)
-	}
-	t.Cleanup(func() {
-		db.Close()
-	})
-
-	var (
-		mu     sync.Mutex
-		called int
-	)
-	sched := NewTimeScheduler(db, &mu, time.Second)
-
-	// First, we construct a request that should retry individually and
-	// execute it non-lazily. It should still return the error the second
-	// time.
-	req := &Request{
-		Update: func(tx kvdb.RwTx) error {
-			called++
-
-			return errors.New("test")
-		},
-	}
-	err = sched.Execute(req)
-
-	// Check and reset the called counter.
-	mu.Lock()
-	require.Equal(t, 2, called)
-	called = 0
-	mu.Unlock()
-
-	require.ErrorContains(t, err, "test")
-
-	// Now, we construct a request that should NOT retry because it returns
-	// a serialization error, which should cause the underlying postgres
-	// transaction to retry. Since we aren't using postgres, this will
-	// cause the transaction to not be retried at all.
-	req = &Request{
-		Update: func(tx kvdb.RwTx) error {
-			called++
-
-			return errors.New("could not serialize access")
-		},
-	}
-	err = sched.Execute(req)
-
-	// Check the called counter.
-	mu.Lock()
-	require.Equal(t, 1, called)
-	mu.Unlock()
-
-	require.ErrorContains(t, err, "could not serialize access")
-}

brontide/listener.go

@@ -7,13 +7,12 @@ import (
 	"net"
 	"time"
 
-	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightningnetwork/lnd/keychain"
 )
 
 // defaultHandshakes is the maximum number of handshakes that can be done in
 // parallel.
-const defaultHandshakes = 50
+const defaultHandshakes = 1000
 
 // Listener is an implementation of a net.Conn which executes an authenticated
 // key exchange and message encryption protocol dubbed "Machine" after
@@ -25,10 +24,6 @@ type Listener struct {
 
 	tcp *net.TCPListener
 
-	// shouldAccept is a closure that determines if we should accept the
-	// incoming connection or not based on its public key.
-	shouldAccept func(*btcec.PublicKey) (bool, error)
-
 	handshakeSema chan struct{}
 	conns         chan maybeConn
 	quit          chan struct{}
@@ -39,8 +34,8 @@ var _ net.Listener = (*Listener)(nil)
 
 // NewListener returns a new net.Listener which enforces the Brontide scheme
 // during both initial connection establishment and data transfer.
-func NewListener(localStatic keychain.SingleKeyECDH, listenAddr string,
-	shouldAccept func(*btcec.PublicKey) (bool, error)) (*Listener, error) {
+func NewListener(localStatic keychain.SingleKeyECDH,
+	listenAddr string) (*Listener, error) {
 
 	addr, err := net.ResolveTCPAddr("tcp", listenAddr)
 	if err != nil {
@@ -55,7 +50,6 @@ func NewListener(localStatic keychain.SingleKeyECDH, listenAddr string,
 	brontideListener := &Listener{
 		localStatic:   localStatic,
 		tcp:           l,
-		shouldAccept:  shouldAccept,
 		handshakeSema: make(chan struct{}, defaultHandshakes),
 		conns:         make(chan maybeConn),
 		quit:          make(chan struct{}),
@@ -199,28 +193,6 @@ func (l *Listener) doHandshake(conn net.Conn) {
 		return
 	}
 
-	// Call the shouldAccept closure to see if the remote node's public key
-	// is allowed according to our banning heuristic. This is here because
-	// we do not learn the remote node's public static key until we've
-	// received and validated Act 3.
-	remoteKey := brontideConn.RemotePub()
-	if remoteKey == nil {
-		connErr := fmt.Errorf("no remote pubkey")
-		brontideConn.conn.Close()
-		l.rejectConn(rejectedConnErr(connErr, remoteAddr))
-
-		return
-	}
-
-	accepted, acceptErr := l.shouldAccept(remoteKey)
-	if !accepted {
-		// Reject the connection.
-		brontideConn.conn.Close()
-		l.rejectConn(rejectedConnErr(acceptErr, remoteAddr))
-
-		return
-	}
-
 	l.acceptConn(brontideConn)
 }
 
@@ -283,9 +255,3 @@ func (l *Listener) Close() error {
 func (l *Listener) Addr() net.Addr {
 	return l.tcp.Addr()
 }
-
-// DisabledBanClosure is used in places that NewListener is invoked to bypass
-// the ban-scoring.
-func DisabledBanClosure(p *btcec.PublicKey) (bool, error) {
-	return true, nil
-}

brontide/noise_test.go

@@ -35,7 +35,7 @@ func makeListener() (*Listener, *lnwire.NetAddress, error) {
 	addr := "localhost:0"
 
 	// Our listener will be local, and the connection remote.
-	listener, err := NewListener(localKeyECDH, addr, DisabledBanClosure)
+	listener, err := NewListener(localKeyECDH, addr)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -85,12 +85,12 @@ func establishTestConnection(t testing.TB) (net.Conn, net.Conn, error) {
 
 	remote := <-remoteConnChan
 	if remote.err != nil {
-		return nil, nil, remote.err
+		return nil, nil, err
 	}
 
 	local := <-localConnChan
 	if local.err != nil {
-		return nil, nil, local.err
+		return nil, nil, err
 	}
 
 	t.Cleanup(func() {

build/config.go

@@ -1,99 +0,0 @@
-package build
-
-import (
-	"fmt"
-
-	"github.com/btcsuite/btclog/v2"
-)
-
-const (
-	callSiteOff   = "off"
-	callSiteShort = "short"
-	callSiteLong  = "long"
-
-	defaultLogCompressor = Gzip
-
-	// DefaultMaxLogFiles is the default maximum number of log files to
-	// keep.
-	DefaultMaxLogFiles = 10
-
-	// DefaultMaxLogFileSize is the default maximum log file size in MB.
-	DefaultMaxLogFileSize = 20
-)
-
-// LogConfig holds logging configuration options.
-//
-//nolint:ll
-type LogConfig struct {
-	Console      *consoleLoggerCfg `group:"console" namespace:"console" description:"The logger writing to stdout and stderr."`
-	File         *FileLoggerConfig `group:"file" namespace:"file" description:"The logger writing to LND's standard log file."`
-	NoCommitHash bool              `long:"no-commit-hash" description:"If set, the commit-hash of the current build will not be included in log lines by default."`
-}
-
-// Validate validates the LogConfig struct values.
-func (c *LogConfig) Validate() error {
-	if !SupportedLogCompressor(c.File.Compressor) {
-		return fmt.Errorf("invalid log compressor: %v",
-			c.File.Compressor)
-	}
-
-	return nil
-}
-
-// LoggerConfig holds options for a particular logger.
-//
-//nolint:ll
-type LoggerConfig struct {
-	Disable      bool   `long:"disable" description:"Disable this logger."`
-	NoTimestamps bool   `long:"no-timestamps" description:"Omit timestamps from log lines."`
-	CallSite     string `long:"call-site" description:"Include the call-site of each log line." choice:"off" choice:"short" choice:"long"`
-}
-
-// DefaultLogConfig returns the default logging config options.
-func DefaultLogConfig() *LogConfig {
-	return &LogConfig{
-		Console: defaultConsoleLoggerCfg(),
-		File: &FileLoggerConfig{
-			Compressor:     defaultLogCompressor,
-			MaxLogFiles:    DefaultMaxLogFiles,
-			MaxLogFileSize: DefaultMaxLogFileSize,
-			LoggerConfig: &LoggerConfig{
-				CallSite: callSiteOff,
-			},
-		},
-	}
-}
-
-// HandlerOptions returns the set of btclog.HandlerOptions that the state of the
-// config struct translates to.
-func (cfg *LoggerConfig) HandlerOptions() []btclog.HandlerOption {
-	opts := []btclog.HandlerOption{
-		// We wrap the logger provided by the logging library with
-		// another layer of abstraction with the handlerSet, and so we
-		// need to increase the default skip depth by 1.
-		btclog.WithCallSiteSkipDepth(btclog.DefaultSkipDepth + 1),
-	}
-
-	if cfg.NoTimestamps {
-		opts = append(opts, btclog.WithNoTimestamp())
-	}
-
-	switch cfg.CallSite {
-	case callSiteShort:
-		opts = append(opts, btclog.WithCallerFlags(btclog.Lshortfile))
-	case callSiteLong:
-		opts = append(opts, btclog.WithCallerFlags(btclog.Llongfile))
-	}
-
-	return opts
-}
-
-// FileLoggerConfig extends LoggerConfig with specific log file options.
-//
-//nolint:ll
-type FileLoggerConfig struct {
-	*LoggerConfig  `yaml:",inline"`
-	Compressor     string `long:"compressor" description:"Compression algorithm to use when rotating logs." choice:"gzip" choice:"zstd"`
-	MaxLogFiles    int    `long:"max-files" description:"Maximum logfiles to keep (0 for no rotation)"`
-	MaxLogFileSize int    `long:"max-file-size" description:"Maximum logfile size in MB"`
-}

build/config_dev.go

@@ -1,112 +0,0 @@
-//go:build dev
-// +build dev
-
-package build
-
-import (
-	"fmt"
-	"strings"
-
-	btclogv1 "github.com/btcsuite/btclog"
-	"github.com/btcsuite/btclog/v2"
-)
-
-const (
-	resetSeq = "0"
-	boldSeq  = "1"
-	faintSeq = "2"
-	esc      = '\x1b'
-	csi      = string(esc) + "["
-)
-
-// consoleLoggerCfg extends the LoggerConfig struct by adding a Color option
-// which is only available for a console logger.
-//
-//nolint:ll
-type consoleLoggerCfg struct {
-	*LoggerConfig `yaml:",inline"`
-	Style         bool `long:"style" description:"If set, the output will be styled with color and fonts"`
-}
-
-// defaultConsoleLoggerCfg returns the default consoleLoggerCfg for the dev
-// console logger.
-func defaultConsoleLoggerCfg() *consoleLoggerCfg {
-	return &consoleLoggerCfg{
-		LoggerConfig: &LoggerConfig{
-			CallSite: callSiteShort,
-		},
-	}
-}
-
-// HandlerOptions returns the set of btclog.HandlerOptions that the state of the
-// config struct translates to.
-func (cfg *consoleLoggerCfg) HandlerOptions() []btclog.HandlerOption {
-	opts := cfg.LoggerConfig.HandlerOptions()
-
-	if !cfg.Style {
-		return opts
-	}
-
-	return append(
-		opts, btclog.WithStyledLevel(
-			func(l btclogv1.Level) string {
-				return styleString(
-					fmt.Sprintf("[%s]", l),
-					boldSeq,
-					string(ansiColoSeq(l)),
-				)
-			},
-		),
-		btclog.WithStyledCallSite(
-			func(file string, line int) string {
-				str := fmt.Sprintf("%s:%d", file, line)
-
-				return styleString(str, faintSeq)
-			},
-		),
-		btclog.WithStyledKeys(func(key string) string {
-			return styleString(key, faintSeq)
-		}),
-	)
-}
-
-func styleString(s string, styles ...string) string {
-	if len(styles) == 0 {
-		return s
-	}
-
-	seq := strings.Join(styles, ";")
-	if seq == "" {
-		return s
-	}
-
-	return fmt.Sprintf("%s%sm%s%sm", csi, seq, s, csi+resetSeq)
-}
-
-type ansiColorSeq string
-
-const (
-	ansiColorSeqDarkTeal  ansiColorSeq = "38;5;30"
-	ansiColorSeqDarkBlue  ansiColorSeq = "38;5;63"
-	ansiColorSeqLightBlue ansiColorSeq = "38;5;86"
-	ansiColorSeqYellow    ansiColorSeq = "38;5;192"
-	ansiColorSeqRed       ansiColorSeq = "38;5;204"
-	ansiColorSeqPink      ansiColorSeq = "38;5;134"
-)
-
-func ansiColoSeq(l btclogv1.Level) ansiColorSeq {
-	switch l {
-	case btclog.LevelTrace:
-		return ansiColorSeqDarkTeal
-	case btclog.LevelDebug:
-		return ansiColorSeqDarkBlue
-	case btclog.LevelWarn:
-		return ansiColorSeqYellow
-	case btclog.LevelError:
-		return ansiColorSeqRed
-	case btclog.LevelCritical:
-		return ansiColorSeqPink
-	default:
-		return ansiColorSeqLightBlue
-	}
-}

build/config_prod.go

@@ -1,22 +0,0 @@
-//go:build !dev
-// +build !dev
-
-package build
-
-// consoleLoggerCfg embeds the LoggerConfig struct along with any extensions
-// specific to a production deployment.
-//
-//nolint:ll
-type consoleLoggerCfg struct {
-	*LoggerConfig `yaml:",inline"`
-}
-
-// defaultConsoleLoggerCfg returns the default consoleLoggerCfg for the prod
-// console logger.
-func defaultConsoleLoggerCfg() *consoleLoggerCfg {
-	return &consoleLoggerCfg{
-		LoggerConfig: &LoggerConfig{
-			CallSite: callSiteOff,
-		},
-	}
-}

build/handler_sets.go

@@ -1,214 +0,0 @@
-package build
-
-import (
-	"context"
-	"log/slog"
-
-	btclogv1 "github.com/btcsuite/btclog"
-	"github.com/btcsuite/btclog/v2"
-)
-
-// handlerSet is an implementation of Handler that abstracts away multiple
-// Handlers.
-type handlerSet struct {
-	level btclogv1.Level
-	set   []btclog.Handler
-}
-
-// newHandlerSet constructs a new HandlerSet.
-func newHandlerSet(level btclogv1.Level, set ...btclog.Handler) *handlerSet {
-	h := &handlerSet{
-		set:   set,
-		level: level,
-	}
-	h.SetLevel(level)
-
-	return h
-}
-
-// Enabled reports whether the handler handles records at the given level.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (h *handlerSet) Enabled(ctx context.Context, level slog.Level) bool {
-	for _, handler := range h.set {
-		if !handler.Enabled(ctx, level) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// Handle handles the Record.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (h *handlerSet) Handle(ctx context.Context, record slog.Record) error {
-	for _, handler := range h.set {
-		if err := handler.Handle(ctx, record); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// WithAttrs returns a new Handler whose attributes consist of both the
-// receiver's attributes and the arguments.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (h *handlerSet) WithAttrs(attrs []slog.Attr) slog.Handler {
-	newSet := &reducedSet{set: make([]slog.Handler, len(h.set))}
-	for i, handler := range h.set {
-		newSet.set[i] = handler.WithAttrs(attrs)
-	}
-
-	return newSet
-}
-
-// WithGroup returns a new Handler with the given group appended to the
-// receiver's existing groups.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (h *handlerSet) WithGroup(name string) slog.Handler {
-	newSet := &reducedSet{set: make([]slog.Handler, len(h.set))}
-	for i, handler := range h.set {
-		newSet.set[i] = handler.WithGroup(name)
-	}
-
-	return newSet
-}
-
-// SubSystem creates a new Handler with the given sub-system tag.
-//
-// NOTE: this is part of the Handler interface.
-func (h *handlerSet) SubSystem(tag string) btclog.Handler {
-	newSet := &handlerSet{set: make([]btclog.Handler, len(h.set))}
-	for i, handler := range h.set {
-		newSet.set[i] = handler.SubSystem(tag)
-	}
-
-	return newSet
-}
-
-// SetLevel changes the logging level of the Handler to the passed
-// level.
-//
-// NOTE: this is part of the btclog.Handler interface.
-func (h *handlerSet) SetLevel(level btclogv1.Level) {
-	for _, handler := range h.set {
-		handler.SetLevel(level)
-	}
-	h.level = level
-}
-
-// Level returns the current logging level of the Handler.
-//
-// NOTE: this is part of the btclog.Handler interface.
-func (h *handlerSet) Level() btclogv1.Level {
-	return h.level
-}
-
-// WithPrefix returns a copy of the Handler but with the given string prefixed
-// to each log message.
-//
-// NOTE: this is part of the btclog.Handler interface.
-func (h *handlerSet) WithPrefix(prefix string) btclog.Handler {
-	newSet := &handlerSet{set: make([]btclog.Handler, len(h.set))}
-	for i, handler := range h.set {
-		newSet.set[i] = handler.WithPrefix(prefix)
-	}
-
-	return newSet
-}
-
-// A compile-time check to ensure that handlerSet implements btclog.Handler.
-var _ btclog.Handler = (*handlerSet)(nil)
-
-// reducedSet is an implementation of the slog.Handler interface which is
-// itself backed by multiple slog.Handlers. This is used by the handlerSet
-// WithGroup and WithAttrs methods so that we can apply the WithGroup and
-// WithAttrs to the underlying handlers in the set. These calls, however,
-// produce slog.Handlers and not btclog.Handlers. So the reducedSet represents
-// the resulting set produced.
-type reducedSet struct {
-	set []slog.Handler
-}
-
-// Enabled reports whether the handler handles records at the given level.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (r *reducedSet) Enabled(ctx context.Context, level slog.Level) bool {
-	for _, handler := range r.set {
-		if !handler.Enabled(ctx, level) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// Handle handles the Record.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (r *reducedSet) Handle(ctx context.Context, record slog.Record) error {
-	for _, handler := range r.set {
-		if err := handler.Handle(ctx, record); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// WithAttrs returns a new Handler whose attributes consist of both the
-// receiver's attributes and the arguments.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (r *reducedSet) WithAttrs(attrs []slog.Attr) slog.Handler {
-	newSet := &reducedSet{set: make([]slog.Handler, len(r.set))}
-	for i, handler := range r.set {
-		newSet.set[i] = handler.WithAttrs(attrs)
-	}
-
-	return newSet
-}
-
-// WithGroup returns a new Handler with the given group appended to the
-// receiver's existing groups.
-//
-// NOTE: this is part of the slog.Handler interface.
-func (r *reducedSet) WithGroup(name string) slog.Handler {
-	newSet := &reducedSet{set: make([]slog.Handler, len(r.set))}
-	for i, handler := range r.set {
-		newSet.set[i] = handler.WithGroup(name)
-	}
-
-	return newSet
-}
-
-// A compile-time check to ensure that handlerSet implements slog.Handler.
-var _ slog.Handler = (*reducedSet)(nil)
-
-// subLogGenerator implements the SubLogCreator backed by a Handler.
-type subLogGenerator struct {
-	handler btclog.Handler
-}
-
-// newSubLogGenerator constructs a new subLogGenerator from a Handler.
-func newSubLogGenerator(handler btclog.Handler) *subLogGenerator {
-	return &subLogGenerator{
-		handler: handler,
-	}
-}
-
-// Logger returns a new logger for a particular sub-system.
-//
-// NOTE: this is part of the SubLogCreator interface.
-func (b *subLogGenerator) Logger(subsystemTag string) btclog.Logger {
-	handler := b.handler.SubSystem(subsystemTag)
-
-	return btclog.NewSLogger(handler)
-}
-
-// A compile-time check to ensure that handlerSet implements slog.Handler.
-var _ SubLogCreator = (*subLogGenerator)(nil)

build/handlers.go

@@ -1,38 +0,0 @@
-package build
-
-import (
-	"os"
-
-	"github.com/btcsuite/btclog/v2"
-)
-
-// NewDefaultLogHandlers returns the standard console logger and rotating log
-// writer handlers that we generally want to use. It also applies the various
-// config options to the loggers.
-func NewDefaultLogHandlers(cfg *LogConfig,
-	rotator *RotatingLogWriter) []btclog.Handler {
-
-	var handlers []btclog.Handler
-
-	consoleLogHandler := btclog.NewDefaultHandler(
-		os.Stdout, cfg.Console.HandlerOptions()...,
-	)
-	logFileHandler := btclog.NewDefaultHandler(
-		rotator, cfg.File.HandlerOptions()...,
-	)
-
-	maybeAddLogger := func(cmdOptionDisable bool, handler btclog.Handler) {
-		if !cmdOptionDisable {
-			handlers = append(handlers, handler)
-		}
-	}
-	switch LoggingType {
-	case LogTypeStdOut:
-		maybeAddLogger(cfg.Console.Disable, consoleLogHandler)
-	case LogTypeDefault:
-		maybeAddLogger(cfg.Console.Disable, consoleLogHandler)
-		maybeAddLogger(cfg.File.Disable, logFileHandler)
-	}
-
-	return handlers
-}

build/log.go

@@ -1,9 +1,11 @@
 package build
 
 import (
-	"os"
+	"fmt"
+	"io"
+	"strings"
 
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 )
 
 // LogType is an indicating the type of logging specified by the build flag.
@@ -34,30 +36,15 @@ func (t LogType) String() string {
 	}
 }
 
-// Declare the supported log file compressors as exported consts for easier use
-// from other projects.
-const (
-	// Gzip is the default compressor.
-	Gzip = "gzip"
-
-	// Zstd is a modern compressor that compresses better than Gzip, in less
-	// time.
-	Zstd = "zstd"
-)
-
-// logCompressors maps the identifier for each supported compression algorithm
-// to the extension used for the compressed log files.
-var logCompressors = map[string]string{
-	Gzip: "gz",
-	Zstd: "zst",
-}
-
-// SupportedLogCompressor returns whether or not logCompressor is a supported
-// compression algorithm for log files.
-func SupportedLogCompressor(logCompressor string) bool {
-	_, ok := logCompressors[logCompressor]
-
-	return ok
+// LogWriter is a stub type whose behavior can be changed using the build flags
+// "stdlog" and "nolog". The default behavior is to write to both stdout and the
+// RotatorPipe. Passing "stdlog" will cause it only to write to stdout, and
+// "nolog" implements Write as a no-op.
+type LogWriter struct {
+	// RotatorPipe is the write-end pipe for writing to the log rotator.  It
+	// is written to by the Write method of the LogWriter type. This only
+	// needs to be set if neither the stdlog or nolog builds are set.
+	RotatorPipe *io.PipeWriter
 }
 
 // NewSubLogger constructs a new subsystem log from the current LogWriter
@@ -93,10 +80,8 @@ func NewSubLogger(subsystem string,
 		// that they share the same backend, since all output is written
 		// to std out.
 		case LogTypeStdOut:
-			backend := btclog.NewDefaultHandler(os.Stdout)
-			logger := btclog.NewSLogger(
-				backend.SubSystem(subsystem),
-			)
+			backend := btclog.NewBackend(&LogWriter{})
+			logger := backend.Logger(subsystem)
 
 			// Set the logging level of the stdout logger to use the
 			// configured logging level specified by build flags.
@@ -110,3 +95,114 @@ func NewSubLogger(subsystem string,
 	// For any other configurations, we'll disable logging.
 	return btclog.Disabled
 }
+
+// SubLoggers is a type that holds a map of subsystem loggers keyed by their
+// subsystem name.
+type SubLoggers map[string]btclog.Logger
+
+// LeveledSubLogger provides the ability to retrieve the subsystem loggers of
+// a logger and set their log levels individually or all at once.
+type LeveledSubLogger interface {
+	// SubLoggers returns the map of all registered subsystem loggers.
+	SubLoggers() SubLoggers
+
+	// SupportedSubsystems returns a slice of strings containing the names
+	// of the supported subsystems. Should ideally correspond to the keys
+	// of the subsystem logger map and be sorted.
+	SupportedSubsystems() []string
+
+	// SetLogLevel assigns an individual subsystem logger a new log level.
+	SetLogLevel(subsystemID string, logLevel string)
+
+	// SetLogLevels assigns all subsystem loggers the same new log level.
+	SetLogLevels(logLevel string)
+}
+
+// ParseAndSetDebugLevels attempts to parse the specified debug level and set
+// the levels accordingly on the given logger. An appropriate error is returned
+// if anything is invalid.
+func ParseAndSetDebugLevels(level string, logger LeveledSubLogger) error {
+	// Split at the delimiter.
+	levels := strings.Split(level, ",")
+	if len(levels) == 0 {
+		return fmt.Errorf("invalid log level: %v", level)
+	}
+
+	// If the first entry has no =, treat is as the log level for all
+	// subsystems.
+	globalLevel := levels[0]
+	if !strings.Contains(globalLevel, "=") {
+		// Validate debug log level.
+		if !validLogLevel(globalLevel) {
+			str := "the specified debug level [%v] is invalid"
+			return fmt.Errorf(str, globalLevel)
+		}
+
+		// Change the logging level for all subsystems.
+		logger.SetLogLevels(globalLevel)
+
+		// The rest will target specific subsystems.
+		levels = levels[1:]
+	}
+
+	// Go through the subsystem/level pairs while detecting issues and
+	// update the log levels accordingly.
+	for _, logLevelPair := range levels {
+		if !strings.Contains(logLevelPair, "=") {
+			str := "the specified debug level contains an " +
+				"invalid subsystem/level pair [%v]"
+			return fmt.Errorf(str, logLevelPair)
+		}
+
+		// Extract the specified subsystem and log level.
+		fields := strings.Split(logLevelPair, "=")
+		if len(fields) != 2 {
+			str := "the specified debug level has an invalid " +
+				"format [%v] -- use format subsystem1=level1," +
+				"subsystem2=level2"
+			return fmt.Errorf(str, logLevelPair)
+		}
+		subsysID, logLevel := fields[0], fields[1]
+		subLoggers := logger.SubLoggers()
+
+		// Validate subsystem.
+		if _, exists := subLoggers[subsysID]; !exists {
+			str := "the specified subsystem [%v] is invalid -- " +
+				"supported subsystems are %v"
+			return fmt.Errorf(
+				str, subsysID, logger.SupportedSubsystems(),
+			)
+		}
+
+		// Validate log level.
+		if !validLogLevel(logLevel) {
+			str := "the specified debug level [%v] is invalid"
+			return fmt.Errorf(str, logLevel)
+		}
+
+		logger.SetLogLevel(subsysID, logLevel)
+	}
+
+	return nil
+}
+
+// validLogLevel returns whether or not logLevel is a valid debug log level.
+func validLogLevel(logLevel string) bool {
+	switch logLevel {
+	case "trace":
+		fallthrough
+	case "debug":
+		fallthrough
+	case "info":
+		fallthrough
+	case "warn":
+		fallthrough
+	case "error":
+		fallthrough
+	case "critical":
+		fallthrough
+	case "off":
+		return true
+	}
+	return false
+}

build/log_default.go

@@ -3,6 +3,17 @@
 
 package build
 
+import "os"
+
 // LoggingType is a log type that writes to both stdout and the log rotator, if
 // present.
 const LoggingType = LogTypeDefault
+
+// Write writes the byte slice to both stdout and the log rotator, if present.
+func (w *LogWriter) Write(b []byte) (int, error) {
+	os.Stdout.Write(b)
+	if w.RotatorPipe != nil {
+		w.RotatorPipe.Write(b)
+	}
+	return len(b), nil
+}

build/log_nolog.go

@@ -5,3 +5,8 @@ package build
 
 // LoggingType is a log type that writes no logs.
 const LoggingType = LogTypeNone
+
+// Write is a noop.
+func (w *LogWriter) Write(b []byte) (int, error) {
+	return len(b), nil
+}

build/log_shutdown.go

@@ -1,9 +1,7 @@
 package build
 
 import (
-	"context"
-
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 )
 
 // ShutdownLogger wraps an existing logger with a shutdown function which will
@@ -43,16 +41,3 @@ func (s *ShutdownLogger) Critical(v ...interface{}) {
 	s.Logger.Info("Sending request for shutdown")
 	s.shutdown()
 }
-
-// CriticalS writes a structured log with the given message and key-value pair
-// attributes with LevelCritical to the log. It will then call the shutdown
-// logger's shutdown function to prompt safe shutdown.
-//
-// Note: it is part of the btclog.Logger interface.
-func (s *ShutdownLogger) CriticalS(ctx context.Context, msg string, err error,
-	attr ...interface{}) {
-
-	s.Logger.CriticalS(ctx, msg, err, attr...)
-	s.Logger.Info("Sending request for shutdown")
-	s.shutdown()
-}

build/log_stdlog.go

@@ -3,5 +3,13 @@
 
 package build
 
+import "os"
+
 // LoggingType is a log type that only writes to stdout.
 const LoggingType = LogTypeStdOut
+
+// Write writes the provided byte slice to stdout.
+func (w *LogWriter) Write(b []byte) (int, error) {
+	os.Stdout.Write(b)
+	return len(b), nil
+}

build/log_test.go

@@ -3,7 +3,7 @@ package build_test
 import (
 	"testing"
 
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/stretchr/testify/require"
 )

build/logrotator.go

@@ -1,105 +1,153 @@
 package build
 
 import (
-	"compress/gzip"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
+	"sort"
 
+	"github.com/btcsuite/btclog"
 	"github.com/jrick/logrotate/rotator"
-	"github.com/klauspost/compress/zstd"
 )
 
 // RotatingLogWriter is a wrapper around the LogWriter that supports log file
 // rotation.
 type RotatingLogWriter struct {
-	// pipe is the write-end pipe for writing to the log rotator.
-	pipe *io.PipeWriter
+	logWriter *LogWriter
 
-	rotator *rotator.Rotator
+	backendLog *btclog.Backend
+
+	logRotator *rotator.Rotator
+
+	subsystemLoggers SubLoggers
 }
 
+// A compile time check to ensure RotatingLogWriter implements the
+// LeveledSubLogger interface.
+var _ LeveledSubLogger = (*RotatingLogWriter)(nil)
+
 // NewRotatingLogWriter creates a new file rotating log writer.
 //
 // NOTE: `InitLogRotator` must be called to set up log rotation after creating
 // the writer.
 func NewRotatingLogWriter() *RotatingLogWriter {
-	return &RotatingLogWriter{}
+	logWriter := &LogWriter{}
+	backendLog := btclog.NewBackend(logWriter)
+	return &RotatingLogWriter{
+		logWriter:        logWriter,
+		backendLog:       backendLog,
+		subsystemLoggers: SubLoggers{},
+	}
+}
+
+// GenSubLogger creates a new sublogger. A shutdown callback function
+// is provided to be able to shutdown in case of a critical error.
+func (r *RotatingLogWriter) GenSubLogger(tag string, shutdown func()) btclog.Logger {
+	logger := r.backendLog.Logger(tag)
+	return NewShutdownLogger(logger, shutdown)
+}
+
+// RegisterSubLogger registers a new subsystem logger.
+func (r *RotatingLogWriter) RegisterSubLogger(subsystem string,
+	logger btclog.Logger) {
+
+	r.subsystemLoggers[subsystem] = logger
 }
 
 // InitLogRotator initializes the log file rotator to write logs to logFile and
 // create roll files in the same directory. It should be called as early on
 // startup and possible and must be closed on shutdown by calling `Close`.
-func (r *RotatingLogWriter) InitLogRotator(cfg *FileLoggerConfig,
-	logFile string) error {
+func (r *RotatingLogWriter) InitLogRotator(logFile string, maxLogFileSize int,
+	maxLogFiles int) error {
 
 	logDir, _ := filepath.Split(logFile)
 	err := os.MkdirAll(logDir, 0700)
 	if err != nil {
 		return fmt.Errorf("failed to create log directory: %w", err)
 	}
-
-	r.rotator, err = rotator.New(
-		logFile, int64(cfg.MaxLogFileSize*1024), false, cfg.MaxLogFiles,
+	r.logRotator, err = rotator.New(
+		logFile, int64(maxLogFileSize*1024), false, maxLogFiles,
 	)
 	if err != nil {
 		return fmt.Errorf("failed to create file rotator: %w", err)
 	}
 
-	// Reject unknown compressors.
-	if !SupportedLogCompressor(cfg.Compressor) {
-		return fmt.Errorf("unknown log compressor: %v", cfg.Compressor)
-	}
-
-	var c rotator.Compressor
-	switch cfg.Compressor {
-	case Gzip:
-		c = gzip.NewWriter(nil)
-
-	case Zstd:
-		c, err = zstd.NewWriter(nil)
-		if err != nil {
-			return fmt.Errorf("failed to create zstd compressor: "+
-				"%w", err)
-		}
-	}
-
-	// Apply the compressor and its file suffix to the log rotator.
-	r.rotator.SetCompressor(c, logCompressors[cfg.Compressor])
-
 	// Run rotator as a goroutine now but make sure we catch any errors
 	// that happen in case something with the rotation goes wrong during
 	// runtime (like running out of disk space or not being allowed to
 	// create a new logfile for whatever reason).
 	pr, pw := io.Pipe()
 	go func() {
-		err := r.rotator.Run(pr)
+		err := r.logRotator.Run(pr)
 		if err != nil {
 			_, _ = fmt.Fprintf(os.Stderr,
 				"failed to run file rotator: %v\n", err)
 		}
 	}()
 
-	r.pipe = pw
-
+	r.logWriter.RotatorPipe = pw
 	return nil
 }
 
-// Write writes the byte slice to the log rotator, if present.
-func (r *RotatingLogWriter) Write(b []byte) (int, error) {
-	if r.rotator != nil {
-		return r.rotator.Write(b)
-	}
-
-	return len(b), nil
-}
-
 // Close closes the underlying log rotator if it has already been created.
 func (r *RotatingLogWriter) Close() error {
-	if r.rotator != nil {
-		return r.rotator.Close()
+	if r.logRotator != nil {
+		return r.logRotator.Close()
 	}
-
 	return nil
 }
+
+// SubLoggers returns all currently registered subsystem loggers for this log
+// writer.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *RotatingLogWriter) SubLoggers() SubLoggers {
+	return r.subsystemLoggers
+}
+
+// SupportedSubsystems returns a sorted string slice of all keys in the
+// subsystems map, corresponding to the names of the subsystems.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *RotatingLogWriter) SupportedSubsystems() []string {
+	// Convert the subsystemLoggers map keys to a string slice.
+	subsystems := make([]string, 0, len(r.subsystemLoggers))
+	for subsysID := range r.subsystemLoggers {
+		subsystems = append(subsystems, subsysID)
+	}
+
+	// Sort the subsystems for stable display.
+	sort.Strings(subsystems)
+	return subsystems
+}
+
+// SetLogLevel sets the logging level for provided subsystem. Invalid
+// subsystems are ignored. Uninitialized subsystems are dynamically created as
+// needed.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *RotatingLogWriter) SetLogLevel(subsystemID string, logLevel string) {
+	// Ignore invalid subsystems.
+	logger, ok := r.subsystemLoggers[subsystemID]
+	if !ok {
+		return
+	}
+
+	// Defaults to info if the log level is invalid.
+	level, _ := btclog.LevelFromString(logLevel)
+	logger.SetLevel(level)
+}
+
+// SetLogLevels sets the log level for all subsystem loggers to the passed
+// level. It also dynamically creates the subsystem loggers as needed, so it
+// can be used to initialize the logging system.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *RotatingLogWriter) SetLogLevels(logLevel string) {
+	// Configure all sub-systems with the new logging level. Dynamically
+	// create loggers as needed.
+	for subsystemID := range r.subsystemLoggers {
+		r.SetLogLevel(subsystemID, logLevel)
+	}
+}

build/prefix_log.go

@@ -0,0 +1,112 @@
+package build
+
+import "github.com/btcsuite/btclog"
+
+// PrefixLog is a pass-through logger that adds a prefix to every logged line.
+type PrefixLog struct {
+	log    btclog.Logger
+	prefix string
+}
+
+// NewPrefixLog instantiates a new prefixed logger.
+func NewPrefixLog(prefix string, log btclog.Logger) *PrefixLog {
+	return &PrefixLog{
+		prefix: prefix,
+		log:    log,
+	}
+}
+
+// addFormatPrefix prepends the prefix to a format string.
+func (p *PrefixLog) addFormatPrefix(s string) string {
+	return p.prefix + " " + s
+}
+
+// addArgsPrefix prepends the prefix to a list of arguments.
+func (p *PrefixLog) addArgsPrefix(args []interface{}) []interface{} {
+	return append([]interface{}{p.prefix}, args...)
+}
+
+// Tracef formats message according to format specifier and writes to to log
+// with LevelTrace.
+func (p *PrefixLog) Tracef(format string, params ...interface{}) {
+	p.log.Tracef(p.addFormatPrefix(format), params...)
+}
+
+// Debugf formats message according to format specifier and writes to log with
+// LevelDebug.
+func (p *PrefixLog) Debugf(format string, params ...interface{}) {
+	p.log.Debugf(p.addFormatPrefix(format), params...)
+}
+
+// Infof formats message according to format specifier and writes to log with
+// LevelInfo.
+func (p *PrefixLog) Infof(format string, params ...interface{}) {
+	p.log.Infof(p.addFormatPrefix(format), params...)
+}
+
+// Warnf formats message according to format specifier and writes to to log with
+// LevelWarn.
+func (p *PrefixLog) Warnf(format string, params ...interface{}) {
+	p.log.Warnf(p.addFormatPrefix(format), params...)
+}
+
+// Errorf formats message according to format specifier and writes to to log
+// with LevelError.
+func (p *PrefixLog) Errorf(format string, params ...interface{}) {
+	p.log.Errorf(p.addFormatPrefix(format), params...)
+}
+
+// Criticalf formats message according to format specifier and writes to log
+// with LevelCritical.
+func (p *PrefixLog) Criticalf(format string, params ...interface{}) {
+	p.log.Criticalf(p.addFormatPrefix(format), params...)
+}
+
+// Trace formats message using the default formats for its operands and writes
+// to log with LevelTrace.
+func (p *PrefixLog) Trace(v ...interface{}) {
+	p.log.Trace(p.addArgsPrefix(v)...)
+}
+
+// Debug formats message using the default formats for its operands and writes
+// to log with LevelDebug.
+func (p *PrefixLog) Debug(v ...interface{}) {
+	p.log.Debug(p.addArgsPrefix(v)...)
+}
+
+// Info formats message using the default formats for its operands and writes to
+// log with LevelInfo.
+func (p *PrefixLog) Info(v ...interface{}) {
+	p.log.Info(p.addArgsPrefix(v)...)
+}
+
+// Warn formats message using the default formats for its operands and writes to
+// log with LevelWarn.
+func (p *PrefixLog) Warn(v ...interface{}) {
+	p.log.Warn(p.addArgsPrefix(v)...)
+}
+
+// Error formats message using the default formats for its operands and writes
+// to log with LevelError.
+func (p *PrefixLog) Error(v ...interface{}) {
+	p.log.Error(p.addArgsPrefix(v)...)
+}
+
+// Critical formats message using the default formats for its operands and
+// writes to log with LevelCritical.
+func (p *PrefixLog) Critical(v ...interface{}) {
+	p.log.Critical(p.addArgsPrefix(v)...)
+}
+
+// Level returns the current logging level.
+func (p *PrefixLog) Level() btclog.Level {
+	return p.log.Level()
+}
+
+// SetLevel changes the logging level to the passed level.
+func (p *PrefixLog) SetLevel(level btclog.Level) {
+	p.log.SetLevel(level)
+}
+
+// Assert that PrefixLog fulfills the btclog.Logger interface.
+var _ btclog.Logger = &PrefixLog{}

build/sub_logger.go

@@ -1,263 +0,0 @@
-package build
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-	"sync"
-
-	"github.com/btcsuite/btclog/v2"
-)
-
-// SubLogCreator can be used to create a new logger for a particular subsystem.
-type SubLogCreator interface {
-	// Logger returns a new logger for a particular subsystem.
-	Logger(subsystemTag string) btclog.Logger
-}
-
-// SubLoggerManager manages a set of subsystem loggers. Level updates will be
-// applied to all the loggers managed by the manager.
-type SubLoggerManager struct {
-	genLogger SubLogCreator
-
-	loggers SubLoggers
-	mu      sync.Mutex
-}
-
-// A compile time check to ensure SubLoggerManager implements the
-// LeveledSubLogger interface.
-var _ LeveledSubLogger = (*SubLoggerManager)(nil)
-
-// NewSubLoggerManager constructs a new SubLoggerManager.
-func NewSubLoggerManager(handlers ...btclog.Handler) *SubLoggerManager {
-	return &SubLoggerManager{
-		loggers: make(SubLoggers),
-		genLogger: newSubLogGenerator(
-			newHandlerSet(btclog.LevelInfo, handlers...),
-		),
-	}
-}
-
-// GenSubLogger creates a new sub-logger and adds it to the set managed by the
-// SubLoggerManager. A shutdown callback function is provided to be able to shut
-// down in case of a critical error.
-func (r *SubLoggerManager) GenSubLogger(subsystem string,
-	shutdown func()) btclog.Logger {
-
-	// Create a new logger with the given subsystem tag.
-	logger := r.genLogger.Logger(subsystem)
-
-	// Wrap the new logger in a Shutdown logger so that the shutdown
-	// call back is called if a critical log is ever written via this new
-	// logger.
-	l := NewShutdownLogger(logger, shutdown)
-
-	r.RegisterSubLogger(subsystem, l)
-
-	return l
-}
-
-// RegisterSubLogger registers the given logger under the given subsystem name.
-func (r *SubLoggerManager) RegisterSubLogger(subsystem string,
-	logger btclog.Logger) {
-
-	// Add the new logger to the set of loggers managed by the manager.
-	r.mu.Lock()
-	r.loggers[subsystem] = logger
-	r.mu.Unlock()
-}
-
-// SubLoggers returns all currently registered subsystem loggers for this log
-// writer.
-//
-// NOTE: This is part of the LeveledSubLogger interface.
-func (r *SubLoggerManager) SubLoggers() SubLoggers {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	return r.loggers
-}
-
-// SupportedSubsystems returns a sorted string slice of all keys in the
-// subsystems map, corresponding to the names of the subsystems.
-//
-// NOTE: This is part of the LeveledSubLogger interface.
-func (r *SubLoggerManager) SupportedSubsystems() []string {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	// Convert the subsystemLoggers map keys to a string slice.
-	subsystems := make([]string, 0, len(r.loggers))
-	for subsysID := range r.loggers {
-		subsystems = append(subsystems, subsysID)
-	}
-
-	// Sort the subsystems for stable display.
-	sort.Strings(subsystems)
-
-	return subsystems
-}
-
-// SetLogLevel sets the logging level for provided subsystem. Invalid
-// subsystems are ignored. Uninitialized subsystems are dynamically created as
-// needed.
-//
-// NOTE: This is part of the LeveledSubLogger interface.
-func (r *SubLoggerManager) SetLogLevel(subsystemID string, logLevel string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	r.setLogLevelUnsafe(subsystemID, logLevel)
-}
-
-// setLogLevelUnsafe sets the logging level for provided subsystem. Invalid
-// subsystems are ignored. Uninitialized subsystems are dynamically created as
-// needed.
-//
-// NOTE: the SubLoggerManager mutex must be held before calling this method.
-func (r *SubLoggerManager) setLogLevelUnsafe(subsystemID string,
-	logLevel string) {
-
-	// Ignore invalid subsystems.
-	logger, ok := r.loggers[subsystemID]
-	if !ok {
-		return
-	}
-
-	// Defaults to info if the log level is invalid.
-	level, _ := btclog.LevelFromString(logLevel)
-
-	logger.SetLevel(level)
-}
-
-// SetLogLevels sets the log level for all subsystem loggers to the passed
-// level. It also dynamically creates the subsystem loggers as needed, so it
-// can be used to initialize the logging system.
-//
-// NOTE: This is part of the LeveledSubLogger interface.
-func (r *SubLoggerManager) SetLogLevels(logLevel string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	// Configure all sub-systems with the new logging level. Dynamically
-	// create loggers as needed.
-	for subsystemID := range r.loggers {
-		r.setLogLevelUnsafe(subsystemID, logLevel)
-	}
-}
-
-// SubLoggers is a type that holds a map of subsystem loggers keyed by their
-// subsystem name.
-type SubLoggers map[string]btclog.Logger
-
-// LeveledSubLogger provides the ability to retrieve the subsystem loggers of
-// a logger and set their log levels individually or all at once.
-type LeveledSubLogger interface {
-	// SubLoggers returns the map of all registered subsystem loggers.
-	SubLoggers() SubLoggers
-
-	// SupportedSubsystems returns a slice of strings containing the names
-	// of the supported subsystems. Should ideally correspond to the keys
-	// of the subsystem logger map and be sorted.
-	SupportedSubsystems() []string
-
-	// SetLogLevel assigns an individual subsystem logger a new log level.
-	SetLogLevel(subsystemID string, logLevel string)
-
-	// SetLogLevels assigns all subsystem loggers the same new log level.
-	SetLogLevels(logLevel string)
-}
-
-// ParseAndSetDebugLevels attempts to parse the specified debug level and set
-// the levels accordingly on the given logger. An appropriate error is returned
-// if anything is invalid.
-func ParseAndSetDebugLevels(level string, logger LeveledSubLogger) error {
-	// Split at the delimiter.
-	levels := strings.Split(level, ",")
-	if len(levels) == 0 {
-		return fmt.Errorf("invalid log level: %v", level)
-	}
-
-	// If the first entry has no =, treat is as the log level for all
-	// subsystems.
-	globalLevel := levels[0]
-	if !strings.Contains(globalLevel, "=") {
-		// Validate debug log level.
-		if !validLogLevel(globalLevel) {
-			str := "the specified debug level [%v] is invalid"
-
-			return fmt.Errorf(str, globalLevel)
-		}
-
-		// Change the logging level for all subsystems.
-		logger.SetLogLevels(globalLevel)
-
-		// The rest will target specific subsystems.
-		levels = levels[1:]
-	}
-
-	// Go through the subsystem/level pairs while detecting issues and
-	// update the log levels accordingly.
-	for _, logLevelPair := range levels {
-		if !strings.Contains(logLevelPair, "=") {
-			str := "the specified debug level contains an " +
-				"invalid subsystem/level pair [%v]"
-
-			return fmt.Errorf(str, logLevelPair)
-		}
-
-		// Extract the specified subsystem and log level.
-		fields := strings.Split(logLevelPair, "=")
-		if len(fields) != 2 {
-			str := "the specified debug level has an invalid " +
-				"format [%v] -- use format subsystem1=level1," +
-				"subsystem2=level2"
-
-			return fmt.Errorf(str, logLevelPair)
-		}
-		subsysID, logLevel := fields[0], fields[1]
-		subLoggers := logger.SubLoggers()
-
-		// Validate subsystem.
-		if _, exists := subLoggers[subsysID]; !exists {
-			str := "the specified subsystem [%v] is invalid -- " +
-				"supported subsystems are %v"
-
-			return fmt.Errorf(
-				str, subsysID, logger.SupportedSubsystems(),
-			)
-		}
-
-		// Validate log level.
-		if !validLogLevel(logLevel) {
-			str := "the specified debug level [%v] is invalid"
-			return fmt.Errorf(str, logLevel)
-		}
-
-		logger.SetLogLevel(subsysID, logLevel)
-	}
-
-	return nil
-}
-
-// validLogLevel returns whether or not logLevel is a valid debug log level.
-func validLogLevel(logLevel string) bool {
-	switch logLevel {
-	case "trace":
-		fallthrough
-	case "debug":
-		fallthrough
-	case "info":
-		fallthrough
-	case "warn":
-		fallthrough
-	case "error":
-		fallthrough
-	case "critical":
-		fallthrough
-	case "off":
-		return true
-	}
-
-	return false
-}

build/version.go

@@ -6,13 +6,9 @@
 package build
 
 import (
-	"context"
-	"encoding/hex"
 	"fmt"
 	"runtime/debug"
 	"strings"
-
-	"github.com/btcsuite/btclog/v2"
 )
 
 var (
@@ -44,10 +40,10 @@ const (
 	AppMajor uint = 0
 
 	// AppMinor defines the minor version of this binary.
-	AppMinor uint = 19
+	AppMinor uint = 18
 
 	// AppPatch defines the application patch for this binary.
-	AppPatch uint = 3
+	AppPatch uint = 4
 
 	// AppPreRelease MUST only contain characters from semanticAlphabet per
 	// the semantic versioning spec.
@@ -105,22 +101,3 @@ func Tags() []string {
 
 	return strings.Split(RawTags, ",")
 }
-
-// WithBuildInfo derives a child context with the build information attached as
-// attributes. At the moment, this only includes the current build's commit
-// hash.
-func WithBuildInfo(ctx context.Context, cfg *LogConfig) (context.Context,
-	error) {
-
-	if cfg.NoCommitHash {
-		return ctx, nil
-	}
-
-	// Convert the commit hash to a byte slice.
-	commitHash, err := hex.DecodeString(CommitHash)
-	if err != nil {
-		return nil, fmt.Errorf("unable to decode commit hash: %w", err)
-	}
-
-	return btclog.WithCtx(ctx, btclog.Hex3("rev", commitHash)), nil
-}

chainio/README.md

@@ -1,152 +0,0 @@
-# Chainio 
-
-`chainio` is a package designed to provide blockchain data access to various
-subsystems within `lnd`. When a new block is received, it is encapsulated in a
-`Blockbeat` object and disseminated to all registered consumers. Consumers may
-receive these updates either concurrently or sequentially, based on their
-registration configuration, ensuring that each subsystem maintains a
-synchronized view of the current block state.
-
-The main components include:
-
-- `Blockbeat`: An interface that provides information about the block.
-
-- `Consumer`: An interface that specifies how subsystems handle the blockbeat.
-
-- `BlockbeatDispatcher`: The core service responsible for receiving each block
-  and distributing it to all consumers.
-
-Additionally, the `BeatConsumer` struct provides a partial implementation of
-the `Consumer` interface. This struct helps reduce code duplication, allowing
-subsystems to avoid re-implementing the `ProcessBlock` method and provides a
-commonly used `NotifyBlockProcessed` method.
-
-
-### Register a Consumer
-
-Consumers within the same queue are notified **sequentially**, while all queues
-are notified **concurrently**. A queue consists of a slice of consumers, which
-are notified in left-to-right order. Developers are responsible for determining
-dependencies in block consumption across subsystems: independent subsystems
-should be notified concurrently, whereas dependent subsystems should be
-notified sequentially.
-
-To notify the consumers concurrently, put them in different queues,
-```go
-// consumer1 and consumer2 will be notified concurrently.
-queue1 := []chainio.Consumer{consumer1}
-blockbeatDispatcher.RegisterQueue(consumer1)
-
-queue2 := []chainio.Consumer{consumer2}
-blockbeatDispatcher.RegisterQueue(consumer2)
-```
-
-To notify the consumers sequentially, put them in the same queue,
-```go
-// consumers will be notified sequentially via,
-// consumer1 -> consumer2 -> consumer3
-queue := []chainio.Consumer{
-   consumer1,
-   consumer2,
-   consumer3,
-}
-blockbeatDispatcher.RegisterQueue(queue)
-```
-
-### Implement the `Consumer` Interface
-
-Implementing the `Consumer` interface is straightforward. Below is an example
-of how
-[`sweep.TxPublisher`](https://github.com/lightningnetwork/lnd/blob/5cec466fad44c582a64cfaeb91f6d5fd302fcf85/sweep/fee_bumper.go#L310)
-implements this interface.
-
-To start, embed the partial implementation `chainio.BeatConsumer`, which
-already provides the `ProcessBlock` implementation and commonly used
-`NotifyBlockProcessed` method,  and exposes `BlockbeatChan` for the consumer to
-receive blockbeats.
-
-```go
-type TxPublisher struct {
-   started atomic.Bool
-   stopped atomic.Bool
-
-   chainio.BeatConsumer
-
-   ...
-```
-
-We should also remember to initialize this `BeatConsumer`,
-
-```go
-...
-// Mount the block consumer.
-tp.BeatConsumer = chainio.NewBeatConsumer(tp.quit, tp.Name())
-```
-
-Finally, in the main event loop, read from `BlockbeatChan`, process the
-received blockbeat, and, crucially, call `tp.NotifyBlockProcessed` to inform
-the blockbeat dispatcher that processing is complete.
-
-```go
-for {
-      select {
-      case beat := <-tp.BlockbeatChan:
-         // Consume this blockbeat, usually it means updating the subsystem
-         // using the new block data.
-
-         // Notify we've processed the block.
-         tp.NotifyBlockProcessed(beat, nil)
-
-      ...
-```
-
-### Existing Queues
-
-Currently, we have a single queue of consumers dedicated to handling force
-closures. This queue includes `ChainArbitrator`, `UtxoSweeper`, and
-`TxPublisher`, with `ChainArbitrator` managing two internal consumers:
-`chainWatcher` and `ChannelArbitrator`. The blockbeat flows sequentially
-through the chain as follows: `ChainArbitrator => chainWatcher =>
-ChannelArbitrator => UtxoSweeper => TxPublisher`. The following diagram
-illustrates the flow within the public subsystems.
-
-```mermaid
-sequenceDiagram
-		autonumber
-		participant bb as BlockBeat
-		participant cc as ChainArb
-		participant us as UtxoSweeper
-		participant tp as TxPublisher
-		
-		note left of bb: 0. received block x,<br>dispatching...
-		
-    note over bb,cc: 1. send block x to ChainArb,<br>wait for its done signal
-		bb->>cc: block x
-		rect rgba(165, 0, 85, 0.8)
-      critical signal processed
-        cc->>bb: processed block
-      option Process error or timeout
-        bb->>bb: error and exit
-      end
-    end
-
-    note over bb,us: 2. send block x to UtxoSweeper, wait for its done signal
-		bb->>us: block x
-		rect rgba(165, 0, 85, 0.8)
-      critical signal processed
-        us->>bb: processed block
-      option Process error or timeout
-        bb->>bb: error and exit
-      end
-    end
-
-    note over bb,tp: 3. send block x to TxPublisher, wait for its done signal
-		bb->>tp: block x
-		rect rgba(165, 0, 85, 0.8)
-      critical signal processed
-        tp->>bb: processed block
-      option Process error or timeout
-        bb->>bb: error and exit
-      end
-    end
-```

chainio/blockbeat.go

@@ -1,54 +0,0 @@
-package chainio
-
-import (
-	"fmt"
-
-	"github.com/btcsuite/btclog/v2"
-	"github.com/lightningnetwork/lnd/chainntnfs"
-)
-
-// Beat implements the Blockbeat interface. It contains the block epoch and a
-// customized logger.
-//
-// TODO(yy): extend this to check for confirmation status - which serves as the
-// single source of truth, to avoid the potential race between receiving blocks
-// and `GetTransactionDetails/RegisterSpendNtfn/RegisterConfirmationsNtfn`.
-type Beat struct {
-	// epoch is the current block epoch the blockbeat is aware of.
-	epoch chainntnfs.BlockEpoch
-
-	// log is the customized logger for the blockbeat which prints the
-	// block height.
-	log btclog.Logger
-}
-
-// Compile-time check to ensure Beat satisfies the Blockbeat interface.
-var _ Blockbeat = (*Beat)(nil)
-
-// NewBeat creates a new beat with the specified block epoch and a customized
-// logger.
-func NewBeat(epoch chainntnfs.BlockEpoch) *Beat {
-	b := &Beat{
-		epoch: epoch,
-	}
-
-	// Create a customized logger for the blockbeat.
-	logPrefix := fmt.Sprintf("Height[%6d]:", b.Height())
-	b.log = clog.WithPrefix(logPrefix)
-
-	return b
-}
-
-// Height returns the height of the block epoch.
-//
-// NOTE: Part of the Blockbeat interface.
-func (b *Beat) Height() int32 {
-	return b.epoch.Height
-}
-
-// logger returns the logger for the blockbeat.
-//
-// NOTE: Part of the private blockbeat interface.
-func (b *Beat) logger() btclog.Logger {
-	return b.log
-}

chainio/blockbeat_test.go

@@ -1,28 +0,0 @@
-package chainio
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/lightningnetwork/lnd/chainntnfs"
-	"github.com/stretchr/testify/require"
-)
-
-var errDummy = errors.New("dummy error")
-
-// TestNewBeat tests the NewBeat and Height functions.
-func TestNewBeat(t *testing.T) {
-	t.Parallel()
-
-	// Create a testing epoch.
-	epoch := chainntnfs.BlockEpoch{
-		Height: 1,
-	}
-
-	// Create the beat and check the internal state.
-	beat := NewBeat(epoch)
-	require.Equal(t, epoch, beat.epoch)
-
-	// Check the height function.
-	require.Equal(t, epoch.Height, beat.Height())
-}

chainio/consumer.go

@@ -1,113 +0,0 @@
-package chainio
-
-// BeatConsumer defines a supplementary component that should be used by
-// subsystems which implement the `Consumer` interface. It partially implements
-// the `Consumer` interface by providing the method `ProcessBlock` such that
-// subsystems don't need to re-implement it.
-//
-// While inheritance is not commonly used in Go, subsystems embedding this
-// struct cannot pass the interface check for `Consumer` because the `Name`
-// method is not implemented, which gives us a "mortise and tenon" structure.
-// In addition to reducing code duplication, this design allows `ProcessBlock`
-// to work on the concrete type `Beat` to access its internal states.
-type BeatConsumer struct {
-	// BlockbeatChan is a channel to receive blocks from Blockbeat. The
-	// received block contains the best known height and the txns confirmed
-	// in this block.
-	BlockbeatChan chan Blockbeat
-
-	// name is the name of the consumer which embeds the BlockConsumer.
-	name string
-
-	// quit is a channel that closes when the BlockConsumer is shutting
-	// down.
-	//
-	// NOTE: this quit channel should be mounted to the same quit channel
-	// used by the subsystem.
-	quit chan struct{}
-
-	// errChan is a buffered chan that receives an error returned from
-	// processing this block.
-	errChan chan error
-}
-
-// NewBeatConsumer creates a new BlockConsumer.
-func NewBeatConsumer(quit chan struct{}, name string) BeatConsumer {
-	// Refuse to start `lnd` if the quit channel is not initialized. We
-	// treat this case as if we are facing a nil pointer dereference, as
-	// there's no point to return an error here, which will cause the node
-	// to fail to be started anyway.
-	if quit == nil {
-		panic("quit channel is nil")
-	}
-
-	b := BeatConsumer{
-		BlockbeatChan: make(chan Blockbeat),
-		name:          name,
-		errChan:       make(chan error, 1),
-		quit:          quit,
-	}
-
-	return b
-}
-
-// ProcessBlock takes a blockbeat and sends it to the consumer's blockbeat
-// channel. It will send it to the subsystem's BlockbeatChan, and block until
-// the processed result is received from the subsystem. The subsystem must call
-// `NotifyBlockProcessed` after it has finished processing the block.
-//
-// NOTE: part of the `chainio.Consumer` interface.
-func (b *BeatConsumer) ProcessBlock(beat Blockbeat) error {
-	// Update the current height.
-	beat.logger().Tracef("set current height for [%s]", b.name)
-
-	select {
-	// Send the beat to the blockbeat channel. It's expected that the
-	// consumer will read from this channel and process the block. Once
-	// processed, it should return the error or nil to the beat.Err chan.
-	case b.BlockbeatChan <- beat:
-		beat.logger().Tracef("Sent blockbeat to [%s]", b.name)
-
-	case <-b.quit:
-		beat.logger().Debugf("[%s] received shutdown before sending "+
-			"beat", b.name)
-
-		return nil
-	}
-
-	// Check the consumer's err chan. We expect the consumer to call
-	// `beat.NotifyBlockProcessed` to send the error back here.
-	select {
-	case err := <-b.errChan:
-		beat.logger().Tracef("[%s] processed beat: err=%v", b.name, err)
-
-		return err
-
-	case <-b.quit:
-		beat.logger().Debugf("[%s] received shutdown", b.name)
-	}
-
-	return nil
-}
-
-// NotifyBlockProcessed signals that the block has been processed. It takes the
-// blockbeat being processed and an error resulted from processing it. This
-// error is then sent back to the consumer's err chan to unblock
-// `ProcessBlock`.
-//
-// NOTE: This method must be called by the subsystem after it has finished
-// processing the block.
-func (b *BeatConsumer) NotifyBlockProcessed(beat Blockbeat, err error) {
-	// Update the current height.
-	beat.logger().Tracef("[%s]: notifying beat processed", b.name)
-
-	select {
-	case b.errChan <- err:
-		beat.logger().Tracef("[%s]: notified beat processed, err=%v",
-			b.name, err)
-
-	case <-b.quit:
-		beat.logger().Debugf("[%s] received shutdown before notifying "+
-			"beat processed", b.name)
-	}
-}

chainio/consumer_test.go

@@ -1,202 +0,0 @@
-package chainio
-
-import (
-	"testing"
-	"time"
-
-	"github.com/lightningnetwork/lnd/fn/v2"
-	"github.com/stretchr/testify/require"
-)
-
-// TestNewBeatConsumer tests the NewBeatConsumer function.
-func TestNewBeatConsumer(t *testing.T) {
-	t.Parallel()
-
-	quitChan := make(chan struct{})
-	name := "test"
-
-	// Test the NewBeatConsumer function.
-	b := NewBeatConsumer(quitChan, name)
-
-	// Assert the state.
-	require.Equal(t, quitChan, b.quit)
-	require.Equal(t, name, b.name)
-	require.NotNil(t, b.BlockbeatChan)
-}
-
-// TestProcessBlockSuccess tests when the block is processed successfully, no
-// error is returned.
-func TestProcessBlockSuccess(t *testing.T) {
-	t.Parallel()
-
-	// Create a test consumer.
-	quitChan := make(chan struct{})
-	b := NewBeatConsumer(quitChan, "test")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock the consumer's err chan.
-	consumerErrChan := make(chan error, 1)
-	b.errChan = consumerErrChan
-
-	// Call the method under test.
-	resultChan := make(chan error, 1)
-	go func() {
-		resultChan <- b.ProcessBlock(mockBeat)
-	}()
-
-	// Assert the beat is sent to the blockbeat channel.
-	beat, err := fn.RecvOrTimeout(b.BlockbeatChan, time.Second)
-	require.NoError(t, err)
-	require.Equal(t, mockBeat, beat)
-
-	// Send nil to the consumer's error channel.
-	consumerErrChan <- nil
-
-	// Assert the result of ProcessBlock is nil.
-	result, err := fn.RecvOrTimeout(resultChan, time.Second)
-	require.NoError(t, err)
-	require.Nil(t, result)
-}
-
-// TestProcessBlockConsumerQuitBeforeSend tests when the consumer is quit
-// before sending the beat, the method returns immediately.
-func TestProcessBlockConsumerQuitBeforeSend(t *testing.T) {
-	t.Parallel()
-
-	// Create a test consumer.
-	quitChan := make(chan struct{})
-	b := NewBeatConsumer(quitChan, "test")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Call the method under test.
-	resultChan := make(chan error, 1)
-	go func() {
-		resultChan <- b.ProcessBlock(mockBeat)
-	}()
-
-	// Instead of reading the BlockbeatChan, close the quit channel.
-	close(quitChan)
-
-	// Assert ProcessBlock returned nil.
-	result, err := fn.RecvOrTimeout(resultChan, time.Second)
-	require.NoError(t, err)
-	require.Nil(t, result)
-}
-
-// TestProcessBlockConsumerQuitAfterSend tests when the consumer is quit after
-// sending the beat, the method returns immediately.
-func TestProcessBlockConsumerQuitAfterSend(t *testing.T) {
-	t.Parallel()
-
-	// Create a test consumer.
-	quitChan := make(chan struct{})
-	b := NewBeatConsumer(quitChan, "test")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock the consumer's err chan.
-	consumerErrChan := make(chan error, 1)
-	b.errChan = consumerErrChan
-
-	// Call the method under test.
-	resultChan := make(chan error, 1)
-	go func() {
-		resultChan <- b.ProcessBlock(mockBeat)
-	}()
-
-	// Assert the beat is sent to the blockbeat channel.
-	beat, err := fn.RecvOrTimeout(b.BlockbeatChan, time.Second)
-	require.NoError(t, err)
-	require.Equal(t, mockBeat, beat)
-
-	// Instead of sending nil to the consumer's error channel, close the
-	// quit channel.
-	close(quitChan)
-
-	// Assert ProcessBlock returned nil.
-	result, err := fn.RecvOrTimeout(resultChan, time.Second)
-	require.NoError(t, err)
-	require.Nil(t, result)
-}
-
-// TestNotifyBlockProcessedSendErr asserts the error can be sent and read by
-// the beat via NotifyBlockProcessed.
-func TestNotifyBlockProcessedSendErr(t *testing.T) {
-	t.Parallel()
-
-	// Create a test consumer.
-	quitChan := make(chan struct{})
-	b := NewBeatConsumer(quitChan, "test")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock the consumer's err chan.
-	consumerErrChan := make(chan error, 1)
-	b.errChan = consumerErrChan
-
-	// Call the method under test.
-	done := make(chan error)
-	go func() {
-		defer close(done)
-		b.NotifyBlockProcessed(mockBeat, errDummy)
-	}()
-
-	// Assert the error is sent to the beat's err chan.
-	result, err := fn.RecvOrTimeout(consumerErrChan, time.Second)
-	require.NoError(t, err)
-	require.ErrorIs(t, result, errDummy)
-
-	// Assert the done channel is closed.
-	result, err = fn.RecvOrTimeout(done, time.Second)
-	require.NoError(t, err)
-	require.Nil(t, result)
-}
-
-// TestNotifyBlockProcessedOnQuit asserts NotifyBlockProcessed exits
-// immediately when the quit channel is closed.
-func TestNotifyBlockProcessedOnQuit(t *testing.T) {
-	t.Parallel()
-
-	// Create a test consumer.
-	quitChan := make(chan struct{})
-	b := NewBeatConsumer(quitChan, "test")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock the consumer's err chan - we don't buffer it so it will block
-	// on sending the error.
-	consumerErrChan := make(chan error)
-	b.errChan = consumerErrChan
-
-	// Call the method under test.
-	done := make(chan error)
-	go func() {
-		defer close(done)
-		b.NotifyBlockProcessed(mockBeat, errDummy)
-	}()
-
-	// Close the quit channel so the method will return.
-	close(b.quit)
-
-	// Assert the done channel is closed.
-	result, err := fn.RecvOrTimeout(done, time.Second)
-	require.NoError(t, err)
-	require.Nil(t, result)
-}

chainio/dispatcher.go

@@ -1,366 +0,0 @@
-package chainio
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/btcsuite/btclog/v2"
-	"github.com/lightningnetwork/lnd/chainntnfs"
-	"github.com/lightningnetwork/lnd/lnutils"
-	"golang.org/x/sync/errgroup"
-)
-
-// DefaultProcessBlockTimeout is the timeout value used when waiting for one
-// consumer to finish processing the new block epoch.
-var DefaultProcessBlockTimeout = 60 * time.Second
-
-// ErrProcessBlockTimeout is the error returned when a consumer takes too long
-// to process the block.
-var ErrProcessBlockTimeout = errors.New("process block timeout")
-
-// BlockbeatDispatcher is a service that handles dispatching new blocks to
-// `lnd`'s subsystems. During startup, subsystems that are block-driven should
-// implement the `Consumer` interface and register themselves via
-// `RegisterQueue`. When two subsystems are independent of each other, they
-// should be registered in different queues so blocks are notified concurrently.
-// Otherwise, when living in the same queue, the subsystems are notified of the
-// new blocks sequentially, which means it's critical to understand the
-// relationship of these systems to properly handle the order.
-type BlockbeatDispatcher struct {
-	wg sync.WaitGroup
-
-	// notifier is used to receive new block epochs.
-	notifier chainntnfs.ChainNotifier
-
-	// beat is the latest blockbeat received.
-	beat Blockbeat
-
-	// consumerQueues is a map of consumers that will receive blocks. Its
-	// key is a unique counter and its value is a queue of consumers. Each
-	// queue is notified concurrently, and consumers in the same queue is
-	// notified sequentially.
-	consumerQueues map[uint32][]Consumer
-
-	// counter is used to assign a unique id to each queue.
-	counter atomic.Uint32
-
-	// quit is used to signal the BlockbeatDispatcher to stop.
-	quit chan struct{}
-
-	// queryHeightChan is used to receive queries on the current height of
-	// the dispatcher.
-	queryHeightChan chan *query
-}
-
-// query is used to fetch the internal state of the dispatcher.
-type query struct {
-	// respChan is used to send back the current height back to the caller.
-	//
-	// NOTE: This channel must be buffered.
-	respChan chan int32
-}
-
-// newQuery creates a query to be used to fetch the internal state of the
-// dispatcher.
-func newQuery() *query {
-	return &query{
-		respChan: make(chan int32, 1),
-	}
-}
-
-// NewBlockbeatDispatcher returns a new blockbeat dispatcher instance.
-func NewBlockbeatDispatcher(n chainntnfs.ChainNotifier) *BlockbeatDispatcher {
-	return &BlockbeatDispatcher{
-		notifier:        n,
-		quit:            make(chan struct{}),
-		consumerQueues:  make(map[uint32][]Consumer),
-		queryHeightChan: make(chan *query, 1),
-	}
-}
-
-// RegisterQueue takes a list of consumers and registers them in the same
-// queue.
-//
-// NOTE: these consumers are notified sequentially.
-func (b *BlockbeatDispatcher) RegisterQueue(consumers []Consumer) {
-	qid := b.counter.Add(1)
-
-	b.consumerQueues[qid] = append(b.consumerQueues[qid], consumers...)
-	clog.Infof("Registered queue=%d with %d blockbeat consumers", qid,
-		len(consumers))
-
-	for _, c := range consumers {
-		clog.Debugf("Consumer [%s] registered in queue %d", c.Name(),
-			qid)
-	}
-}
-
-// Start starts the blockbeat dispatcher - it registers a block notification
-// and monitors and dispatches new blocks in a goroutine. It will refuse to
-// start if there are no registered consumers.
-func (b *BlockbeatDispatcher) Start() error {
-	// Make sure consumers are registered.
-	if len(b.consumerQueues) == 0 {
-		return fmt.Errorf("no consumers registered")
-	}
-
-	// Start listening to new block epochs. We should get a notification
-	// with the current best block immediately.
-	blockEpochs, err := b.notifier.RegisterBlockEpochNtfn(nil)
-	if err != nil {
-		return fmt.Errorf("register block epoch ntfn: %w", err)
-	}
-
-	clog.Infof("BlockbeatDispatcher is starting with %d consumer queues",
-		len(b.consumerQueues))
-	defer clog.Debug("BlockbeatDispatcher started")
-
-	b.wg.Add(1)
-	go b.dispatchBlocks(blockEpochs)
-
-	return nil
-}
-
-// Stop shuts down the blockbeat dispatcher.
-func (b *BlockbeatDispatcher) Stop() {
-	clog.Info("BlockbeatDispatcher is stopping")
-	defer clog.Debug("BlockbeatDispatcher stopped")
-
-	// Signal the dispatchBlocks goroutine to stop.
-	close(b.quit)
-	b.wg.Wait()
-}
-
-func (b *BlockbeatDispatcher) log() btclog.Logger {
-	// There's no guarantee that the `b.beat` is initialized when the
-	// dispatcher shuts down, especially in the case where the node is
-	// running as a remote signer, which doesn't have a chainbackend. In
-	// that case we will use the package logger.
-	if b.beat == nil {
-		return clog
-	}
-
-	return b.beat.logger()
-}
-
-// dispatchBlocks listens to new block epoch and dispatches it to all the
-// consumers. Each queue is notified concurrently, and the consumers in the
-// same queue are notified sequentially.
-//
-// NOTE: Must be run as a goroutine.
-func (b *BlockbeatDispatcher) dispatchBlocks(
-	blockEpochs *chainntnfs.BlockEpochEvent) {
-
-	defer b.wg.Done()
-	defer blockEpochs.Cancel()
-
-	for {
-		select {
-		case blockEpoch, ok := <-blockEpochs.Epochs:
-			if !ok {
-				clog.Debugf("Block epoch channel closed")
-
-				return
-			}
-
-			// Log a separator so it's easier to identify when a
-			// new block arrives for subsystems.
-			clog.Debugf("%v", lnutils.NewSeparatorClosure())
-
-			clog.Debugf("Received new block %v at height %d, "+
-				"notifying consumers...", blockEpoch.Hash,
-				blockEpoch.Height)
-
-			// Record the time it takes the consumer to process
-			// this block.
-			start := time.Now()
-
-			// Update the current block epoch.
-			b.beat = NewBeat(*blockEpoch)
-
-			// Notify all consumers.
-			err := b.notifyQueues()
-			if err != nil {
-				b.log().Errorf("Notify block failed: %v", err)
-			}
-
-			b.log().Debugf("Notified all consumers on new block "+
-				"in %v", time.Since(start))
-
-		// A query has been made to fetch the current height, we now
-		// send the height from its current beat.
-		case query := <-b.queryHeightChan:
-			// The beat may not be set yet, e.g., during the startup
-			// the query is made before the block epoch being sent.
-			height := int32(0)
-			if b.beat != nil {
-				height = b.beat.Height()
-			}
-
-			query.respChan <- height
-
-		case <-b.quit:
-			b.log().Debugf("BlockbeatDispatcher quit signal " +
-				"received")
-
-			return
-		}
-	}
-}
-
-// CurrentHeight returns the current best height known to the dispatcher. 0 is
-// returned if the dispatcher is shutting down.
-func (b *BlockbeatDispatcher) CurrentHeight() int32 {
-	query := newQuery()
-
-	select {
-	case b.queryHeightChan <- query:
-
-	case <-b.quit:
-		clog.Debugf("BlockbeatDispatcher quit before query")
-		return 0
-	}
-
-	select {
-	case height := <-query.respChan:
-		clog.Debugf("Responded current height: %v", height)
-		return height
-
-	case <-b.quit:
-		clog.Debugf("BlockbeatDispatcher quit before response")
-		return 0
-	}
-}
-
-// notifyQueues notifies each queue concurrently about the latest block epoch.
-func (b *BlockbeatDispatcher) notifyQueues() error {
-	// errChans is a map of channels that will be used to receive errors
-	// returned from notifying the consumers.
-	errChans := make(map[uint32]chan error, len(b.consumerQueues))
-
-	// Notify each queue in goroutines.
-	for qid, consumers := range b.consumerQueues {
-		b.log().Debugf("Notifying queue=%d with %d consumers", qid,
-			len(consumers))
-
-		// Create a signal chan.
-		errChan := make(chan error, 1)
-		errChans[qid] = errChan
-
-		// Notify each queue concurrently.
-		go func(qid uint32, c []Consumer, beat Blockbeat) {
-			// Notify each consumer in this queue sequentially.
-			errChan <- DispatchSequential(beat, c)
-		}(qid, consumers, b.beat)
-	}
-
-	// Wait for all consumers in each queue to finish.
-	for qid, errChan := range errChans {
-		select {
-		case err := <-errChan:
-			if err != nil {
-				return fmt.Errorf("queue=%d got err: %w", qid,
-					err)
-			}
-
-			b.log().Debugf("Notified queue=%d", qid)
-
-		case <-b.quit:
-			b.log().Debugf("BlockbeatDispatcher quit signal " +
-				"received, exit notifyQueues")
-
-			return nil
-		}
-	}
-
-	return nil
-}
-
-// DispatchSequential takes a list of consumers and notify them about the new
-// epoch sequentially. It requires the consumer to finish processing the block
-// within the specified time, otherwise a timeout error is returned.
-func DispatchSequential(b Blockbeat, consumers []Consumer) error {
-	for _, c := range consumers {
-		// Send the beat to the consumer.
-		err := notifyAndWait(b, c, DefaultProcessBlockTimeout)
-		if err != nil {
-			b.logger().Errorf("Failed to process block: %v", err)
-
-			return err
-		}
-	}
-
-	return nil
-}
-
-// DispatchConcurrent notifies each consumer concurrently about the blockbeat.
-// It requires the consumer to finish processing the block within the specified
-// time, otherwise a timeout error is returned.
-func DispatchConcurrent(b Blockbeat, consumers []Consumer) error {
-	eg := &errgroup.Group{}
-
-	// Notify each queue in goroutines.
-	for _, c := range consumers {
-		// Notify each consumer concurrently.
-		eg.Go(func() error {
-			// Send the beat to the consumer.
-			err := notifyAndWait(b, c, DefaultProcessBlockTimeout)
-
-			// Exit early if there's no error.
-			if err == nil {
-				return nil
-			}
-
-			b.logger().Errorf("Consumer=%v failed to process "+
-				"block: %v", c.Name(), err)
-
-			return err
-		})
-	}
-
-	// Wait for all consumers in each queue to finish.
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// notifyAndWait sends the blockbeat to the specified consumer. It requires the
-// consumer to finish processing the block within the specified time, otherwise
-// a timeout error is returned.
-func notifyAndWait(b Blockbeat, c Consumer, timeout time.Duration) error {
-	b.logger().Debugf("Waiting for consumer[%s] to process it", c.Name())
-
-	// Record the time it takes the consumer to process this block.
-	start := time.Now()
-
-	errChan := make(chan error, 1)
-	go func() {
-		errChan <- c.ProcessBlock(b)
-	}()
-
-	// We expect the consumer to finish processing this block under 30s,
-	// otherwise a timeout error is returned.
-	select {
-	case err := <-errChan:
-		if err == nil {
-			break
-		}
-
-		return fmt.Errorf("%s got err in ProcessBlock: %w", c.Name(),
-			err)
-
-	case <-time.After(timeout):
-		return fmt.Errorf("consumer %s: %w", c.Name(),
-			ErrProcessBlockTimeout)
-	}
-
-	b.logger().Debugf("Consumer[%s] processed block in %v", c.Name(),
-		time.Since(start))
-
-	return nil
-}

chainio/dispatcher_test.go

@@ -1,440 +0,0 @@
-package chainio
-
-import (
-	"testing"
-	"time"
-
-	"github.com/lightningnetwork/lnd/chainntnfs"
-	"github.com/lightningnetwork/lnd/fn/v2"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-)
-
-// TestNotifyAndWaitOnConsumerErr asserts when the consumer returns an error,
-// it's returned by notifyAndWait.
-func TestNotifyAndWaitOnConsumerErr(t *testing.T) {
-	t.Parallel()
-
-	// Create a mock consumer.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock ProcessBlock to return an error.
-	consumer.On("ProcessBlock", mockBeat).Return(errDummy).Once()
-
-	// Call the method under test.
-	err := notifyAndWait(mockBeat, consumer, DefaultProcessBlockTimeout)
-
-	// We expect the error to be returned.
-	require.ErrorIs(t, err, errDummy)
-}
-
-// TestNotifyAndWaitOnConsumerErr asserts when the consumer successfully
-// processed the beat, no error is returned.
-func TestNotifyAndWaitOnConsumerSuccess(t *testing.T) {
-	t.Parallel()
-
-	// Create a mock consumer.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock ProcessBlock to return nil.
-	consumer.On("ProcessBlock", mockBeat).Return(nil).Once()
-
-	// Call the method under test.
-	err := notifyAndWait(mockBeat, consumer, DefaultProcessBlockTimeout)
-
-	// We expect a nil error to be returned.
-	require.NoError(t, err)
-}
-
-// TestNotifyAndWaitOnConsumerTimeout asserts when the consumer times out
-// processing the block, the timeout error is returned.
-func TestNotifyAndWaitOnConsumerTimeout(t *testing.T) {
-	t.Parallel()
-
-	// Set timeout to be 10ms.
-	processBlockTimeout := 10 * time.Millisecond
-
-	// Create a mock consumer.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker")
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Mock ProcessBlock to return nil but blocks on returning.
-	consumer.On("ProcessBlock", mockBeat).Return(nil).Run(
-		func(args mock.Arguments) {
-			// Sleep one second to block on the method.
-			time.Sleep(processBlockTimeout * 100)
-		}).Once()
-
-	// Call the method under test.
-	err := notifyAndWait(mockBeat, consumer, processBlockTimeout)
-
-	// We expect a timeout error to be returned.
-	require.ErrorIs(t, err, ErrProcessBlockTimeout)
-}
-
-// TestDispatchSequential checks that the beat is sent to the consumers
-// sequentially.
-func TestDispatchSequential(t *testing.T) {
-	t.Parallel()
-
-	// Create three mock consumers.
-	consumer1 := &MockConsumer{}
-	defer consumer1.AssertExpectations(t)
-	consumer1.On("Name").Return("mocker1")
-
-	consumer2 := &MockConsumer{}
-	defer consumer2.AssertExpectations(t)
-	consumer2.On("Name").Return("mocker2")
-
-	consumer3 := &MockConsumer{}
-	defer consumer3.AssertExpectations(t)
-	consumer3.On("Name").Return("mocker3")
-
-	consumers := []Consumer{consumer1, consumer2, consumer3}
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// prevConsumer specifies the previous consumer that was called.
-	var prevConsumer string
-
-	// Mock the ProcessBlock on consumers to return immediately.
-	consumer1.On("ProcessBlock", mockBeat).Return(nil).Run(
-		func(args mock.Arguments) {
-			// Check the order of the consumers.
-			//
-			// The first consumer should have no previous consumer.
-			require.Empty(t, prevConsumer)
-
-			// Set the consumer as the previous consumer.
-			prevConsumer = consumer1.Name()
-		}).Once()
-
-	consumer2.On("ProcessBlock", mockBeat).Return(nil).Run(
-		func(args mock.Arguments) {
-			// Check the order of the consumers.
-			//
-			// The second consumer should see consumer1.
-			require.Equal(t, consumer1.Name(), prevConsumer)
-
-			// Set the consumer as the previous consumer.
-			prevConsumer = consumer2.Name()
-		}).Once()
-
-	consumer3.On("ProcessBlock", mockBeat).Return(nil).Run(
-		func(args mock.Arguments) {
-			// Check the order of the consumers.
-			//
-			// The third consumer should see consumer2.
-			require.Equal(t, consumer2.Name(), prevConsumer)
-
-			// Set the consumer as the previous consumer.
-			prevConsumer = consumer3.Name()
-		}).Once()
-
-	// Call the method under test.
-	err := DispatchSequential(mockBeat, consumers)
-	require.NoError(t, err)
-
-	// Check the previous consumer is the last consumer.
-	require.Equal(t, consumer3.Name(), prevConsumer)
-}
-
-// TestRegisterQueue tests the RegisterQueue function.
-func TestRegisterQueue(t *testing.T) {
-	t.Parallel()
-
-	// Create two mock consumers.
-	consumer1 := &MockConsumer{}
-	defer consumer1.AssertExpectations(t)
-	consumer1.On("Name").Return("mocker1")
-
-	consumer2 := &MockConsumer{}
-	defer consumer2.AssertExpectations(t)
-	consumer2.On("Name").Return("mocker2")
-
-	consumers := []Consumer{consumer1, consumer2}
-
-	// Create a mock chain notifier.
-	mockNotifier := &chainntnfs.MockChainNotifier{}
-	defer mockNotifier.AssertExpectations(t)
-
-	// Create a new dispatcher.
-	b := NewBlockbeatDispatcher(mockNotifier)
-
-	// Register the consumers.
-	b.RegisterQueue(consumers)
-
-	// Assert that the consumers have been registered.
-	//
-	// We should have one queue.
-	require.Len(t, b.consumerQueues, 1)
-
-	// The queue should have two consumers.
-	queue, ok := b.consumerQueues[1]
-	require.True(t, ok)
-	require.Len(t, queue, 2)
-}
-
-// TestStartDispatcher tests the Start method.
-func TestStartDispatcher(t *testing.T) {
-	t.Parallel()
-
-	// Create a mock chain notifier.
-	mockNotifier := &chainntnfs.MockChainNotifier{}
-	defer mockNotifier.AssertExpectations(t)
-
-	// Create a new dispatcher.
-	b := NewBlockbeatDispatcher(mockNotifier)
-
-	// Start the dispatcher without consumers should return an error.
-	err := b.Start()
-	require.Error(t, err)
-
-	// Create a consumer and register it.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker1")
-	b.RegisterQueue([]Consumer{consumer})
-
-	// Mock the chain notifier to return an error.
-	mockNotifier.On("RegisterBlockEpochNtfn",
-		mock.Anything).Return(nil, errDummy).Once()
-
-	// Start the dispatcher now should return the error.
-	err = b.Start()
-	require.ErrorIs(t, err, errDummy)
-
-	// Mock the chain notifier to return a valid notifier.
-	blockEpochs := &chainntnfs.BlockEpochEvent{}
-	mockNotifier.On("RegisterBlockEpochNtfn",
-		mock.Anything).Return(blockEpochs, nil).Once()
-
-	// Start the dispatcher now should not return an error.
-	err = b.Start()
-	require.NoError(t, err)
-}
-
-// TestDispatchBlocks asserts the blocks are properly dispatched to the queues.
-func TestDispatchBlocks(t *testing.T) {
-	t.Parallel()
-
-	// Create a mock chain notifier.
-	mockNotifier := &chainntnfs.MockChainNotifier{}
-	defer mockNotifier.AssertExpectations(t)
-
-	// Create a new dispatcher.
-	b := NewBlockbeatDispatcher(mockNotifier)
-
-	// Create the beat and attach it to the dispatcher.
-	epoch := chainntnfs.BlockEpoch{Height: 1}
-	beat := NewBeat(epoch)
-	b.beat = beat
-
-	// Create a consumer and register it.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker1")
-	b.RegisterQueue([]Consumer{consumer})
-
-	// Mock the consumer to return nil error on ProcessBlock. This
-	// implicitly asserts that the step `notifyQueues` is successfully
-	// reached in the `dispatchBlocks` method.
-	consumer.On("ProcessBlock", mock.Anything).Return(nil).Once()
-
-	// Create a test epoch chan.
-	epochChan := make(chan *chainntnfs.BlockEpoch, 1)
-	blockEpochs := &chainntnfs.BlockEpochEvent{
-		Epochs: epochChan,
-		Cancel: func() {},
-	}
-
-	// Call the method in a goroutine.
-	done := make(chan struct{})
-	b.wg.Add(1)
-	go func() {
-		defer close(done)
-		b.dispatchBlocks(blockEpochs)
-	}()
-
-	// Send an epoch.
-	epoch = chainntnfs.BlockEpoch{Height: 2}
-	epochChan <- &epoch
-
-	// Wait for the dispatcher to process the epoch.
-	time.Sleep(100 * time.Millisecond)
-
-	// Stop the dispatcher.
-	b.Stop()
-
-	// We expect the dispatcher to stop immediately.
-	_, err := fn.RecvOrTimeout(done, time.Second)
-	require.NoError(t, err)
-}
-
-// TestNotifyQueuesSuccess checks when the dispatcher successfully notifies all
-// the queues, no error is returned.
-func TestNotifyQueuesSuccess(t *testing.T) {
-	t.Parallel()
-
-	// Create two mock consumers.
-	consumer1 := &MockConsumer{}
-	defer consumer1.AssertExpectations(t)
-	consumer1.On("Name").Return("mocker1")
-
-	consumer2 := &MockConsumer{}
-	defer consumer2.AssertExpectations(t)
-	consumer2.On("Name").Return("mocker2")
-
-	// Create two queues.
-	queue1 := []Consumer{consumer1}
-	queue2 := []Consumer{consumer2}
-
-	// Create a mock chain notifier.
-	mockNotifier := &chainntnfs.MockChainNotifier{}
-	defer mockNotifier.AssertExpectations(t)
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Create a new dispatcher.
-	b := NewBlockbeatDispatcher(mockNotifier)
-
-	// Register the queues.
-	b.RegisterQueue(queue1)
-	b.RegisterQueue(queue2)
-
-	// Attach the blockbeat.
-	b.beat = mockBeat
-
-	// Mock the consumers to return nil error on ProcessBlock for
-	// both calls.
-	consumer1.On("ProcessBlock", mockBeat).Return(nil).Once()
-	consumer2.On("ProcessBlock", mockBeat).Return(nil).Once()
-
-	// Notify the queues. The mockers will be asserted in the end to
-	// validate the calls.
-	err := b.notifyQueues()
-	require.NoError(t, err)
-}
-
-// TestNotifyQueuesError checks when one of the queue returns an error, this
-// error is returned by the method.
-func TestNotifyQueuesError(t *testing.T) {
-	t.Parallel()
-
-	// Create a mock consumer.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker1")
-
-	// Create one queue.
-	queue := []Consumer{consumer}
-
-	// Create a mock chain notifier.
-	mockNotifier := &chainntnfs.MockChainNotifier{}
-	defer mockNotifier.AssertExpectations(t)
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-
-	// Create a new dispatcher.
-	b := NewBlockbeatDispatcher(mockNotifier)
-
-	// Register the queues.
-	b.RegisterQueue(queue)
-
-	// Attach the blockbeat.
-	b.beat = mockBeat
-
-	// Mock the consumer to return an error on ProcessBlock.
-	consumer.On("ProcessBlock", mockBeat).Return(errDummy).Once()
-
-	// Notify the queues. The mockers will be asserted in the end to
-	// validate the calls.
-	err := b.notifyQueues()
-	require.ErrorIs(t, err, errDummy)
-}
-
-// TestCurrentHeight asserts `CurrentHeight` returns the expected block height.
-func TestCurrentHeight(t *testing.T) {
-	t.Parallel()
-
-	testHeight := int32(1000)
-
-	// Create a mock chain notifier.
-	mockNotifier := &chainntnfs.MockChainNotifier{}
-	defer mockNotifier.AssertExpectations(t)
-
-	// Create a mock beat.
-	mockBeat := &MockBlockbeat{}
-	defer mockBeat.AssertExpectations(t)
-	mockBeat.On("logger").Return(clog)
-	mockBeat.On("Height").Return(testHeight).Once()
-
-	// Create a mock consumer.
-	consumer := &MockConsumer{}
-	defer consumer.AssertExpectations(t)
-	consumer.On("Name").Return("mocker1")
-
-	// Create one queue.
-	queue := []Consumer{consumer}
-
-	// Create a new dispatcher.
-	b := NewBlockbeatDispatcher(mockNotifier)
-
-	// Register the queues.
-	b.RegisterQueue(queue)
-
-	// Attach the blockbeat.
-	b.beat = mockBeat
-
-	// Mock the chain notifier to return a valid notifier.
-	blockEpochs := &chainntnfs.BlockEpochEvent{
-		Cancel: func() {},
-	}
-	mockNotifier.On("RegisterBlockEpochNtfn",
-		mock.Anything).Return(blockEpochs, nil).Once()
-
-	// Start the dispatcher now should not return an error.
-	err := b.Start()
-	require.NoError(t, err)
-
-	// Make a query on the current height and assert it equals to
-	// testHeight.
-	height := b.CurrentHeight()
-	require.Equal(t, testHeight, height)
-
-	// Stop the dispatcher.
-	b.Stop()
-
-	// Make a query on the current height and assert it equals to 0.
-	height = b.CurrentHeight()
-	require.Zero(t, height)
-}

chainio/interface.go

@@ -1,53 +0,0 @@
-package chainio
-
-import "github.com/btcsuite/btclog/v2"
-
-// Blockbeat defines an interface that can be used by subsystems to retrieve
-// block data. It is sent by the BlockbeatDispatcher to all the registered
-// consumers whenever a new block is received. Once the consumer finishes
-// processing the block, it must signal it by calling `NotifyBlockProcessed`.
-//
-// The blockchain is a state machine - whenever there's a state change, it's
-// manifested in a block. The blockbeat is a way to notify subsystems of this
-// state change, and to provide them with the data they need to process it. In
-// other words, subsystems must react to this state change and should consider
-// being driven by the blockbeat in their own state machines.
-type Blockbeat interface {
-	// blockbeat is a private interface that's only used in this package.
-	blockbeat
-
-	// Height returns the current block height.
-	Height() int32
-}
-
-// blockbeat defines a set of private methods used in this package to make
-// interaction with the blockbeat easier.
-type blockbeat interface {
-	// logger returns the internal logger used by the blockbeat which has a
-	// block height prefix.
-	logger() btclog.Logger
-}
-
-// Consumer defines a blockbeat consumer interface. Subsystems that need block
-// info must implement it.
-type Consumer interface {
-	// TODO(yy): We should also define the start methods used by the
-	// consumers such that when implementing the interface, the consumer
-	// will always be started with a blockbeat. This cannot be enforced at
-	// the moment as we need refactor all the start methods to only take a
-	// beat.
-	//
-	// Start(beat Blockbeat) error
-
-	// Name returns a human-readable string for this subsystem.
-	Name() string
-
-	// ProcessBlock takes a blockbeat and processes it. It should not
-	// return until the subsystem has updated its state based on the block
-	// data.
-	//
-	// NOTE: The consumer must try its best to NOT return an error. If an
-	// error is returned from processing the block, it means the subsystem
-	// cannot react to onchain state changes and lnd will shutdown.
-	ProcessBlock(b Blockbeat) error
-}

chainio/log.go

@@ -1,32 +0,0 @@
-package chainio
-
-import (
-	"github.com/btcsuite/btclog/v2"
-	"github.com/lightningnetwork/lnd/build"
-)
-
-// Subsystem defines the logging code for this subsystem.
-const Subsystem = "CHIO"
-
-// clog 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 clog btclog.Logger
-
-// The default amount of logging is none.
-func init() {
-	UseLogger(build.NewSubLogger(Subsystem, nil))
-}
-
-// DisableLog disables all library log output. Logging output is disabled by
-// default until UseLogger is called.
-func DisableLog() {
-	UseLogger(btclog.Disabled)
-}
-
-// UseLogger uses a specified Logger to output package logging info. This
-// should be used in preference to SetLogWriter if the caller is also using
-// btclog.
-func UseLogger(logger btclog.Logger) {
-	clog = logger
-}

chainio/mocks.go

@@ -1,50 +0,0 @@
-package chainio
-
-import (
-	"github.com/btcsuite/btclog/v2"
-	"github.com/stretchr/testify/mock"
-)
-
-// MockConsumer is a mock implementation of the Consumer interface.
-type MockConsumer struct {
-	mock.Mock
-}
-
-// Compile-time constraint to ensure MockConsumer implements Consumer.
-var _ Consumer = (*MockConsumer)(nil)
-
-// Name returns a human-readable string for this subsystem.
-func (m *MockConsumer) Name() string {
-	args := m.Called()
-	return args.String(0)
-}
-
-// ProcessBlock takes a blockbeat and processes it. A receive-only error chan
-// must be returned.
-func (m *MockConsumer) ProcessBlock(b Blockbeat) error {
-	args := m.Called(b)
-
-	return args.Error(0)
-}
-
-// MockBlockbeat is a mock implementation of the Blockbeat interface.
-type MockBlockbeat struct {
-	mock.Mock
-}
-
-// Compile-time constraint to ensure MockBlockbeat implements Blockbeat.
-var _ Blockbeat = (*MockBlockbeat)(nil)
-
-// Height returns the current block height.
-func (m *MockBlockbeat) Height() int32 {
-	args := m.Called()
-
-	return args.Get(0).(int32)
-}
-
-// logger returns the logger for the blockbeat.
-func (m *MockBlockbeat) logger() btclog.Logger {
-	args := m.Called()
-
-	return args.Get(0).(btclog.Logger)
-}

chainntnfs/bitcoindnotify/bitcoind.go

@@ -15,7 +15,7 @@ import (
 	"github.com/btcsuite/btcwallet/chain"
 	"github.com/lightningnetwork/lnd/blockcache"
 	"github.com/lightningnetwork/lnd/chainntnfs"
-	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/queue"
 )
 
@@ -139,7 +139,6 @@ func (b *BitcoindNotifier) Stop() error {
 	// Shutdown the rpc client, this gracefully disconnects from bitcoind,
 	// and cleans up all related resources.
 	b.chainConn.Stop()
-	b.chainConn.WaitForShutdown()
 
 	close(b.quit)
 	b.wg.Wait()
@@ -171,8 +170,6 @@ func (b *BitcoindNotifier) Started() bool {
 }
 
 func (b *BitcoindNotifier) startNotifier() error {
-	chainntnfs.Log.Infof("bitcoind notifier starting...")
-
 	// Connect to bitcoind, and register for notifications on connected,
 	// and disconnected blocks.
 	if err := b.chainConn.Start(); err != nil {
@@ -209,8 +206,6 @@ func (b *BitcoindNotifier) startNotifier() error {
 	// startup.
 	atomic.StoreInt32(&b.active, 1)
 
-	chainntnfs.Log.Debugf("bitcoind notifier started")
-
 	return nil
 }
 
@@ -260,7 +255,7 @@ out:
 				// TODO(wilmer): add retry logic if rescan fails?
 				b.wg.Add(1)
 
-				//nolint:ll
+				//nolint:lll
 				go func(msg *chainntnfs.HistoricalConfDispatch) {
 					defer b.wg.Done()
 
@@ -305,7 +300,7 @@ out:
 				// TODO(wilmer): add retry logic if rescan fails?
 				b.wg.Add(1)
 
-				//nolint:ll
+				//nolint:lll
 				go func(msg *chainntnfs.HistoricalSpendDispatch) {
 					defer b.wg.Done()
 
@@ -495,7 +490,7 @@ out:
 func (b *BitcoindNotifier) handleRelevantTx(tx *btcutil.Tx,
 	mempool bool, height uint32) {
 
-	// If this is a mempool spend, we'll ask the mempool notifier to handle
+	// If this is a mempool spend, we'll ask the mempool notifier to hanlde
 	// it.
 	if mempool {
 		err := b.memNotifier.ProcessRelevantSpendTx(tx)
@@ -669,14 +664,8 @@ func (b *BitcoindNotifier) handleBlockConnected(block chainntnfs.BlockEpoch) err
 	// satisfy any client requests based upon the new block.
 	b.bestBlock = block
 
-	err = b.txNotifier.NotifyHeight(uint32(block.Height))
-	if err != nil {
-		return fmt.Errorf("unable to notify height: %w", err)
-	}
-
 	b.notifyBlockEpochs(block.Height, block.Hash, block.BlockHeader)
-
-	return nil
+	return b.txNotifier.NotifyHeight(uint32(block.Height))
 }
 
 // notifyBlockEpochs notifies all registered block epoch clients of the newly
@@ -833,16 +822,8 @@ func (b *BitcoindNotifier) RegisterSpendNtfn(outpoint *wire.OutPoint,
 			return nil, err
 		}
 
-		spentHeight := uint32(blockHeight)
-		chainntnfs.Log.Debugf("Outpoint(%v) has spent at height %v",
-			outpoint, spentHeight)
-
-		// Since the tx has already been spent at spentHeight, the
-		// heightHint specified by the caller is no longer relevant. We
-		// now update the starting height to be the spent height to make
-		// sure we won't miss it in the rescan.
-		if spentHeight != ntfn.HistoricalDispatch.StartHeight {
-			ntfn.HistoricalDispatch.StartHeight = spentHeight
+		if uint32(blockHeight) > ntfn.HistoricalDispatch.StartHeight {
+			ntfn.HistoricalDispatch.StartHeight = uint32(blockHeight)
 		}
 	}
 

chainntnfs/bitcoindnotify/bitcoind_test.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/integration/rpctest"
-	"github.com/btcsuite/btcd/rpcclient"
 	"github.com/btcsuite/btcwallet/chain"
 	"github.com/lightningnetwork/lnd/blockcache"
 	"github.com/lightningnetwork/lnd/chainntnfs"
@@ -38,7 +37,11 @@ var (
 func initHintCache(t *testing.T) *channeldb.HeightHintCache {
 	t.Helper()
 
-	db := channeldb.OpenForTesting(t, t.TempDir())
+	db, err := channeldb.Open(t.TempDir())
+	require.NoError(t, err, "unable to create db")
+	t.Cleanup(func() {
+		require.NoError(t, db.Close())
+	})
 
 	testCfg := channeldb.CacheConfig{
 		QueryDisable: false,
@@ -104,69 +107,17 @@ func syncNotifierWithMiner(t *testing.T, notifier *BitcoindNotifier,
 				"err=%v, minerHeight=%v, bitcoindHeight=%v",
 				err, minerHeight, bitcoindHeight)
 		}
-
-		// Get the num of connections the miner has. We expect it to
-		// have at least one connection with the chain backend.
-		count, err := miner.Client.GetConnectionCount()
-		require.NoError(t, err)
-		if count != 0 {
-			continue
-		}
-
-		// Reconnect the miner and the chain backend.
-		//
-		// NOTE: The connection should have been made before we perform
-		// the `syncNotifierWithMiner`. However, due to an unknown
-		// reason, the miner may refuse to process the inbound
-		// connection made by the bitcoind node, causing the connection
-		// to fail. It's possible there's a bug in the handshake between
-		// the two nodes.
-		//
-		// A normal flow is, bitcoind starts a v2 handshake flow, which
-		// btcd will fail and disconnect. Upon seeing this
-		// disconnection, bitcoind will try a v1 handshake and succeeds.
-		// The failed flow is, upon seeing the v2 handshake, btcd
-		// doesn't seem to perform the disconnect. Instead an EOF
-		// websocket error is found.
-		//
-		// TODO(yy): Fix the above bug in `btcd`. This can be reproduced
-		// using `make flakehunter-unit pkg=$pkg case=$case`, with,
-		// `case=TestHistoricalConfDetailsNoTxIndex/rpc_polling_enabled`
-		// `pkg=chainntnfs/bitcoindnotify`.
-		// Also need to modify the temp dir logic so we can save the
-		// debug logs.
-		// This bug is likely to be fixed when we implement the
-		// encrypted p2p conn, or when we properly fix the shutdown
-		// issues in all our RPC conns.
-		t.Log("Expected to the chain backend to have one conn with " +
-			"the miner, instead it's disconnected!")
-
-		// We now ask the miner to add the chain backend back.
-		host := fmt.Sprintf(
-			"127.0.0.1:%s", notifier.chainParams.DefaultPort,
-		)
-
-		// NOTE:AddNode must take a host that has the format
-		// `host:port`, otherwise the default port will be used. Check
-		// `normalizeAddress` in btcd for details.
-		err = miner.Client.AddNode(host, rpcclient.ANAdd)
-		require.NoError(t, err, "Failed to connect miner to the chain "+
-			"backend")
 	}
 }
 
 // TestHistoricalConfDetailsTxIndex ensures that we correctly retrieve
 // historical confirmation details using the backend node's txindex.
 func TestHistoricalConfDetailsTxIndex(t *testing.T) {
-	success := t.Run("rpc polling enabled", func(st *testing.T) {
+	t.Run("rpc polling enabled", func(st *testing.T) {
 		st.Parallel()
 		testHistoricalConfDetailsTxIndex(st, true)
 	})
 
-	if !success {
-		return
-	}
-
 	t.Run("rpc polling disabled", func(st *testing.T) {
 		st.Parallel()
 		testHistoricalConfDetailsTxIndex(st, false)
@@ -179,7 +130,7 @@ func testHistoricalConfDetailsTxIndex(t *testing.T, rpcPolling bool) {
 	)
 
 	bitcoindConn := unittest.NewBitcoindBackend(
-		t, unittest.NetParams, miner, true, rpcPolling,
+		t, unittest.NetParams, miner.P2PAddress(), true, rpcPolling,
 	)
 
 	hintCache := initHintCache(t)
@@ -189,6 +140,8 @@ func testHistoricalConfDetailsTxIndex(t *testing.T, rpcPolling bool) {
 		t, bitcoindConn, hintCache, hintCache, blockCache,
 	)
 
+	syncNotifierWithMiner(t, notifier, miner)
+
 	// A transaction unknown to the node should not be found within the
 	// txindex even if it is enabled, so we should not proceed with any
 	// fallback methods.
@@ -258,15 +211,11 @@ func testHistoricalConfDetailsTxIndex(t *testing.T, rpcPolling bool) {
 // historical confirmation details using the set of fallback methods when the
 // backend node's txindex is disabled.
 func TestHistoricalConfDetailsNoTxIndex(t *testing.T) {
-	success := t.Run("rpc polling enabled", func(st *testing.T) {
+	t.Run("rpc polling enabled", func(st *testing.T) {
 		st.Parallel()
 		testHistoricalConfDetailsNoTxIndex(st, true)
 	})
 
-	if !success {
-		return
-	}
-
 	t.Run("rpc polling disabled", func(st *testing.T) {
 		st.Parallel()
 		testHistoricalConfDetailsNoTxIndex(st, false)
@@ -277,15 +226,13 @@ func testHistoricalConfDetailsNoTxIndex(t *testing.T, rpcpolling bool) {
 	miner := unittest.NewMiner(t, unittest.NetParams, nil, true, 25)
 
 	bitcoindConn := unittest.NewBitcoindBackend(
-		t, unittest.NetParams, miner, false, rpcpolling,
+		t, unittest.NetParams, miner.P2PAddress(), false, rpcpolling,
 	)
 
 	hintCache := initHintCache(t)
 	blockCache := blockcache.NewBlockCache(10000)
 
-	notifier := setUpNotifier(
-		t, bitcoindConn, hintCache, hintCache, blockCache,
-	)
+	notifier := setUpNotifier(t, bitcoindConn, hintCache, hintCache, blockCache)
 
 	// Since the node has its txindex disabled, we fall back to scanning the
 	// chain manually. A transaction unknown to the network should not be
@@ -294,11 +241,7 @@ func testHistoricalConfDetailsNoTxIndex(t *testing.T, rpcpolling bool) {
 	copy(unknownHash[:], bytes.Repeat([]byte{0x10}, 32))
 	unknownConfReq, err := chainntnfs.NewConfRequest(&unknownHash, testScript)
 	require.NoError(t, err, "unable to create conf request")
-
-	// Get the current best height.
-	_, broadcastHeight, err := miner.Client.GetBestBlock()
-	require.NoError(t, err, "unable to retrieve miner's current height")
-
+	broadcastHeight := syncNotifierWithMiner(t, notifier, miner)
 	_, txStatus, err := notifier.historicalConfDetails(
 		unknownConfReq, uint32(broadcastHeight), uint32(broadcastHeight),
 	)

chainntnfs/btcdnotify/btcd.go

@@ -17,7 +17,7 @@ import (
 	"github.com/btcsuite/btcwallet/chain"
 	"github.com/lightningnetwork/lnd/blockcache"
 	"github.com/lightningnetwork/lnd/chainntnfs"
-	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/queue"
 )
 
@@ -129,6 +129,11 @@ func New(config *rpcclient.ConnConfig, chainParams *chaincfg.Params,
 		quit: make(chan struct{}),
 	}
 
+	// Disable connecting to btcd within the rpcclient.New method. We
+	// defer establishing the connection to our .Start() method.
+	config.DisableConnectOnNew = true
+	config.DisableAutoReconnect = false
+
 	ntfnCallbacks := &rpcclient.NotificationHandlers{
 		OnBlockConnected:    notifier.onBlockConnected,
 		OnBlockDisconnected: notifier.onBlockDisconnected,
@@ -180,7 +185,7 @@ func (b *BtcdNotifier) Stop() error {
 
 	// Shutdown the rpc client, this gracefully disconnects from btcd, and
 	// cleans up all related resources.
-	b.chainConn.Stop()
+	b.chainConn.Shutdown()
 
 	close(b.quit)
 	b.wg.Wait()
@@ -204,11 +209,7 @@ func (b *BtcdNotifier) Stop() error {
 	return nil
 }
 
-// startNotifier is the main starting point for the BtcdNotifier. It connects
-// to btcd and start the main dispatcher goroutine.
 func (b *BtcdNotifier) startNotifier() error {
-	chainntnfs.Log.Infof("btcd notifier starting...")
-
 	// Start our concurrent queues before starting the chain connection, to
 	// ensure onBlockConnected and onRedeemingTx callbacks won't be
 	// blocked.
@@ -223,17 +224,6 @@ func (b *BtcdNotifier) startNotifier() error {
 		return err
 	}
 
-	// Before we fetch the best block/block height we need to register the
-	// notifications for connected blocks, otherwise we might think we are
-	// at an earlier block height because during block notification
-	// registration we might have already mined some new blocks. Hence we
-	// will not get notified accordingly.
-	if err := b.chainConn.NotifyBlocks(); err != nil {
-		b.txUpdates.Stop()
-		b.chainUpdates.Stop()
-		return err
-	}
-
 	currentHash, currentHeight, err := b.chainConn.GetBestBlock()
 	if err != nil {
 		b.txUpdates.Stop()
@@ -259,6 +249,12 @@ func (b *BtcdNotifier) startNotifier() error {
 		BlockHeader: &bestBlock.Header,
 	}
 
+	if err := b.chainConn.NotifyBlocks(); err != nil {
+		b.txUpdates.Stop()
+		b.chainUpdates.Stop()
+		return err
+	}
+
 	b.wg.Add(1)
 	go b.notificationDispatcher()
 
@@ -266,8 +262,6 @@ func (b *BtcdNotifier) startNotifier() error {
 	// startup.
 	atomic.StoreInt32(&b.active, 1)
 
-	chainntnfs.Log.Debugf("btcd notifier started")
-
 	return nil
 }
 
@@ -377,7 +371,7 @@ out:
 				// TODO(wilmer): add retry logic if rescan fails?
 				b.wg.Add(1)
 
-				//nolint:ll
+				//nolint:lll
 				go func(msg *chainntnfs.HistoricalConfDispatch) {
 					defer b.wg.Done()
 
@@ -550,7 +544,7 @@ out:
 func (b *BtcdNotifier) handleRelevantTx(tx *btcutil.Tx,
 	mempool bool, height uint32) {
 
-	// If this is a mempool spend, we'll ask the mempool notifier to handle
+	// If this is a mempool spend, we'll ask the mempool notifier to hanlde
 	// it.
 	if mempool {
 		err := b.memNotifier.ProcessRelevantSpendTx(tx)
@@ -736,16 +730,11 @@ func (b *BtcdNotifier) handleBlockConnected(epoch chainntnfs.BlockEpoch) error {
 	// satisfy any client requests based upon the new block.
 	b.bestBlock = epoch
 
-	err = b.txNotifier.NotifyHeight(uint32(epoch.Height))
-	if err != nil {
-		return fmt.Errorf("unable to notify height: %w", err)
-	}
-
 	b.notifyBlockEpochs(
 		epoch.Height, epoch.Hash, epoch.BlockHeader,
 	)
 
-	return nil
+	return b.txNotifier.NotifyHeight(uint32(epoch.Height))
 }
 
 // notifyBlockEpochs notifies all registered block epoch clients of the newly
@@ -933,25 +922,15 @@ func (b *BtcdNotifier) RegisterSpendNtfn(outpoint *wire.OutPoint,
 				"block %v: %v", blockHash, err)
 		}
 
-		spentHeight := uint32(blockHeader.Height)
-		chainntnfs.Log.Debugf("Outpoint(%v) has spent at height %v",
-			outpoint, spentHeight)
-
-		// Since the tx has already been spent at spentHeight, the
-		// heightHint specified by the caller is no longer relevant. We
-		// now update the starting height to be the spent height to make
-		// sure we won't miss it in the rescan.
-		if spentHeight != ntfn.HistoricalDispatch.StartHeight {
+		if uint32(blockHeader.Height) > ntfn.HistoricalDispatch.StartHeight {
 			startHash, err = b.chainConn.GetBlockHash(
-				int64(spentHeight),
+				int64(blockHeader.Height),
 			)
 			if err != nil {
 				return nil, fmt.Errorf("unable to get block "+
 					"hash for height %d: %v",
 					blockHeader.Height, err)
 			}
-
-			ntfn.HistoricalDispatch.StartHeight = spentHeight
 		}
 	}
 

chainntnfs/btcdnotify/btcd_test.go

@@ -33,7 +33,11 @@ var (
 func initHintCache(t *testing.T) *channeldb.HeightHintCache {
 	t.Helper()
 
-	db := channeldb.OpenForTesting(t, t.TempDir())
+	db, err := channeldb.Open(t.TempDir())
+	require.NoError(t, err, "unable to create db")
+	t.Cleanup(func() {
+		require.NoError(t, db.Close())
+	})
 
 	testCfg := channeldb.CacheConfig{
 		QueryDisable: false,

chainntnfs/interface.go

@@ -13,7 +13,7 @@ import (
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
-	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/lightningnetwork/lnd/fn"
 )
 
 var (
@@ -70,28 +70,28 @@ func (t TxConfStatus) String() string {
 	}
 }
 
-// NotifierOptions is a set of functional options that allow callers to further
+// notifierOptions is a set of functional options that allow callers to further
 // modify the type of chain event notifications they receive.
-type NotifierOptions struct {
-	// IncludeBlock if true, then the dispatched confirmation notification
+type notifierOptions struct {
+	// includeBlock if true, then the dispatched confirmation notification
 	// will include the block that mined the transaction.
-	IncludeBlock bool
+	includeBlock bool
 }
 
-// DefaultNotifierOptions returns the set of default options for the notifier.
-func DefaultNotifierOptions() *NotifierOptions {
-	return &NotifierOptions{}
+// defaultNotifierOptions returns the set of default options for the notifier.
+func defaultNotifierOptions() *notifierOptions {
+	return &notifierOptions{}
 }
 
 // NotifierOption is a functional option that allows a caller to modify the
 // events received from the notifier.
-type NotifierOption func(*NotifierOptions)
+type NotifierOption func(*notifierOptions)
 
-// WithIncludeBlock is an optional argument that allows the caller to specify
+// WithIncludeBlock is an optional argument that allows the calelr to specify
 // that the block that mined a transaction should be included in the response.
 func WithIncludeBlock() NotifierOption {
-	return func(o *NotifierOptions) {
-		o.IncludeBlock = true
+	return func(o *notifierOptions) {
+		o.includeBlock = true
 	}
 }
 
@@ -258,9 +258,6 @@ type ConfirmationEvent struct {
 // channels.
 func NewConfirmationEvent(numConfs uint32, cancel func()) *ConfirmationEvent {
 	return &ConfirmationEvent{
-		// We cannot rely on the subscriber to immediately read from
-		// the channel so we need to create a larger buffer to avoid
-		// blocking the notifier.
 		Confirmed:    make(chan *TxConfirmation, 1),
 		Updates:      make(chan uint32, numConfs),
 		NegativeConf: make(chan int32, 1),

chainntnfs/log.go

@@ -1,7 +1,7 @@
 package chainntnfs
 
 import (
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 )
 

chainntnfs/mempool.go

@@ -211,7 +211,7 @@ func (m *MempoolNotifier) findRelevantInputs(tx *btcutil.Tx) (inputsWithTx,
 
 		// If found, save it to watchedInputs to notify the
 		// subscriber later.
-		Log.Debugf("Found input %s, spent in %s", op, txid)
+		Log.Infof("Found input %s, spent in %s", op, txid)
 
 		// Construct the spend details.
 		details := &SpendDetail{

chainntnfs/mocks.go

@@ -3,7 +3,7 @@ package chainntnfs
 import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
-	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/stretchr/testify/mock"
 )
 

chainntnfs/neutrinonotify/neutrino.go

@@ -168,8 +168,6 @@ func (n *NeutrinoNotifier) Started() bool {
 }
 
 func (n *NeutrinoNotifier) startNotifier() error {
-	chainntnfs.Log.Infof("neutrino notifier starting...")
-
 	// Start our concurrent queues before starting the rescan, to ensure
 	// onFilteredBlockConnected and onRelavantTx callbacks won't be
 	// blocked.
@@ -236,8 +234,6 @@ func (n *NeutrinoNotifier) startNotifier() error {
 	// startup.
 	atomic.StoreInt32(&n.active, 1)
 
-	chainntnfs.Log.Debugf("neutrino notifier started")
-
 	return nil
 }
 
@@ -443,7 +439,7 @@ func (n *NeutrinoNotifier) notificationDispatcher() {
 				// potentially long rescans.
 				n.wg.Add(1)
 
-				//nolint:ll
+				//nolint:lll
 				go func(msg *chainntnfs.HistoricalConfDispatch) {
 					defer n.wg.Done()
 
@@ -693,16 +689,10 @@ func (n *NeutrinoNotifier) handleBlockConnected(newBlock *filteredBlock) error {
 	n.bestBlock.Height = int32(newBlock.height)
 	n.bestBlock.BlockHeader = newBlock.header
 
-	err = n.txNotifier.NotifyHeight(newBlock.height)
-	if err != nil {
-		return fmt.Errorf("unable to notify height: %w", err)
-	}
-
 	n.notifyBlockEpochs(
 		int32(newBlock.height), &newBlock.hash, newBlock.header,
 	)
-
-	return nil
+	return n.txNotifier.NotifyHeight(newBlock.height)
 }
 
 // getFilteredBlock is a utility to retrieve the full filtered block from a block epoch.

chainntnfs/test/bitcoind/bitcoind_test.go

@@ -12,15 +12,11 @@ import (
 // TestInterfaces executes the generic notifier test suite against a bitcoind
 // powered chain notifier.
 func TestInterfaces(t *testing.T) {
-	success := t.Run("bitcoind", func(st *testing.T) {
+	t.Run("bitcoind", func(st *testing.T) {
 		st.Parallel()
 		chainntnfstest.TestInterfaces(st, "bitcoind")
 	})
 
-	if !success {
-		return
-	}
-
 	t.Run("bitcoind rpc polling", func(st *testing.T) {
 		st.Parallel()
 		chainntnfstest.TestInterfaces(st, "bitcoind-rpc-polling")

chainntnfs/test/test_interface.go

@@ -41,8 +41,9 @@ func testSingleConfirmationNotification(miner *rpctest.Harness,
 	// function.
 	txid, pkScript, err := chainntnfs.GetTestTxidAndScript(miner)
 	require.NoError(t, err, "unable to create test tx")
-	err = chainntnfs.WaitForMempoolTx(miner, txid)
-	require.NoError(t, err, "tx not relayed to miner")
+	if err := chainntnfs.WaitForMempoolTx(miner, txid); err != nil {
+		t.Fatalf("tx not relayed to miner: %v", err)
+	}
 
 	_, currentHeight, err := miner.Client.GetBestBlock()
 	require.NoError(t, err, "unable to get current height")
@@ -67,11 +68,6 @@ func testSingleConfirmationNotification(miner *rpctest.Harness,
 	blockHash, err := miner.Client.Generate(1)
 	require.NoError(t, err, "unable to generate single block")
 
-	// Assert the above tx is mined in the block.
-	block, err := miner.Client.GetBlock(blockHash[0])
-	require.NoError(t, err)
-	require.Len(t, block.Transactions, 2, "block does not contain tx")
-
 	select {
 	case confInfo := <-confIntent.Confirmed:
 		if !confInfo.BlockHash.IsEqual(blockHash[0]) {
@@ -1910,8 +1906,10 @@ func TestInterfaces(t *testing.T, targetBackEnd string) {
 
 		// Initialize a height hint cache for each notifier.
 		tempDir := t.TempDir()
-		db := channeldb.OpenForTesting(t, tempDir)
-
+		db, err := channeldb.Open(tempDir)
+		if err != nil {
+			t.Fatalf("unable to create db: %v", err)
+		}
 		testCfg := channeldb.CacheConfig{
 			QueryDisable: false,
 		}
@@ -1932,7 +1930,7 @@ func TestInterfaces(t *testing.T, targetBackEnd string) {
 		case "bitcoind":
 			var bitcoindConn *chain.BitcoindConn
 			bitcoindConn = unittest.NewBitcoindBackend(
-				t, unittest.NetParams, miner, true, false,
+				t, unittest.NetParams, p2pAddr, true, false,
 			)
 			newNotifier = func() (chainntnfs.TestChainNotifier, error) {
 				return bitcoindnotify.New(
@@ -1944,7 +1942,7 @@ func TestInterfaces(t *testing.T, targetBackEnd string) {
 		case "bitcoind-rpc-polling":
 			var bitcoindConn *chain.BitcoindConn
 			bitcoindConn = unittest.NewBitcoindBackend(
-				t, unittest.NetParams, miner, true, true,
+				t, unittest.NetParams, p2pAddr, true, true,
 			)
 			newNotifier = func() (chainntnfs.TestChainNotifier, error) {
 				return bitcoindnotify.New(

chainntnfs/txnotifier.go

@@ -244,25 +244,20 @@ type ConfNtfn struct {
 	// notification is to be sent.
 	NumConfirmations uint32
 
-	// Event contains references to the channels that the notifications are
-	// to be sent over.
+	// Event contains references to the channels that the notifications are to
+	// be sent over.
 	Event *ConfirmationEvent
 
 	// HeightHint is the minimum height in the chain that we expect to find
 	// this txid.
 	HeightHint uint32
 
-	// dispatched is false if the confirmed notification has not been sent
-	// yet.
+	// dispatched is false if the confirmed notification has not been sent yet.
 	dispatched bool
 
 	// includeBlock is true if the dispatched notification should also have
 	// the block included with it.
 	includeBlock bool
-
-	// numConfsLeft is the number of confirmations left to be sent to the
-	// subscriber.
-	numConfsLeft uint32
 }
 
 // HistoricalConfDispatch parametrizes a manual rescan for a particular
@@ -559,7 +554,7 @@ func NewTxNotifier(startHeight uint32, reorgSafetyLimit uint32,
 // and register a confirmation notification.
 func (n *TxNotifier) newConfNtfn(txid *chainhash.Hash,
 	pkScript []byte, numConfs, heightHint uint32,
-	opts *NotifierOptions) (*ConfNtfn, error) {
+	opts *notifierOptions) (*ConfNtfn, error) {
 
 	// An accompanying output script must always be provided.
 	if len(pkScript) == 0 {
@@ -593,8 +588,7 @@ func (n *TxNotifier) newConfNtfn(txid *chainhash.Hash,
 			n.CancelConf(confRequest, confID)
 		}),
 		HeightHint:   heightHint,
-		includeBlock: opts.IncludeBlock,
-		numConfsLeft: numConfs,
+		includeBlock: opts.includeBlock,
 	}, nil
 }
 
@@ -616,7 +610,7 @@ func (n *TxNotifier) RegisterConf(txid *chainhash.Hash, pkScript []byte,
 	default:
 	}
 
-	opts := DefaultNotifierOptions()
+	opts := defaultNotifierOptions()
 	for _, optFunc := range optFuncs {
 		optFunc(opts)
 	}
@@ -670,8 +664,8 @@ func (n *TxNotifier) RegisterConf(txid *chainhash.Hash, pkScript []byte,
 		// already been found, we'll attempt to deliver them immediately
 		// to this client.
 		Log.Debugf("Attempting to dispatch confirmation for %v on "+
-			"registration since rescan has finished, conf_id=%v",
-			ntfn.ConfRequest, ntfn.ConfID)
+			"registration since rescan has finished",
+			ntfn.ConfRequest)
 
 		// The default notification we assigned above includes the
 		// block along with the rest of the details. However not all
@@ -685,13 +679,9 @@ func (n *TxNotifier) RegisterConf(txid *chainhash.Hash, pkScript []byte,
 			confDetails = &confDetailsCopy
 		}
 
-		// Deliver the details to the whole conf set where this ntfn
-		// lives in.
-		for _, subscriber := range confSet.ntfns {
-			err := n.dispatchConfDetails(subscriber, confDetails)
-			if err != nil {
-				return nil, err
-			}
+		err := n.dispatchConfDetails(ntfn, confDetails)
+		if err != nil {
+			return nil, err
 		}
 
 		return &ConfRegistration{
@@ -922,16 +912,10 @@ func (n *TxNotifier) dispatchConfDetails(
 	// If there are no conf details to dispatch or if the notification has
 	// already been dispatched, then we can skip dispatching to this
 	// client.
-	if details == nil {
-		Log.Debugf("Skipped dispatching nil conf details for request "+
-			"%v, conf_id=%v", ntfn.ConfRequest, ntfn.ConfID)
-
-		return nil
-	}
-
-	if ntfn.dispatched {
-		Log.Debugf("Skipped dispatched conf details for request %v "+
-			"conf_id=%v", ntfn.ConfRequest, ntfn.ConfID)
+	if details == nil || ntfn.dispatched {
+		Log.Debugf("Skipping dispatch of conf details(%v) for "+
+			"request %v, dispatched=%v", details, ntfn.ConfRequest,
+			ntfn.dispatched)
 
 		return nil
 	}
@@ -941,16 +925,16 @@ func (n *TxNotifier) dispatchConfDetails(
 	// we'll dispatch a confirmation notification to the caller.
 	confHeight := details.BlockHeight + ntfn.NumConfirmations - 1
 	if confHeight <= n.currentHeight {
-		Log.Debugf("Dispatching %v confirmation notification for "+
-			"conf_id=%v, %v", ntfn.NumConfirmations, ntfn.ConfID,
-			ntfn.ConfRequest)
+		Log.Debugf("Dispatching %v confirmation notification for %v",
+			ntfn.NumConfirmations, ntfn.ConfRequest)
 
 		// We'll send a 0 value to the Updates channel,
 		// indicating that the transaction/output script has already
 		// been confirmed.
-		err := n.notifyNumConfsLeft(ntfn, 0)
-		if err != nil {
-			return err
+		select {
+		case ntfn.Event.Updates <- 0:
+		case <-n.quit:
+			return ErrTxNotifierExiting
 		}
 
 		select {
@@ -960,8 +944,8 @@ func (n *TxNotifier) dispatchConfDetails(
 			return ErrTxNotifierExiting
 		}
 	} else {
-		Log.Debugf("Queueing %v confirmation notification for %v at "+
-			"tip", ntfn.NumConfirmations, ntfn.ConfRequest)
+		Log.Debugf("Queueing %v confirmation notification for %v at tip ",
+			ntfn.NumConfirmations, ntfn.ConfRequest)
 
 		// Otherwise, we'll keep track of the notification
 		// request by the height at which we should dispatch the
@@ -977,9 +961,10 @@ func (n *TxNotifier) dispatchConfDetails(
 		// confirmations are left for the transaction/output script to
 		// be confirmed.
 		numConfsLeft := confHeight - n.currentHeight
-		err := n.notifyNumConfsLeft(ntfn, numConfsLeft)
-		if err != nil {
-			return err
+		select {
+		case ntfn.Event.Updates <- numConfsLeft:
+		case <-n.quit:
+			return ErrTxNotifierExiting
 		}
 	}
 
@@ -1744,9 +1729,10 @@ func (n *TxNotifier) NotifyHeight(height uint32) error {
 					continue
 				}
 
-				err := n.notifyNumConfsLeft(ntfn, numConfsLeft)
-				if err != nil {
-					return err
+				select {
+				case ntfn.Event.Updates <- numConfsLeft:
+				case <-n.quit:
+					return ErrTxNotifierExiting
 				}
 			}
 		}
@@ -1757,6 +1743,9 @@ func (n *TxNotifier) NotifyHeight(height uint32) error {
 	for ntfn := range n.ntfnsByConfirmHeight[height] {
 		confSet := n.confNotifications[ntfn.ConfRequest]
 
+		Log.Debugf("Dispatching %v confirmation notification for %v",
+			ntfn.NumConfirmations, ntfn.ConfRequest)
+
 		// The default notification we assigned above includes the
 		// block along with the rest of the details. However not all
 		// clients want the block, so we make a copy here w/o the block
@@ -1766,20 +1755,6 @@ func (n *TxNotifier) NotifyHeight(height uint32) error {
 			confDetails.Block = nil
 		}
 
-		// If the `confDetails` has already been sent before, we'll
-		// skip it and continue processing the next one.
-		if ntfn.dispatched {
-			Log.Debugf("Skipped dispatched conf details for "+
-				"request %v conf_id=%v", ntfn.ConfRequest,
-				ntfn.ConfID)
-
-			continue
-		}
-
-		Log.Debugf("Dispatching %v confirmation notification for "+
-			"conf_id=%v, %v", ntfn.NumConfirmations, ntfn.ConfID,
-			ntfn.ConfRequest)
-
 		select {
 		case ntfn.Event.Confirmed <- &confDetails:
 			ntfn.dispatched = true
@@ -1858,9 +1833,6 @@ func (n *TxNotifier) DisconnectTip(blockHeight uint32) error {
 				default:
 				}
 
-				// We also reset the num of confs update.
-				ntfn.numConfsLeft = ntfn.NumConfirmations
-
 				// Then, we'll check if the current
 				// transaction/output script was included in the
 				// block currently being disconnected. If it
@@ -2097,30 +2069,3 @@ func (n *TxNotifier) TearDown() {
 		}
 	}
 }
-
-// notifyNumConfsLeft sends the number of confirmations left to the
-// notification subscriber through the Event.Updates channel.
-//
-// NOTE: must be used with the TxNotifier's lock held.
-func (n *TxNotifier) notifyNumConfsLeft(ntfn *ConfNtfn, num uint32) error {
-	// If the number left is no less than the recorded value, we can skip
-	// sending it as it means this same value has already been sent before.
-	if num >= ntfn.numConfsLeft {
-		Log.Debugf("Skipped dispatched update (numConfsLeft=%v) for "+
-			"request %v conf_id=%v", num, ntfn.ConfRequest,
-			ntfn.ConfID)
-
-		return nil
-	}
-
-	// Update the number of confirmations left to the notification.
-	ntfn.numConfsLeft = num
-
-	select {
-	case ntfn.Event.Updates <- num:
-	case <-n.quit:
-		return ErrTxNotifierExiting
-	}
-
-	return nil
-}

chainntnfs/txnotifier_test.go

@@ -173,7 +173,7 @@ func TestTxNotifierRegistrationValidation(t *testing.T) {
 
 	for _, testCase := range testCases {
 		testCase := testCase
-		success := t.Run(testCase.name, func(t *testing.T) {
+		t.Run(testCase.name, func(t *testing.T) {
 			hintCache := newMockHintCache()
 			n := chainntnfs.NewTxNotifier(
 				10, chainntnfs.ReorgSafetyLimit, hintCache, hintCache,
@@ -201,10 +201,6 @@ func TestTxNotifierRegistrationValidation(t *testing.T) {
 					"\"%v\", got \"%v\"", testCase.err, err)
 			}
 		})
-
-		if !success {
-			return
-		}
 	}
 }
 

chainreg/chainparams.go

@@ -22,14 +22,6 @@ var BitcoinTestNetParams = BitcoinNetParams{
 	CoinType: keychain.CoinTypeTestnet,
 }
 
-// BitcoinTestNet4Params contains parameters specific to the 4th version of the
-// test network.
-var BitcoinTestNet4Params = BitcoinNetParams{
-	Params:   &bitcoinCfg.TestNet4Params,
-	RPCPort:  "48334",
-	CoinType: keychain.CoinTypeTestnet,
-}
-
 // BitcoinMainNetParams contains parameters specific to the current Bitcoin
 // mainnet.
 var BitcoinMainNetParams = BitcoinNetParams{
@@ -61,9 +53,8 @@ var BitcoinRegTestNetParams = BitcoinNetParams{
 	CoinType: keychain.CoinTypeTestnet,
 }
 
-// IsTestnet tests if the given params correspond to a testnet parameter
-// configuration.
+// IsTestnet tests if the givern params correspond to a testnet
+// parameter configuration.
 func IsTestnet(params *BitcoinNetParams) bool {
-	return params.Params.Net == bitcoinWire.TestNet3 ||
-		params.Params.Net == bitcoinWire.TestNet4
+	return params.Params.Net == bitcoinWire.TestNet3
 }

chainreg/chainregistry.go

@@ -23,8 +23,8 @@ import (
 	"github.com/lightningnetwork/lnd/chainntnfs/btcdnotify"
 	"github.com/lightningnetwork/lnd/chainntnfs/neutrinonotify"
 	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/fn/v2"
-	"github.com/lightningnetwork/lnd/graph/db/models"
+	"github.com/lightningnetwork/lnd/channeldb/models"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/kvdb"
@@ -222,7 +222,7 @@ type ChainControl struct {
 // the parts that can be purely constructed from the passed in global
 // configuration and doesn't need any wallet instance yet.
 //
-//nolint:ll
+//nolint:lll
 func NewPartialChainControl(cfg *Config) (*PartialChainControl, func(), error) {
 	cc := &PartialChainControl{
 		Cfg: cfg,
@@ -385,7 +385,8 @@ func NewPartialChainControl(cfg *Config) (*PartialChainControl, func(), error) {
 		)
 		cc.ChainSource = bitcoindConn.NewBitcoindClient()
 
-		// Initialize config to connect to bitcoind RPC.
+		// If we're not in regtest mode, then we'll attempt to use a
+		// proper fee estimator for testnet.
 		rpcConfig := &rpcclient.ConnConfig{
 			Host:                 bitcoindHost,
 			User:                 bitcoindMode.RPCUser,
@@ -395,9 +396,7 @@ func NewPartialChainControl(cfg *Config) (*PartialChainControl, func(), error) {
 			DisableTLS:           true,
 			HTTPPostMode:         true,
 		}
-
-		// If feeurl is not provided, use bitcoind's fee estimator.
-		if cfg.Fee.URL == "" {
+		if !cfg.Bitcoin.RegTest {
 			log.Infof("Initializing bitcoind backed fee estimator "+
 				"in %s mode", bitcoindMode.EstimateMode)
 
@@ -661,8 +660,9 @@ func NewPartialChainControl(cfg *Config) (*PartialChainControl, func(), error) {
 			return checkOutboundPeers(chainRPC.Client)
 		}
 
-		// If feeurl is not provided, use btcd's fee estimator.
-		if cfg.Fee.URL == "" {
+		// If we're not in simnet or regtest mode, then we'll attempt
+		// to use a proper fee estimator for testnet.
+		if !cfg.Bitcoin.SimNet && !cfg.Bitcoin.RegTest {
 			log.Info("Initializing btcd backed fee estimator")
 
 			// Finally, we'll re-initialize the fee estimator, as
@@ -838,15 +838,6 @@ var (
 		0x01, 0xea, 0x33, 0x09, 0x00, 0x00, 0x00, 0x00,
 	})
 
-	// BitcoinTestnet4Genesis is the genesis hash of Bitcoin's testnet4
-	// chain.
-	BitcoinTestnet4Genesis = chainhash.Hash([chainhash.HashSize]byte{
-		0x43, 0xf0, 0x8b, 0xda, 0xb0, 0x50, 0xe3, 0x5b,
-		0x56, 0x7c, 0x86, 0x4b, 0x91, 0xf4, 0x7f, 0x50,
-		0xae, 0x72, 0x5a, 0xe2, 0xde, 0x53, 0xbc, 0xfb,
-		0xba, 0xf2, 0x84, 0xda, 0x00, 0x00, 0x00, 0x00,
-	})
-
 	// BitcoinSignetGenesis is the genesis hash of Bitcoin's signet chain.
 	BitcoinSignetGenesis = chainhash.Hash([chainhash.HashSize]byte{
 		0xf6, 0x1e, 0xee, 0x3b, 0x63, 0xa3, 0x80, 0xa4,
@@ -878,8 +869,8 @@ var (
 	ChainDNSSeeds = map[chainhash.Hash][][2]string{
 		BitcoinMainnetGenesis: {
 			{
-				"nodes.lightning.wiki",
-				"soa.nodes.lightning.wiki",
+				"nodes.lightning.directory",
+				"soa.nodes.lightning.directory",
 			},
 			{
 				"lseed.bitcoinstats.com",
@@ -888,22 +879,14 @@ var (
 
 		BitcoinTestnetGenesis: {
 			{
-				"test.nodes.lightning.wiki",
-				"soa.nodes.lightning.wiki",
-			},
-		},
-
-		BitcoinTestnet4Genesis: {
-			{
-				"test4.nodes.lightning.wiki",
-				"soa.nodes.lightning.wiki",
+				"test.nodes.lightning.directory",
+				"soa.nodes.lightning.directory",
 			},
 		},
 
 		BitcoinSignetGenesis: {
 			{
-				"signet.nodes.lightning.wiki",
-				"soa.nodes.lightning.wiki",
+				"ln.signet.secp.tech",
 			},
 		},
 	}

chainreg/log.go

@@ -1,7 +1,7 @@
 package chainreg
 
 import (
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 )
 

chainreg/no_chain_backend.go

@@ -11,7 +11,7 @@ import (
 	"github.com/btcsuite/btcwallet/chain"
 	"github.com/btcsuite/btcwallet/waddrmgr"
 	"github.com/lightningnetwork/lnd/chainntnfs"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
+	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/routing/chainview"
 )
@@ -94,7 +94,7 @@ func (n *NoChainBackend) DisconnectedBlocks() <-chan *chainview.FilteredBlock {
 	return make(chan *chainview.FilteredBlock)
 }
 
-func (n *NoChainBackend) UpdateFilter([]graphdb.EdgePoint, uint32) error {
+func (n *NoChainBackend) UpdateFilter([]channeldb.EdgePoint, uint32) error {
 	return nil
 }
 

chanacceptor/log.go

@@ -1,7 +1,7 @@
 package chanacceptor
 
 import (
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 )
 

chanacceptor/rpcacceptor.go

@@ -249,7 +249,7 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 	acceptRequests := make(map[[32]byte]*chanAcceptInfo)
 
 	for {
-		//nolint:ll
+		//nolint:lll
 		select {
 		// Consume requests passed to us from our Accept() function and
 		// send them into our stream.

chanbackup/backup.go

@@ -2,10 +2,12 @@ package chanbackup
 
 import (
 	"fmt"
+	"net"
 
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/lightningnetwork/lnd/kvdb"
 )
 
 // LiveChannelSource is an interface that allows us to query for the set of
@@ -17,14 +19,23 @@ type LiveChannelSource interface {
 
 	// FetchChannel attempts to locate a live channel identified by the
 	// passed chanPoint. Optionally an existing db tx can be supplied.
-	FetchChannel(chanPoint wire.OutPoint) (*channeldb.OpenChannel, error)
+	FetchChannel(tx kvdb.RTx, chanPoint wire.OutPoint) (
+		*channeldb.OpenChannel, error)
+}
+
+// AddressSource is an interface that allows us to query for the set of
+// addresses a node can be connected to.
+type AddressSource interface {
+	// AddrsForNode returns all known addresses for the target node public
+	// key.
+	AddrsForNode(nodePub *btcec.PublicKey) ([]net.Addr, error)
 }
 
 // assembleChanBackup attempts to assemble a static channel backup for the
 // passed open channel. The backup includes all information required to restore
 // the channel, as well as addressing information so we can find the peer and
 // reconnect to them to initiate the protocol.
-func assembleChanBackup(addrSource channeldb.AddrSource,
+func assembleChanBackup(addrSource AddressSource,
 	openChan *channeldb.OpenChannel) (*Single, error) {
 
 	log.Debugf("Crafting backup for ChannelPoint(%v)",
@@ -32,70 +43,25 @@ func assembleChanBackup(addrSource channeldb.AddrSource,
 
 	// First, we'll query the channel source to obtain all the addresses
 	// that are associated with the peer for this channel.
-	known, nodeAddrs, err := addrSource.AddrsForNode(openChan.IdentityPub)
+	nodeAddrs, err := addrSource.AddrsForNode(openChan.IdentityPub)
 	if err != nil {
 		return nil, err
 	}
-	if !known {
-		return nil, fmt.Errorf("node unknown by address source")
-	}
 
 	single := NewSingle(openChan, nodeAddrs)
 
 	return &single, nil
 }
 
-// buildCloseTxInputs generates inputs needed to force close a channel from
-// an open channel. Anyone having these inputs and the signer, can sign the
-// force closure transaction. Warning! If the channel state updates, an attempt
-// to close the channel using this method with outdated CloseTxInputs can result
-// in loss of funds! This may happen if an outdated channel backup is attempted
-// to be used to force close the channel.
-func buildCloseTxInputs(
-	targetChan *channeldb.OpenChannel) fn.Option[CloseTxInputs] {
-
-	log.Debugf("Crafting CloseTxInputs for ChannelPoint(%v)",
-		targetChan.FundingOutpoint)
-
-	localCommit := targetChan.LocalCommitment
-
-	if localCommit.CommitTx == nil {
-		log.Infof("CommitTx is nil for ChannelPoint(%v), "+
-			"skipping CloseTxInputs. This is possible when "+
-			"DLP is active.", targetChan.FundingOutpoint)
-
-		return fn.None[CloseTxInputs]()
-	}
-
-	// We need unsigned force close tx and the counterparty's signature.
-	inputs := CloseTxInputs{
-		CommitTx:  localCommit.CommitTx,
-		CommitSig: localCommit.CommitSig,
-	}
-
-	// In case of a taproot channel, commit height is needed as well to
-	// produce verification nonce for the taproot channel using shachain.
-	if targetChan.ChanType.IsTaproot() {
-		inputs.CommitHeight = localCommit.CommitHeight
-	}
-
-	// In case of a custom taproot channel, TapscriptRoot is needed as well.
-	if targetChan.ChanType.HasTapscriptRoot() {
-		inputs.TapscriptRoot = targetChan.TapscriptRoot
-	}
-
-	return fn.Some(inputs)
-}
-
 // FetchBackupForChan attempts to create a plaintext static channel backup for
 // the target channel identified by its channel point. If we're unable to find
 // the target channel, then an error will be returned.
 func FetchBackupForChan(chanPoint wire.OutPoint, chanSource LiveChannelSource,
-	addrSource channeldb.AddrSource) (*Single, error) {
+	addrSource AddressSource) (*Single, error) {
 
 	// First, we'll query the channel source to see if the channel is known
 	// and open within the database.
-	targetChan, err := chanSource.FetchChannel(chanPoint)
+	targetChan, err := chanSource.FetchChannel(nil, chanPoint)
 	if err != nil {
 		// If we can't find the channel, then we return with an error,
 		// as we have nothing to  backup.
@@ -115,7 +81,7 @@ func FetchBackupForChan(chanPoint wire.OutPoint, chanSource LiveChannelSource,
 // FetchStaticChanBackups will return a plaintext static channel back up for
 // all known active/open channels within the passed channel source.
 func FetchStaticChanBackups(chanSource LiveChannelSource,
-	addrSource channeldb.AddrSource) ([]Single, error) {
+	addrSource AddressSource) ([]Single, error) {
 
 	// First, we'll query the backup source for information concerning all
 	// currently open and available channels.

chanbackup/backup_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/stretchr/testify/require"
 )
 
@@ -39,7 +40,7 @@ func (m *mockChannelSource) FetchAllChannels() ([]*channeldb.OpenChannel, error)
 	return chans, nil
 }
 
-func (m *mockChannelSource) FetchChannel(chanPoint wire.OutPoint) (
+func (m *mockChannelSource) FetchChannel(_ kvdb.RTx, chanPoint wire.OutPoint) (
 	*channeldb.OpenChannel, error) {
 
 	if m.failQuery {
@@ -61,19 +62,20 @@ func (m *mockChannelSource) addAddrsForNode(nodePub *btcec.PublicKey, addrs []ne
 	m.addrs[nodeKey] = addrs
 }
 
-func (m *mockChannelSource) AddrsForNode(nodePub *btcec.PublicKey) (bool,
-	[]net.Addr, error) {
-
+func (m *mockChannelSource) AddrsForNode(nodePub *btcec.PublicKey) ([]net.Addr, error) {
 	if m.failQuery {
-		return false, nil, fmt.Errorf("fail")
+		return nil, fmt.Errorf("fail")
 	}
 
 	var nodeKey [33]byte
 	copy(nodeKey[:], nodePub.SerializeCompressed())
 
 	addrs, ok := m.addrs[nodeKey]
+	if !ok {
+		return nil, fmt.Errorf("can't find addr")
+	}
 
-	return ok, addrs, nil
+	return addrs, nil
 }
 
 // TestFetchBackupForChan tests that we're able to construct a single channel
@@ -156,8 +158,6 @@ func TestFetchStaticChanBackups(t *testing.T) {
 	chanSource.chans[randomChan2.FundingOutpoint] = randomChan2
 	chanSource.addAddrsForNode(randomChan1.IdentityPub, []net.Addr{addr1})
 	chanSource.addAddrsForNode(randomChan2.IdentityPub, []net.Addr{addr2})
-	chanSource.addAddrsForNode(randomChan2.IdentityPub, []net.Addr{addr3})
-	chanSource.addAddrsForNode(randomChan2.IdentityPub, []net.Addr{addr4})
 
 	// With the channel source populated, we'll now attempt to create a set
 	// of backups for all the channels. This should succeed, as all items

chanbackup/backupfile.go

@@ -2,13 +2,10 @@ package chanbackup
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"path/filepath"
-	"time"
 
 	"github.com/lightningnetwork/lnd/keychain"
-	"github.com/lightningnetwork/lnd/lnrpc"
 )
 
 const (
@@ -20,10 +17,6 @@ const (
 	// file that we'll use to atomically update the primary back up file
 	// when new channel are detected.
 	DefaultTempBackupFileName = "temp-dont-use.backup"
-
-	// DefaultChanBackupArchiveDirName is the default name of the directory
-	// that we'll use to store old channel backups.
-	DefaultChanBackupArchiveDirName = "chan-backup-archives"
 )
 
 var (
@@ -51,40 +44,28 @@ type MultiFile struct {
 
 	// tempFile is an open handle to the temp back up file.
 	tempFile *os.File
-
-	// archiveDir is the directory where we'll store old channel backups.
-	archiveDir string
-
-	// noBackupArchive indicates whether old backups should be deleted
-	// rather than archived.
-	noBackupArchive bool
 }
 
 // NewMultiFile create a new multi-file instance at the target location on the
 // file system.
-func NewMultiFile(fileName string, noBackupArchive bool) *MultiFile {
+func NewMultiFile(fileName string) *MultiFile {
+
 	// We'll our temporary backup file in the very same directory as the
 	// main backup file.
 	backupFileDir := filepath.Dir(fileName)
 	tempFileName := filepath.Join(
 		backupFileDir, DefaultTempBackupFileName,
 	)
-	archiveDir := filepath.Join(
-		backupFileDir, DefaultChanBackupArchiveDirName,
-	)
 
 	return &MultiFile{
-		fileName:        fileName,
-		tempFileName:    tempFileName,
-		archiveDir:      archiveDir,
-		noBackupArchive: noBackupArchive,
+		fileName:     fileName,
+		tempFileName: tempFileName,
 	}
 }
 
 // UpdateAndSwap will attempt write a new temporary backup file to disk with
 // the newBackup encoded, then atomically swap (via rename) the old file for
-// the new file by updating the name of the new file to the old. It also checks
-// if the old file should be archived first before swapping it.
+// the new file by updating the name of the new file to the old.
 func (b *MultiFile) UpdateAndSwap(newBackup PackedMulti) error {
 	// If the main backup file isn't set, then we can't proceed.
 	if b.fileName == "" {
@@ -136,12 +117,6 @@ func (b *MultiFile) UpdateAndSwap(newBackup PackedMulti) error {
 		return fmt.Errorf("unable to close file: %w", err)
 	}
 
-	// Archive the old channel backup file before replacing.
-	if err := b.createArchiveFile(); err != nil {
-		return fmt.Errorf("unable to archive old channel "+
-			"backup file: %w", err)
-	}
-
 	// Finally, we'll attempt to atomically rename the temporary file to
 	// the main back up file. If this succeeds, then we'll only have a
 	// single file on disk once this method exits.
@@ -172,74 +147,3 @@ func (b *MultiFile) ExtractMulti(keyChain keychain.KeyRing) (*Multi, error) {
 	packedMulti := PackedMulti(multiBytes)
 	return packedMulti.Unpack(keyChain)
 }
-
-// createArchiveFile creates an archive file with a timestamped name in the
-// specified archive directory, and copies the contents of the main backup file
-// to the new archive file.
-func (b *MultiFile) createArchiveFile() error {
-	// User can skip archiving of old backup files to save disk space.
-	if b.noBackupArchive {
-		log.Debug("Skipping archive of old backup file as configured")
-		return nil
-	}
-
-	// Check for old channel backup file.
-	oldFileExists := lnrpc.FileExists(b.fileName)
-	if !oldFileExists {
-		log.Debug("No old channel backup file to archive")
-		return nil
-	}
-
-	log.Infof("Archiving old channel backup to %v", b.archiveDir)
-
-	// Generate archive file path with timestamped name.
-	baseFileName := filepath.Base(b.fileName)
-	timestamp := time.Now().Format("2006-01-02-15-04-05")
-
-	archiveFileName := fmt.Sprintf("%s-%s", baseFileName, timestamp)
-	archiveFilePath := filepath.Join(b.archiveDir, archiveFileName)
-
-	oldBackupFile, err := os.Open(b.fileName)
-	if err != nil {
-		return fmt.Errorf("unable to open old channel backup file: "+
-			"%w", err)
-	}
-	defer func() {
-		err := oldBackupFile.Close()
-		if err != nil {
-			log.Errorf("unable to close old channel backup file: "+
-				"%v", err)
-		}
-	}()
-
-	// Ensure the archive directory exists. If it doesn't we create it.
-	const archiveDirPermissions = 0o700
-	err = os.MkdirAll(b.archiveDir, archiveDirPermissions)
-	if err != nil {
-		return fmt.Errorf("unable to create archive directory: %w", err)
-	}
-
-	// Create new archive file.
-	archiveFile, err := os.Create(archiveFilePath)
-	if err != nil {
-		return fmt.Errorf("unable to create archive file: %w", err)
-	}
-	defer func() {
-		err := archiveFile.Close()
-		if err != nil {
-			log.Errorf("unable to close archive file: %v", err)
-		}
-	}()
-
-	// Copy contents of old backup to the newly created archive files.
-	_, err = io.Copy(archiveFile, oldBackupFile)
-	if err != nil {
-		return fmt.Errorf("unable to copy to archive file: %w", err)
-	}
-	err = archiveFile.Sync()
-	if err != nil {
-		return fmt.Errorf("unable to sync archive file: %w", err)
-	}
-
-	return nil
-}

chanbackup/backupfile_test.go

@@ -45,121 +45,6 @@ func assertFileDeleted(t *testing.T, filePath string) {
 	}
 }
 
-// TestUpdateAndSwapWithArchive test that we're able to properly swap out old
-// backups on disk with new ones. In addition, we check for noBackupArchive to
-// ensure that the archive file is created when it's set to false, and not
-// created when it's set to true.
-func TestUpdateAndSwapWithArchive(t *testing.T) {
-	t.Parallel()
-
-	testCases := []struct {
-		name            string
-		noBackupArchive bool
-	}{
-		// Test with noBackupArchive set to true - should not create
-		// archive.
-		{
-			name:            "no archive file",
-			noBackupArchive: true,
-		},
-
-		// Test with noBackupArchive set to false - should create
-		// archive.
-		{
-			name:            "with archive file",
-			noBackupArchive: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tempTestDir := t.TempDir()
-
-			fileName := filepath.Join(
-				tempTestDir, DefaultBackupFileName,
-			)
-			tempFileName := filepath.Join(
-				tempTestDir, DefaultTempBackupFileName,
-			)
-
-			backupFile := NewMultiFile(fileName, tc.noBackupArchive)
-
-			// To start with, we'll make a random byte slice that'll
-			// pose as our packed multi backup.
-			newPackedMulti, err := makeFakePackedMulti()
-			require.NoError(t, err)
-
-			// With our backup created, we'll now attempt to swap
-			// out this backup, for the old one.
-			err = backupFile.UpdateAndSwap(newPackedMulti)
-			require.NoError(t, err)
-
-			// If we read out the file on disk, then it should match
-			// exactly what we wrote. The temp backup file should
-			// also be gone.
-			assertBackupMatches(t, fileName, newPackedMulti)
-			assertFileDeleted(t, tempFileName)
-
-			// Now that we know this is a valid test case, we'll
-			// make a new packed multi to swap out this current one.
-			newPackedMulti2, err := makeFakePackedMulti()
-			require.NoError(t, err)
-
-			// We'll then attempt to swap the old version for this
-			// new one.
-			err = backupFile.UpdateAndSwap(newPackedMulti2)
-			require.NoError(t, err)
-
-			// Once again, the file written on disk should have been
-			// properly swapped out with the new instance.
-			assertBackupMatches(t, fileName, newPackedMulti2)
-
-			// Additionally, we shouldn't be able to find the temp
-			// backup file on disk, as it should be deleted each
-			// time.
-			assertFileDeleted(t, tempFileName)
-
-			// Now check if archive was created when noBackupArchive
-			// is false.
-			archiveDir := filepath.Join(
-				filepath.Dir(fileName),
-				DefaultChanBackupArchiveDirName,
-			)
-
-			// When noBackupArchive is true, no new archive file
-			// should be created.
-			//
-			// NOTE: In a real environment, the archive directory
-			// might exist with older backups before the feature is
-			// disabled, but for test simplicity (since we clean up
-			// the directory between test cases), we verify the
-			// directory doesn't exist at all.
-			if tc.noBackupArchive {
-				require.NoDirExists(t, archiveDir)
-				return
-			}
-
-			// Otherwise we expect an archive to be created.
-			files, err := os.ReadDir(archiveDir)
-			require.NoError(t, err)
-			require.Len(t, files, 1)
-
-			// Verify the archive contents match the previous
-			// backup.
-			archiveFile := filepath.Join(
-				archiveDir, files[0].Name(),
-			)
-
-			// The archived content should match the previous backup
-			// (newPackedMulti) that was just swapped out.
-			assertBackupMatches(t, archiveFile, newPackedMulti)
-
-			// Clean up the archive directory.
-			os.RemoveAll(archiveDir)
-		})
-	}
-}
-
 // TestUpdateAndSwap test that we're able to properly swap out old backups on
 // disk with new ones. Additionally, after a swap operation succeeds, then each
 // time we should only have the main backup file on disk, as the temporary file
@@ -167,112 +52,114 @@ func TestUpdateAndSwapWithArchive(t *testing.T) {
 func TestUpdateAndSwap(t *testing.T) {
 	t.Parallel()
 
-	// Check that when the main file name is blank, an error is returned.
-	backupFile := NewMultiFile("", false)
-
-	err := backupFile.UpdateAndSwap(PackedMulti(nil))
-	require.ErrorIs(t, err, ErrNoBackupFileExists)
+	tempTestDir := t.TempDir()
 
 	testCases := []struct {
-		name          string
+		fileName     string
+		tempFileName string
+
 		oldTempExists bool
+
+		valid bool
 	}{
+		// Main file name is blank, should fail.
+		{
+			fileName: "",
+			valid:    false,
+		},
+
 		// Old temporary file still exists, should be removed. Only one
 		// file should remain.
 		{
-			name:          "remove old temp file",
+			fileName: filepath.Join(
+				tempTestDir, DefaultBackupFileName,
+			),
+			tempFileName: filepath.Join(
+				tempTestDir, DefaultTempBackupFileName,
+			),
 			oldTempExists: true,
+			valid:         true,
 		},
 
 		// Old temp doesn't exist, should swap out file, only a single
 		// file remains.
 		{
-			name:          "swap out file",
-			oldTempExists: false,
+			fileName: filepath.Join(
+				tempTestDir, DefaultBackupFileName,
+			),
+			tempFileName: filepath.Join(
+				tempTestDir, DefaultTempBackupFileName,
+			),
+			valid: true,
 		},
 	}
+	for i, testCase := range testCases {
+		backupFile := NewMultiFile(testCase.fileName)
 
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tempTestDir := t.TempDir()
+		// To start with, we'll make a random byte slice that'll pose
+		// as our packed multi backup.
+		newPackedMulti, err := makeFakePackedMulti()
+		if err != nil {
+			t.Fatalf("unable to make test backup: %v", err)
+		}
 
-			fileName := filepath.Join(
-				tempTestDir, DefaultBackupFileName,
-			)
-			tempFileName := filepath.Join(
-				tempTestDir, DefaultTempBackupFileName,
-			)
-
-			backupFile := NewMultiFile(fileName, false)
-
-			// To start with, we'll make a random byte slice that'll
-			// pose as our packed multi backup.
-			newPackedMulti, err := makeFakePackedMulti()
-			require.NoError(t, err)
-
-			// If the old temporary file is meant to exist, then
-			// we'll create it now as an empty file.
-			if tc.oldTempExists {
-				f, err := os.Create(tempFileName)
-				require.NoError(t, err)
-				require.NoError(t, f.Close())
-
-				// TODO(roasbeef): mock out fs calls?
+		// If the old temporary file is meant to exist, then we'll
+		// create it now as an empty file.
+		if testCase.oldTempExists {
+			f, err := os.Create(testCase.tempFileName)
+			if err != nil {
+				t.Fatalf("unable to create temp file: %v", err)
 			}
+			require.NoError(t, f.Close())
 
-			// With our backup created, we'll now attempt to swap
-			// out this backup, for the old one.
-			err = backupFile.UpdateAndSwap(newPackedMulti)
-			require.NoError(t, err)
+			// TODO(roasbeef): mock out fs calls?
+		}
 
-			// If we read out the file on disk, then it should match
-			// exactly what we wrote. The temp backup file should
-			// also be gone.
-			assertBackupMatches(t, fileName, newPackedMulti)
-			assertFileDeleted(t, tempFileName)
+		// With our backup created, we'll now attempt to swap out this
+		// backup, for the old one.
+		err = backupFile.UpdateAndSwap(PackedMulti(newPackedMulti))
+		switch {
+		// If this is a valid test case, and we failed, then we'll
+		// return an error.
+		case err != nil && testCase.valid:
+			t.Fatalf("#%v, unable to swap file: %v", i, err)
 
-			// Now that we know this is a valid test case, we'll
-			// make a new packed multi to swap out this current one.
-			newPackedMulti2, err := makeFakePackedMulti()
-			require.NoError(t, err)
+		// If this is an invalid test case, and we passed it, then
+		// we'll return an error.
+		case err == nil && !testCase.valid:
+			t.Fatalf("#%v file swap should have failed: %v", i, err)
+		}
 
-			// We'll then attempt to swap the old version for this
-			// new one.
-			err = backupFile.UpdateAndSwap(newPackedMulti2)
-			require.NoError(t, err)
+		if !testCase.valid {
+			continue
+		}
 
-			// Once again, the file written on disk should have been
-			// properly swapped out with the new instance.
-			assertBackupMatches(t, fileName, newPackedMulti2)
+		// If we read out the file on disk, then it should match
+		// exactly what we wrote. The temp backup file should also be
+		// gone.
+		assertBackupMatches(t, testCase.fileName, newPackedMulti)
+		assertFileDeleted(t, testCase.tempFileName)
 
-			// Additionally, we shouldn't be able to find the temp
-			// backup file on disk, as it should be deleted each
-			// time.
-			assertFileDeleted(t, tempFileName)
+		// Now that we know this is a valid test case, we'll make a new
+		// packed multi to swap out this current one.
+		newPackedMulti2, err := makeFakePackedMulti()
+		if err != nil {
+			t.Fatalf("unable to make test backup: %v", err)
+		}
 
-			// Now check if archive was created when noBackupArchive
-			// is false.
-			archiveDir := filepath.Join(
-				filepath.Dir(fileName),
-				DefaultChanBackupArchiveDirName,
-			)
-			files, err := os.ReadDir(archiveDir)
-			require.NoError(t, err)
-			require.Len(t, files, 1)
+		// We'll then attempt to swap the old version for this new one.
+		err = backupFile.UpdateAndSwap(PackedMulti(newPackedMulti2))
+		if err != nil {
+			t.Fatalf("unable to swap file: %v", err)
+		}
 
-			// Verify the archive contents match the previous
-			// backup.
-			archiveFile := filepath.Join(
-				archiveDir, files[0].Name(),
-			)
+		// Once again, the file written on disk should have been
+		// properly swapped out with the new instance.
+		assertBackupMatches(t, testCase.fileName, newPackedMulti2)
 
-			// The archived content should match the previous backup
-			// (newPackedMulti) that was just swapped out.
-			assertBackupMatches(t, archiveFile, newPackedMulti)
-
-			// Clean up the archive directory.
-			os.RemoveAll(archiveDir)
-		})
+		// Additionally, we shouldn't be able to find the temp backup
+		// file on disk, as it should be deleted each time.
+		assertFileDeleted(t, testCase.tempFileName)
 	}
 }
 
@@ -351,7 +238,7 @@ func TestExtractMulti(t *testing.T) {
 	}
 	for i, testCase := range testCases {
 		// First, we'll make our backup file with the specified name.
-		backupFile := NewMultiFile(testCase.fileName, false)
+		backupFile := NewMultiFile(testCase.fileName)
 
 		// With our file made, we'll now attempt to read out the
 		// multi-file.
@@ -387,86 +274,3 @@ func TestExtractMulti(t *testing.T) {
 		assertMultiEqual(t, &unpackedMulti, freshUnpackedMulti)
 	}
 }
-
-// TestCreateArchiveFile tests that we're able to create an archive file
-// with a timestamped name in the specified archive directory, and copy the
-// contents of the main backup file to the new archive file.
-func TestCreateArchiveFile(t *testing.T) {
-	t.Parallel()
-
-	// First, we'll create a temporary directory for our test files.
-	tempDir := t.TempDir()
-	archiveDir := filepath.Join(tempDir, DefaultChanBackupArchiveDirName)
-
-	// Next, we'll create a test backup file and write some content to it.
-	backupFile := filepath.Join(tempDir, DefaultBackupFileName)
-	testContent := []byte("test backup content")
-	err := os.WriteFile(backupFile, testContent, 0644)
-	require.NoError(t, err)
-
-	tests := []struct {
-		name            string
-		setup           func()
-		noBackupArchive bool
-		wantError       bool
-	}{
-		{
-			name:            "successful archive",
-			noBackupArchive: false,
-		},
-		{
-			name:            "skip archive when disabled",
-			noBackupArchive: true,
-		},
-		{
-			name: "invalid archive directory permissions",
-			setup: func() {
-				// Create dir with no write permissions.
-				err := os.MkdirAll(archiveDir, 0500)
-				require.NoError(t, err)
-			},
-			noBackupArchive: false,
-			wantError:       true,
-		},
-	}
-
-	for _, tc := range tests {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			defer os.RemoveAll(archiveDir)
-			if tc.setup != nil {
-				tc.setup()
-			}
-
-			multiFile := NewMultiFile(
-				backupFile, tc.noBackupArchive,
-			)
-
-			err := multiFile.createArchiveFile()
-			if tc.wantError {
-				require.Error(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-
-			// If archiving is disabled, verify no archive was
-			// created.
-			if tc.noBackupArchive {
-				require.NoDirExists(t, archiveDir)
-				return
-			}
-
-			// Verify archive exists and content matches.
-			files, err := os.ReadDir(archiveDir)
-			require.NoError(t, err)
-			require.Len(t, files, 1)
-
-			archivedContent, err := os.ReadFile(
-				filepath.Join(archiveDir, files[0].Name()),
-			)
-			require.NoError(t, err)
-			assertBackupMatches(t, backupFile, archivedContent)
-		})
-	}
-}

chanbackup/log.go

@@ -1,7 +1,7 @@
 package chanbackup
 
 import (
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 )
 

chanbackup/multi_test.go

@@ -22,9 +22,7 @@ func TestMultiPackUnpack(t *testing.T) {
 			t.Fatalf("unable to gen channel: %v", err)
 		}
 
-		single := NewSingle(
-			channel, []net.Addr{addr1, addr2, addr3, addr4},
-		)
+		single := NewSingle(channel, []net.Addr{addr1, addr2})
 
 		originalSingles = append(originalSingles, single)
 		multi.StaticBackups = append(multi.StaticBackups, single)

chanbackup/pubsub.go

@@ -6,7 +6,6 @@ import (
 	"net"
 	"os"
 	"sync"
-	"sync/atomic"
 
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/channeldb"
@@ -49,19 +48,6 @@ type ChannelEvent struct {
 	NewChans []ChannelWithAddrs
 }
 
-// manualUpdate holds a group of channel state updates and an error channel
-// to send back an error happened upon update processing or file updating.
-type manualUpdate struct {
-	// singles hold channels backups. They can be either new or known
-	// channels in the Swapper.
-	singles []Single
-
-	// errChan is the channel to send an error back. If the update handling
-	// and the subsequent file updating succeeds, nil is sent.
-	// The channel must have capacity of 1 to prevent Swapper blocking.
-	errChan chan error
-}
-
 // ChannelSubscription represents an intent to be notified of any updates to
 // the primary channel state.
 type ChannelSubscription struct {
@@ -94,12 +80,7 @@ type ChannelNotifier interface {
 // be used to implement a system that always keeps the multi-chan backup file
 // on disk in a consistent state for safety purposes.
 type SubSwapper struct {
-	// started tracks whether the SubSwapper has been started and ensures
-	// it can only be started once.
 	started sync.Once
-
-	// stopped tracks whether the SubSwapper has been stopped and ensures
-	// it can only be stopped once.
 	stopped sync.Once
 
 	// backupState are the set of SCBs for all open channels we know of.
@@ -109,8 +90,6 @@ type SubSwapper struct {
 	// over.
 	chanEvents *ChannelSubscription
 
-	manualUpdates chan manualUpdate
-
 	// keyRing is the main key ring that will allow us to pack the new
 	// multi backup.
 	keyRing keychain.KeyRing
@@ -119,11 +98,6 @@ type SubSwapper struct {
 
 	quit chan struct{}
 	wg   sync.WaitGroup
-
-	// isActive tracks whether the SubSwapper is active and ready to receive
-	// messages. It is used to prevent manual updates from being sent to the
-	// SubSwapper after it has been stopped or not yet started.
-	isActive atomic.Bool
 }
 
 // NewSubSwapper creates a new instance of the SubSwapper given the starting
@@ -152,12 +126,11 @@ func NewSubSwapper(startingChans []Single, chanNotifier ChannelNotifier,
 	}
 
 	return &SubSwapper{
-		backupState:   backupState,
-		chanEvents:    chanEvents,
-		keyRing:       keyRing,
-		Swapper:       backupSwapper,
-		quit:          make(chan struct{}),
-		manualUpdates: make(chan manualUpdate),
+		backupState: backupState,
+		chanEvents:  chanEvents,
+		keyRing:     keyRing,
+		Swapper:     backupSwapper,
+		quit:        make(chan struct{}),
 	}, nil
 }
 
@@ -173,7 +146,6 @@ func (s *SubSwapper) Start() error {
 		if err := s.updateBackupFile(); err != nil {
 			startErr = fmt.Errorf("unable to refresh backup "+
 				"file: %v", err)
-
 			return
 		}
 
@@ -190,55 +162,9 @@ func (s *SubSwapper) Stop() error {
 		log.Infof("chanbackup.SubSwapper shutting down...")
 		defer log.Debug("chanbackup.SubSwapper shutdown complete")
 
-		// Mark the SubSwapper as not running.
-		s.isActive.Store(false)
-
 		close(s.quit)
 		s.wg.Wait()
 	})
-
-	return nil
-}
-
-// ManualUpdate inserts/updates channel states into the swapper. The updates
-// are processed in another goroutine. The method waits for the updates to be
-// fully processed and the file to be updated on-disk before returning.
-func (s *SubSwapper) ManualUpdate(singles []Single) error {
-	if !s.isActive.Load() {
-		return fmt.Errorf("swapper is not active, cannot perform " +
-			"manual update")
-	}
-
-	// Create the channel to send an error back. If the update handling
-	// and the subsequent file updating succeeds, nil is sent.
-	// The channel must have capacity of 1 to prevent Swapper blocking.
-	errChan := make(chan error, 1)
-
-	// Create the update object to insert into the processing loop.
-	update := manualUpdate{
-		singles: singles,
-		errChan: errChan,
-	}
-
-	select {
-	case s.manualUpdates <- update:
-	case <-s.quit:
-		return fmt.Errorf("swapper stopped when sending manual update")
-	}
-
-	// Wait for processing, block on errChan.
-	select {
-	case err := <-errChan:
-		if err != nil {
-			return fmt.Errorf("processing of manual update "+
-				"failed: %w", err)
-		}
-
-	case <-s.quit:
-		return fmt.Errorf("swapper stopped when waiting for outcome")
-	}
-
-	// Success.
 	return nil
 }
 
@@ -318,8 +244,7 @@ func (s *SubSwapper) updateBackupFile(closedChans ...wire.OutPoint) error {
 // backupFileUpdater is the primary goroutine of the SubSwapper which is
 // responsible for listening for changes to the channel, and updating the
 // persistent multi backup state with a new packed multi of the latest channel
-// state. Once active, it will process subscription updates and manual updates
-// until the SubSwapper is stopped.
+// state.
 func (s *SubSwapper) backupUpdater() {
 	// Ensure that once we exit, we'll cancel our active channel
 	// subscription.
@@ -328,9 +253,6 @@ func (s *SubSwapper) backupUpdater() {
 
 	log.Debugf("SubSwapper's backupUpdater is active!")
 
-	// Mark the SubSwapper as active.
-	s.isActive.Store(true)
-
 	for {
 		select {
 		// The channel state has been modified! We'll evaluate all
@@ -345,10 +267,9 @@ func (s *SubSwapper) backupUpdater() {
 				log.Debugf("Adding channel %v to backup state",
 					newChan.FundingOutpoint)
 
-				single := NewSingle(
+				s.backupState[newChan.FundingOutpoint] = NewSingle(
 					newChan.OpenChannel, newChan.Addrs,
 				)
-				s.backupState[newChan.FundingOutpoint] = single
 			}
 
 			// For all closed channels, we'll remove the prior
@@ -372,45 +293,13 @@ func (s *SubSwapper) backupUpdater() {
 				"num_old_chans=%v, num_new_chans=%v",
 				oldStateSize, newStateSize)
 
-			// Without new state constructed, we'll, atomically
+			// With out new state constructed, we'll, atomically
 			// update the on-disk backup state.
 			if err := s.updateBackupFile(closedChans...); err != nil {
 				log.Errorf("unable to update backup file: %v",
 					err)
 			}
 
-		// We received a manual update. Handle it and update the file.
-		case manualUpdate := <-s.manualUpdates:
-			oldStateSize := len(s.backupState)
-
-			// For all open channels, we'll create a new SCB given
-			// the required information.
-			for _, single := range manualUpdate.singles {
-				log.Debugf("Manual update of channel %v",
-					single.FundingOutpoint)
-
-				s.backupState[single.FundingOutpoint] = single
-			}
-
-			newStateSize := len(s.backupState)
-
-			log.Infof("Updating on-disk multi SCB backup: "+
-				"num_old_chans=%v, num_new_chans=%v",
-				oldStateSize, newStateSize)
-
-			// Without new state constructed, we'll, atomically
-			// update the on-disk backup state.
-			err := s.updateBackupFile()
-			if err != nil {
-				log.Errorf("unable to update backup file: %v",
-					err)
-			}
-
-			// Send the error (or nil) to the caller of
-			// ManualUpdate. The error channel must have capacity of
-			// 1 not to block here.
-			manualUpdate.errChan <- err
-
 		// TODO(roasbeef): refresh periodically on a time basis due to
 		// possible addr changes from node
 

chanbackup/pubsub_test.go

@@ -277,18 +277,4 @@ func TestSubSwapperUpdater(t *testing.T) {
 	// Verify that the new set of backups, now has one less after the
 	// sub-swapper switches the new set with the old.
 	assertExpectedBackupSwap(t, swapper, subSwapper, keyRing, backupSet)
-
-	// Check ManualUpdate method.
-	channel, err := genRandomOpenChannelShell()
-	require.NoError(t, err)
-	single := NewSingle(channel, nil)
-	backupSet[channel.FundingOutpoint] = single
-	require.NoError(t, subSwapper.ManualUpdate([]Single{single}))
-
-	// Verify that the state of the backup is as expected.
-	assertExpectedBackupSwap(t, swapper, subSwapper, keyRing, backupSet)
-
-	// Check the case ManualUpdate returns an error.
-	swapper.fail = true
-	require.Error(t, subSwapper.ManualUpdate([]Single{single}))
 }

chanbackup/recover.go

@@ -40,11 +40,9 @@ type PeerConnector interface {
 // the channel. In addition a LinkNode will be created for each new peer as
 // well, in order to expose the addressing information required to locate to
 // and connect to each peer in order to initiate the recovery protocol.
-// The number of channels that were successfully restored is returned.
 func Recover(backups []Single, restorer ChannelRestorer,
-	peerConnector PeerConnector) (int, error) {
+	peerConnector PeerConnector) error {
 
-	var numRestored int
 	for i, backup := range backups {
 		log.Infof("Restoring ChannelPoint(%v) to disk: ",
 			backup.FundingOutpoint)
@@ -59,10 +57,9 @@ func Recover(backups []Single, restorer ChannelRestorer,
 			continue
 		}
 		if err != nil {
-			return numRestored, err
+			return err
 		}
 
-		numRestored++
 		log.Infof("Attempting to connect to node=%x (addrs=%v) to "+
 			"restore ChannelPoint(%v)",
 			backup.RemoteNodePub.SerializeCompressed(),
@@ -73,7 +70,7 @@ func Recover(backups []Single, restorer ChannelRestorer,
 			backup.RemoteNodePub, backup.Addresses,
 		)
 		if err != nil {
-			return numRestored, err
+			return err
 		}
 
 		// TODO(roasbeef): to handle case where node has changed addrs,
@@ -83,7 +80,7 @@ func Recover(backups []Single, restorer ChannelRestorer,
 		//  * just to to fresh w/ call to node addrs and de-dup?
 	}
 
-	return numRestored, nil
+	return nil
 }
 
 // TODO(roasbeef): more specific keychain interface?
@@ -91,17 +88,16 @@ func Recover(backups []Single, restorer ChannelRestorer,
 // UnpackAndRecoverSingles is a one-shot method, that given a set of packed
 // single channel backups, will restore the channel state to a channel shell,
 // and also reach out to connect to any of the known node addresses for that
-// channel. It is assumes that after this method exists, if a connection was
-// established, then the PeerConnector will continue to attempt to re-establish
-// a persistent connection in the background. The number of channels that were
-// successfully restored is returned.
+// channel. It is assumes that after this method exists, if a connection we
+// able to be established, then then PeerConnector will continue to attempt to
+// re-establish a persistent connection in the background.
 func UnpackAndRecoverSingles(singles PackedSingles,
 	keyChain keychain.KeyRing, restorer ChannelRestorer,
-	peerConnector PeerConnector) (int, error) {
+	peerConnector PeerConnector) error {
 
 	chanBackups, err := singles.Unpack(keyChain)
 	if err != nil {
-		return 0, err
+		return err
 	}
 
 	return Recover(chanBackups, restorer, peerConnector)
@@ -110,17 +106,16 @@ func UnpackAndRecoverSingles(singles PackedSingles,
 // UnpackAndRecoverMulti is a one-shot method, that given a set of packed
 // multi-channel backups, will restore the channel states to channel shells,
 // and also reach out to connect to any of the known node addresses for that
-// channel. It is assumes that after this method exists, if a connection was
-// established, then the PeerConnector will continue to attempt to re-establish
-// a persistent connection in the background. The number of channels that were
-// successfully restored is returned.
+// channel. It is assumes that after this method exists, if a connection we
+// able to be established, then then PeerConnector will continue to attempt to
+// re-establish a persistent connection in the background.
 func UnpackAndRecoverMulti(packedMulti PackedMulti,
 	keyChain keychain.KeyRing, restorer ChannelRestorer,
-	peerConnector PeerConnector) (int, error) {
+	peerConnector PeerConnector) error {
 
 	chanBackups, err := packedMulti.Unpack(keyChain)
 	if err != nil {
-		return 0, err
+		return err
 	}
 
 	return Recover(chanBackups.StaticBackups, restorer, peerConnector)

chanbackup/recover_test.go

@@ -2,7 +2,7 @@ package chanbackup
 
 import (
 	"bytes"
-	"errors"
+	"fmt"
 	"net"
 	"testing"
 
@@ -11,12 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-var (
-	errRestoreFail = errors.New("restore fail")
-
-	errConnectFail = errors.New("connect fail")
-)
-
 type mockChannelRestorer struct {
 	fail bool
 
@@ -25,7 +19,7 @@ type mockChannelRestorer struct {
 
 func (m *mockChannelRestorer) RestoreChansFromSingles(...Single) error {
 	if m.fail {
-		return errRestoreFail
+		return fmt.Errorf("fail")
 	}
 
 	m.callCount++
@@ -39,11 +33,11 @@ type mockPeerConnector struct {
 	callCount int
 }
 
-func (m *mockPeerConnector) ConnectPeer(_ *btcec.PublicKey,
-	_ []net.Addr) error {
+func (m *mockPeerConnector) ConnectPeer(node *btcec.PublicKey,
+	addrs []net.Addr) error {
 
 	if m.fail {
-		return errConnectFail
+		return fmt.Errorf("fail")
 	}
 
 	m.callCount++
@@ -65,13 +59,16 @@ func TestUnpackAndRecoverSingles(t *testing.T) {
 	var packedBackups PackedSingles
 	for i := 0; i < numSingles; i++ {
 		channel, err := genRandomOpenChannelShell()
-		require.NoError(t, err)
+		if err != nil {
+			t.Fatalf("unable make channel: %v", err)
+		}
 
 		single := NewSingle(channel, nil)
 
 		var b bytes.Buffer
-		err = single.PackToWriter(&b, keyRing)
-		require.NoError(t, err)
+		if err := single.PackToWriter(&b, keyRing); err != nil {
+			t.Fatalf("unable to pack single: %v", err)
+		}
 
 		backups = append(backups, single)
 		packedBackups = append(packedBackups, b.Bytes())
@@ -86,47 +83,54 @@ func TestUnpackAndRecoverSingles(t *testing.T) {
 	// If we make the channel restore fail, then the entire method should
 	// as well
 	chanRestorer.fail = true
-	_, err := UnpackAndRecoverSingles(
+	err := UnpackAndRecoverSingles(
 		packedBackups, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.ErrorIs(t, err, errRestoreFail)
+	if err == nil {
+		t.Fatalf("restoration should have failed")
+	}
 
 	chanRestorer.fail = false
 
 	// If we make the peer connector fail, then the entire method should as
 	// well
 	peerConnector.fail = true
-	_, err = UnpackAndRecoverSingles(
+	err = UnpackAndRecoverSingles(
 		packedBackups, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.ErrorIs(t, err, errConnectFail)
+	if err == nil {
+		t.Fatalf("restoration should have failed")
+	}
 
 	chanRestorer.callCount--
 	peerConnector.fail = false
 
 	// Next, we'll ensure that if all the interfaces function as expected,
 	// then the channels will properly be unpacked and restored.
-	numRestored, err := UnpackAndRecoverSingles(
+	err = UnpackAndRecoverSingles(
 		packedBackups, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.NoError(t, err)
-	require.EqualValues(t, numSingles, numRestored)
+	require.NoError(t, err, "unable to recover chans")
 
 	// Both the restorer, and connector should have been called 10 times,
 	// once for each backup.
-	require.EqualValues(
-		t, numSingles, chanRestorer.callCount, "restorer call count",
-	)
-	require.EqualValues(
-		t, numSingles, peerConnector.callCount, "peer call count",
-	)
+	if chanRestorer.callCount != numSingles {
+		t.Fatalf("expected %v calls, instead got %v",
+			numSingles, chanRestorer.callCount)
+	}
+	if peerConnector.callCount != numSingles {
+		t.Fatalf("expected %v calls, instead got %v",
+			numSingles, peerConnector.callCount)
+	}
 
 	// If we modify the keyRing, then unpacking should fail.
 	keyRing.Fail = true
-	_, err = UnpackAndRecoverSingles(
+	err = UnpackAndRecoverSingles(
 		packedBackups, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.ErrorContains(t, err, "fail")
+	if err == nil {
+		t.Fatalf("unpacking should have failed")
+	}
 
 	// TODO(roasbeef): verify proper call args
 }
@@ -144,7 +148,9 @@ func TestUnpackAndRecoverMulti(t *testing.T) {
 	backups := make([]Single, 0, numSingles)
 	for i := 0; i < numSingles; i++ {
 		channel, err := genRandomOpenChannelShell()
-		require.NoError(t, err)
+		if err != nil {
+			t.Fatalf("unable make channel: %v", err)
+		}
 
 		single := NewSingle(channel, nil)
 
@@ -156,8 +162,9 @@ func TestUnpackAndRecoverMulti(t *testing.T) {
 	}
 
 	var b bytes.Buffer
-	err := multi.PackToWriter(&b, keyRing)
-	require.NoError(t, err)
+	if err := multi.PackToWriter(&b, keyRing); err != nil {
+		t.Fatalf("unable to pack multi: %v", err)
+	}
 
 	// Next, we'll pack the set of singles into a packed multi, and also
 	// create the set of interfaces we need to carry out the remainder of
@@ -170,47 +177,54 @@ func TestUnpackAndRecoverMulti(t *testing.T) {
 	// If we make the channel restore fail, then the entire method should
 	// as well
 	chanRestorer.fail = true
-	_, err = UnpackAndRecoverMulti(
+	err := UnpackAndRecoverMulti(
 		packedMulti, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.ErrorIs(t, err, errRestoreFail)
+	if err == nil {
+		t.Fatalf("restoration should have failed")
+	}
 
 	chanRestorer.fail = false
 
 	// If we make the peer connector fail, then the entire method should as
 	// well
 	peerConnector.fail = true
-	_, err = UnpackAndRecoverMulti(
+	err = UnpackAndRecoverMulti(
 		packedMulti, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.ErrorIs(t, err, errConnectFail)
+	if err == nil {
+		t.Fatalf("restoration should have failed")
+	}
 
 	chanRestorer.callCount--
 	peerConnector.fail = false
 
 	// Next, we'll ensure that if all the interfaces function as expected,
 	// then the channels will properly be unpacked and restored.
-	numRestored, err := UnpackAndRecoverMulti(
+	err = UnpackAndRecoverMulti(
 		packedMulti, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.NoError(t, err)
-	require.EqualValues(t, numSingles, numRestored)
+	require.NoError(t, err, "unable to recover chans")
 
 	// Both the restorer, and connector should have been called 10 times,
 	// once for each backup.
-	require.EqualValues(
-		t, numSingles, chanRestorer.callCount, "restorer call count",
-	)
-	require.EqualValues(
-		t, numSingles, peerConnector.callCount, "peer call count",
-	)
+	if chanRestorer.callCount != numSingles {
+		t.Fatalf("expected %v calls, instead got %v",
+			numSingles, chanRestorer.callCount)
+	}
+	if peerConnector.callCount != numSingles {
+		t.Fatalf("expected %v calls, instead got %v",
+			numSingles, peerConnector.callCount)
+	}
 
 	// If we modify the keyRing, then unpacking should fail.
 	keyRing.Fail = true
-	_, err = UnpackAndRecoverMulti(
+	err = UnpackAndRecoverMulti(
 		packedMulti, keyRing, &chanRestorer, &peerConnector,
 	)
-	require.ErrorContains(t, err, "fail")
+	if err == nil {
+		t.Fatalf("unpacking should have failed")
+	}
 
 	// TODO(roasbeef): verify proper call args
 }

chanbackup/single.go

@@ -2,7 +2,6 @@ package chanbackup
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"net"
@@ -12,7 +11,6 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/lnencrypt"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -54,55 +52,8 @@ const (
 	// SimpleTaprootVersion is a version that denotes this channel is using
 	// the musig2 based taproot commitment format.
 	SimpleTaprootVersion = 5
-
-	// TapscriptRootVersion is a version that denotes this is a MuSig2
-	// channel with a top level tapscript commitment.
-	TapscriptRootVersion = 6
-
-	// closeTxVersionMask is the byte mask used that is ORed to version byte
-	// on wire indicating that the backup has CloseTxInputs.
-	closeTxVersionMask = 1 << 7
 )
 
-// Encode returns encoding of the version to put into channel backup.
-// Argument "closeTx" specifies if the backup includes force close transaction.
-func (v SingleBackupVersion) Encode(closeTx bool) byte {
-	encoded := byte(v)
-
-	// If the backup includes closing transaction, set this bit in the
-	// encoded version.
-	if closeTx {
-		encoded |= closeTxVersionMask
-	}
-
-	return encoded
-}
-
-// DecodeVersion decodes the encoding of the version from a channel backup.
-// It returns the version and if the backup includes the force close tx.
-func DecodeVersion(encoded byte) (SingleBackupVersion, bool) {
-	// Find if it has a closing transaction by inspecting the bit.
-	closeTx := (encoded & closeTxVersionMask) != 0
-
-	// The version byte also encodes the closeTxVersion feature, so we
-	// extract it here and return it separately to the backup version.
-	version := SingleBackupVersion(encoded &^ closeTxVersionMask)
-
-	return version, closeTx
-}
-
-// IsTaproot returns if this is a backup of a taproot channel. This will also be
-// true for simple taproot overlay channels when a version is added.
-func (v SingleBackupVersion) IsTaproot() bool {
-	return v == SimpleTaprootVersion || v == TapscriptRootVersion
-}
-
-// HasTapscriptRoot returns true if the channel is using a top level tapscript
-// root commitment.
-func (v SingleBackupVersion) HasTapscriptRoot() bool {
-	return v == TapscriptRootVersion
-}
-
 // Single is a static description of an existing channel that can be used for
 // the purposes of backing up. The fields in this struct allow a node to
 // recover the settled funds within a channel in the case of partial or
@@ -187,47 +138,11 @@ type Single struct {
 	//
 	// - ScriptEnforcedLeaseVersion
 	LeaseExpiry uint32
-
-	// CloseTxInputs contains data needed to produce a force close tx
-	// using for example the "chantools scbforceclose" command.
-	//
-	// The field is optional.
-	CloseTxInputs fn.Option[CloseTxInputs]
-}
-
-// CloseTxInputs contains data needed to produce a force close transaction
-// using for example the "chantools scbforceclose" command.
-type CloseTxInputs struct {
-	// CommitTx is the latest version of the commitment state, broadcast
-	// able by us, but not signed. It can be signed by for example the
-	// "chantools scbforceclose" command.
-	CommitTx *wire.MsgTx
-
-	// CommitSig is one half of the signature required to fully complete
-	// the script for the commitment transaction above. This is the
-	// signature signed by the remote party for our version of the
-	// commitment transactions.
-	CommitSig []byte
-
-	// CommitHeight is the update number that this ChannelDelta represents
-	// the total number of commitment updates to this point. This can be
-	// viewed as sort of a "commitment height" as this number is
-	// monotonically increasing.
-	//
-	// This field is filled only for taproot channels.
-	CommitHeight uint64
-
-	// TapscriptRoot is the root of the tapscript tree that will be used to
-	// create the funding output. This is an optional field that should
-	// only be set for overlay taproot channels (HasTapscriptRoot).
-	TapscriptRoot fn.Option[chainhash.Hash]
 }
 
 // NewSingle creates a new static channel backup based on an existing open
 // channel. We also pass in the set of addresses that we used in the past to
-// connect to the channel peer. If possible, we include the data needed to
-// produce a force close transaction from the most recent state using externally
-// provided private key.
+// connect to the channel peer.
 func NewSingle(channel *channeldb.OpenChannel,
 	nodeAddrs []net.Addr) Single {
 
@@ -303,11 +218,7 @@ func NewSingle(channel *channeldb.OpenChannel,
 
 	switch {
 	case channel.ChanType.IsTaproot():
-		if channel.ChanType.HasTapscriptRoot() {
-			single.Version = TapscriptRootVersion
-		} else {
-			single.Version = SimpleTaprootVersion
-		}
+		single.Version = SimpleTaprootVersion
 
 	case channel.ChanType.HasLeaseExpiration():
 		single.Version = ScriptEnforcedLeaseVersion
@@ -326,18 +237,9 @@ func NewSingle(channel *channeldb.OpenChannel,
 		single.Version = DefaultSingleVersion
 	}
 
-	// Include unsigned force-close transaction for the most recent channel
-	// state as well as the data needed to produce the signature, given the
-	// private key is provided separately.
-	single.CloseTxInputs = buildCloseTxInputs(channel)
-
 	return single
 }
 
-// errEmptyTapscriptRoot is returned by Serialize if field TapscriptRoot is
-// empty, when it should be filled according to the channel version.
-var errEmptyTapscriptRoot = errors.New("field TapscriptRoot is not filled")
-
 // Serialize attempts to write out the serialized version of the target
 // StaticChannelBackup into the passed io.Writer.
 func (s *Single) Serialize(w io.Writer) error {
@@ -350,7 +252,6 @@ func (s *Single) Serialize(w io.Writer) error {
 	case AnchorsZeroFeeHtlcTxCommitVersion:
 	case ScriptEnforcedLeaseVersion:
 	case SimpleTaprootVersion:
-	case TapscriptRootVersion:
 	default:
 		return fmt.Errorf("unable to serialize w/ unknown "+
 			"version: %v", s.Version)
@@ -419,60 +320,6 @@ func (s *Single) Serialize(w io.Writer) error {
 		}
 	}
 
-	// Encode version enum and hasCloseTx flag to version byte.
-	version := s.Version.Encode(s.CloseTxInputs.IsSome())
-
-	// Serialize CloseTxInputs if it is provided. Fill err if it fails.
-	err := fn.MapOptionZ(s.CloseTxInputs, func(inputs CloseTxInputs) error {
-		err := inputs.CommitTx.Serialize(&singleBytes)
-		if err != nil {
-			return err
-		}
-
-		err = lnwire.WriteElements(
-			&singleBytes,
-			uint16(len(inputs.CommitSig)), inputs.CommitSig,
-		)
-		if err != nil {
-			return err
-		}
-
-		if !s.Version.IsTaproot() {
-			return nil
-		}
-
-		// Write fields needed for taproot channels.
-		err = lnwire.WriteElements(
-			&singleBytes, inputs.CommitHeight,
-		)
-		if err != nil {
-			return err
-		}
-
-		if s.Version.HasTapscriptRoot() {
-			opt := inputs.TapscriptRoot
-			var tapscriptRoot chainhash.Hash
-			tapscriptRoot, err = opt.UnwrapOrErr(
-				errEmptyTapscriptRoot,
-			)
-			if err != nil {
-				return err
-			}
-
-			err = lnwire.WriteElements(
-				&singleBytes, tapscriptRoot[:],
-			)
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return fmt.Errorf("failed to encode CloseTxInputs: %w", err)
-	}
-
 	// TODO(yy): remove the type assertion when we finished refactoring db
 	// into using write buffer.
 	buf, ok := w.(*bytes.Buffer)
@@ -482,7 +329,7 @@ func (s *Single) Serialize(w io.Writer) error {
 
 	return lnwire.WriteElements(
 		buf,
-		version,
+		byte(s.Version),
 		uint16(len(singleBytes.Bytes())),
 		singleBytes.Bytes(),
 	)
@@ -573,9 +420,7 @@ func (s *Single) Deserialize(r io.Reader) error {
 		return err
 	}
 
-	// Decode version byte to version enum and hasCloseTx flag.
-	var hasCloseTx bool
-	s.Version, hasCloseTx = DecodeVersion(version)
+	s.Version = SingleBackupVersion(version)
 
 	switch s.Version {
 	case DefaultSingleVersion:
@@ -584,7 +429,6 @@ func (s *Single) Deserialize(r io.Reader) error {
 	case AnchorsZeroFeeHtlcTxCommitVersion:
 	case ScriptEnforcedLeaseVersion:
 	case SimpleTaprootVersion:
-	case TapscriptRootVersion:
 	default:
 		return fmt.Errorf("unable to de-serialize w/ unknown "+
 			"version: %v", s.Version)
@@ -689,50 +533,6 @@ func (s *Single) Deserialize(r io.Reader) error {
 		}
 	}
 
-	if !hasCloseTx {
-		return nil
-	}
-
-	// Deserialize CloseTxInputs if it is present in serialized data.
-	commitTx := &wire.MsgTx{}
-	if err := commitTx.Deserialize(r); err != nil {
-		return err
-	}
-
-	var commitSigLen uint16
-	if err := lnwire.ReadElement(r, &commitSigLen); err != nil {
-		return err
-	}
-	commitSig := make([]byte, commitSigLen)
-	if err := lnwire.ReadElement(r, commitSig); err != nil {
-		return err
-	}
-
-	var commitHeight uint64
-	if s.Version.IsTaproot() {
-		err := lnwire.ReadElement(r, &commitHeight)
-		if err != nil {
-			return err
-		}
-	}
-
-	tapscriptRootOpt := fn.None[chainhash.Hash]()
-	if s.Version.HasTapscriptRoot() {
-		var tapscriptRoot chainhash.Hash
-		err := lnwire.ReadElement(r, tapscriptRoot[:])
-		if err != nil {
-			return err
-		}
-		tapscriptRootOpt = fn.Some(tapscriptRoot)
-	}
-
-	s.CloseTxInputs = fn.Some(CloseTxInputs{
-		CommitTx:      commitTx,
-		CommitSig:     commitSig,
-		CommitHeight:  commitHeight,
-		TapscriptRoot: tapscriptRootOpt,
-	})
-
 	return nil
 }
 

chanbackup/single_test.go

@@ -13,12 +13,10 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/lnencrypt"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/shachain"
-	"github.com/lightningnetwork/lnd/tor"
 	"github.com/stretchr/testify/require"
 )
 
@@ -37,15 +35,6 @@ var (
 
 	addr1, _ = net.ResolveTCPAddr("tcp", "10.0.0.2:9000")
 	addr2, _ = net.ResolveTCPAddr("tcp", "10.0.0.3:9000")
-	addr3    = &tor.OnionAddr{
-		OnionService: "3g2upl4pq6kufc4m.onion",
-		Port:         9735,
-	}
-	addr4 = &lnwire.OpaqueAddrs{
-		// The first byte must be an address type we are not yet aware
-		// of for it to be a valid OpaqueAddrs.
-		Payload: []byte{math.MaxUint8, 1, 2, 3, 4},
-	}
 )
 
 func assertSingleEqual(t *testing.T, a, b Single) {
@@ -106,29 +95,6 @@ func assertSingleEqual(t *testing.T, a, b Single) {
 				a.Addresses[i], b.Addresses[i])
 		}
 	}
-
-	// Make sure that CloseTxInputs are present either in both backups,
-	// or in none of them.
-	require.Equal(t, a.CloseTxInputs.IsSome(), b.CloseTxInputs.IsSome())
-
-	if a.CloseTxInputs.IsSome() {
-		// Cache CloseTxInputs into short variables.
-		ai := a.CloseTxInputs.UnwrapOrFail(t)
-		bi := b.CloseTxInputs.UnwrapOrFail(t)
-
-		// Compare serialized unsigned transactions.
-		var abuf, bbuf bytes.Buffer
-		require.NoError(t, ai.CommitTx.Serialize(&abuf))
-		require.NoError(t, bi.CommitTx.Serialize(&bbuf))
-		aBytes := abuf.Bytes()
-		bBytes := bbuf.Bytes()
-		require.Equal(t, aBytes, bBytes)
-
-		// Compare counterparty's signature and commit height.
-		require.Equal(t, ai.CommitSig, bi.CommitSig)
-		require.Equal(t, ai.CommitHeight, bi.CommitHeight)
-		require.Equal(t, ai.TapscriptRoot, bi.TapscriptRoot)
-	}
 }
 
 func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
@@ -158,7 +124,7 @@ func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
 		isInitiator = true
 	}
 
-	chanType := channeldb.ChannelType(rand.Intn(1 << 12))
+	chanType := channeldb.ChannelType(rand.Intn(8))
 
 	localCfg := channeldb.ChannelConfig{
 		ChannelStateBounds: channeldb.ChannelStateBounds{},
@@ -218,29 +184,6 @@ func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
 		},
 	}
 
-	var localCommit channeldb.ChannelCommitment
-	if chanType.IsTaproot() {
-		var commitSig [64]byte
-		if _, err := rand.Read(commitSig[:]); err != nil {
-			return nil, err
-		}
-
-		localCommit = channeldb.ChannelCommitment{
-			CommitTx:     sampleCommitTx,
-			CommitSig:    commitSig[:],
-			CommitHeight: rand.Uint64(),
-		}
-	}
-
-	var tapscriptRootOption fn.Option[chainhash.Hash]
-	if chanType.HasTapscriptRoot() {
-		var tapscriptRoot chainhash.Hash
-		if _, err := rand.Read(tapscriptRoot[:]); err != nil {
-			return nil, err
-		}
-		tapscriptRootOption = fn.Some(tapscriptRoot)
-	}
-
 	return &channeldb.OpenChannel{
 		ChainHash:       chainHash,
 		ChanType:        chanType,
@@ -253,61 +196,10 @@ func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
 		IdentityPub:        pub,
 		LocalChanCfg:       localCfg,
 		RemoteChanCfg:      remoteCfg,
-		LocalCommitment:    localCommit,
 		RevocationProducer: shaChainProducer,
-		TapscriptRoot:      tapscriptRootOption,
 	}, nil
 }
 
-// TestVersionEncoding tests encoding and decoding of version byte.
-func TestVersionEncoding(t *testing.T) {
-	cases := []struct {
-		version     SingleBackupVersion
-		hasCloseTx  bool
-		versionByte byte
-	}{
-		{
-			version:     DefaultSingleVersion,
-			hasCloseTx:  false,
-			versionByte: DefaultSingleVersion,
-		},
-		{
-			version:     DefaultSingleVersion,
-			hasCloseTx:  true,
-			versionByte: DefaultSingleVersion | closeTxVersionMask,
-		},
-		{
-			version:     AnchorsCommitVersion,
-			hasCloseTx:  false,
-			versionByte: AnchorsCommitVersion,
-		},
-		{
-			version:     AnchorsCommitVersion,
-			hasCloseTx:  true,
-			versionByte: AnchorsCommitVersion | closeTxVersionMask,
-		},
-	}
-
-	for _, tc := range cases {
-		gotVersionByte := tc.version.Encode(tc.hasCloseTx)
-		require.Equal(t, tc.versionByte, gotVersionByte)
-
-		gotVersion, gotHasCloseTx := DecodeVersion(tc.versionByte)
-		require.Equal(t, tc.version, gotVersion)
-		require.Equal(t, tc.hasCloseTx, gotHasCloseTx)
-	}
-}
-
-var sampleCommitTx = &wire.MsgTx{
-	TxIn: []*wire.TxIn{
-		{PreviousOutPoint: wire.OutPoint{Hash: [32]byte{1}}},
-	},
-	TxOut: []*wire.TxOut{
-		{Value: 1e8, PkScript: []byte("1")},
-		{Value: 2e8, PkScript: []byte("2")},
-	},
-}
-
 // TestSinglePackUnpack tests that we're able to unpack a previously packed
 // channel backup.
 func TestSinglePackUnpack(t *testing.T) {
@@ -319,9 +211,7 @@ func TestSinglePackUnpack(t *testing.T) {
 	channel, err := genRandomOpenChannelShell()
 	require.NoError(t, err, "unable to gen open channel")
 
-	singleChanBackup := NewSingle(
-		channel, []net.Addr{addr1, addr2, addr3, addr4},
-	)
+	singleChanBackup := NewSingle(channel, []net.Addr{addr1, addr2})
 
 	keyRing := &lnencrypt.MockKeyRing{}
 
@@ -330,9 +220,6 @@ func TestSinglePackUnpack(t *testing.T) {
 		// decode/encode the final SCB.
 		version SingleBackupVersion
 
-		// closeTxInputs is the data needed to produce a force close tx.
-		closeTxInputs fn.Option[CloseTxInputs]
-
 		// valid tests us if this test case should pass or not.
 		valid bool
 	}{
@@ -363,111 +250,16 @@ func TestSinglePackUnpack(t *testing.T) {
 			valid:   true,
 		},
 
-		// The new taproot channel version should
-		// pack/unpack with no problem.
-		{
-			version: SimpleTaprootVersion,
-			valid:   true,
-		},
-
-		// The new tapscript root channel version should pack/unpack
-		// with no problem.
-		{
-			version: TapscriptRootVersion,
-			valid:   true,
-		},
-
 		// A non-default version, atm this should result in a failure.
 		{
 			version: 99,
 			valid:   false,
 		},
-
-		// Versions with CloseTxInputs.
-		{
-			version: DefaultSingleVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:  sampleCommitTx,
-				CommitSig: []byte("signature"),
-			}),
-			valid: true,
-		},
-		{
-			version: TweaklessCommitVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:  sampleCommitTx,
-				CommitSig: []byte("signature"),
-			}),
-			valid: true,
-		},
-		{
-			version: AnchorsCommitVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:  sampleCommitTx,
-				CommitSig: []byte("signature"),
-			}),
-			valid: true,
-		},
-		{
-			version: ScriptEnforcedLeaseVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:  sampleCommitTx,
-				CommitSig: []byte("signature"),
-			}),
-			valid: true,
-		},
-		{
-			version: SimpleTaprootVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:     sampleCommitTx,
-				CommitSig:    []byte("signature"),
-				CommitHeight: 42,
-			}),
-			valid: true,
-		},
-		{
-			version: TapscriptRootVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:      sampleCommitTx,
-				CommitSig:     []byte("signature"),
-				CommitHeight:  42,
-				TapscriptRoot: fn.Some(chainhash.Hash{1}),
-			}),
-			valid: true,
-		},
-		{
-			version: 99,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:  sampleCommitTx,
-				CommitSig: []byte("signature"),
-			}),
-			valid: false,
-		},
-		{
-			version: 99,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:     sampleCommitTx,
-				CommitSig:    []byte("signature"),
-				CommitHeight: 42,
-			}),
-			valid: false,
-		},
-		{
-			version: TapscriptRootVersion,
-			closeTxInputs: fn.Some(CloseTxInputs{
-				CommitTx:     sampleCommitTx,
-				CommitSig:    []byte("signature"),
-				CommitHeight: 42,
-				// TapscriptRoot is not filled.
-			}),
-			valid: false,
-		},
 	}
 	for i, versionCase := range versionTestCases {
 		// First, we'll re-assign SCB version to what was indicated in
 		// the test case.
 		singleChanBackup.Version = versionCase.version
-		singleChanBackup.CloseTxInputs = versionCase.closeTxInputs
 
 		var b bytes.Buffer
 
@@ -646,9 +438,7 @@ func TestSingleUnconfirmedChannel(t *testing.T) {
 	channel.ShortChannelID.BlockHeight = 0
 	channel.FundingBroadcastHeight = fundingBroadcastHeight
 
-	singleChanBackup := NewSingle(
-		channel, []net.Addr{addr1, addr2, addr3, addr4},
-	)
+	singleChanBackup := NewSingle(channel, []net.Addr{addr1, addr2})
 	keyRing := &lnencrypt.MockKeyRing{}
 
 	// Pack it and then unpack it again to make sure everything is written

chanfitness/log.go

@@ -1,7 +1,7 @@
 package chanfitness
 
 import (
-	"github.com/btcsuite/btclog/v2"
+	"github.com/btcsuite/btclog"
 	"github.com/lightningnetwork/lnd/build"
 )
 

channel_notifier.go

@@ -2,13 +2,24 @@ package lnd
 
 import (
 	"fmt"
+	"net"
 
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/chanbackup"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/channelnotifier"
 )
 
+// addrSource is an interface that allow us to get the addresses for a target
+// node. We'll need this in order to be able to properly proxy the
+// notifications to create SCBs.
+type addrSource interface {
+	// AddrsForNode returns all known addresses for the target node public
+	// key.
+	AddrsForNode(nodePub *btcec.PublicKey) ([]net.Addr, error)
+}
+
 // channelNotifier is an implementation of the chanbackup.ChannelNotifier
 // interface using the existing channelnotifier.ChannelNotifier struct. This
 // implementation allows us to satisfy all the dependencies of the
@@ -21,7 +32,7 @@ type channelNotifier struct {
 	// addrs is an implementation of the addrSource interface that allows
 	// us to get the latest set of addresses for a given node. We'll need
 	// this to be able to create an SCB for new channels.
-	addrs channeldb.AddrSource
+	addrs addrSource
 }
 
 // SubscribeChans requests a new channel subscription relative to the initial
@@ -45,7 +56,7 @@ func (c *channelNotifier) SubscribeChans(startingChans map[wire.OutPoint]struct{
 	// chanUpdates channel to inform subscribers about new pending or
 	// confirmed channels.
 	sendChanOpenUpdate := func(newOrPendingChan *channeldb.OpenChannel) {
-		_, nodeAddrs, err := c.addrs.AddrsForNode(
+		nodeAddrs, err := c.addrs.AddrsForNode(
 			newOrPendingChan.IdentityPub,
 		)
 		if err != nil {

channeldb/addr.go

@@ -1,4 +1,4 @@
-package graphdb
+package channeldb
 
 import (
 	"encoding/binary"
@@ -7,7 +7,6 @@ import (
 	"io"
 	"net"
 
-	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/tor"
 )
 
@@ -27,10 +26,6 @@ const (
 
 	// v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
 	v3OnionAddr addressType = 3
-
-	// opaqueAddrs denotes an address (or a set of addresses) that LND was
-	// not able to parse since LND is not yet aware of the address type.
-	opaqueAddrs addressType = 4
 )
 
 // encodeTCPAddr serializes a TCP address into its compact raw bytes
@@ -126,31 +121,10 @@ func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {
 	return nil
 }
 
-// encodeOpaqueAddrs serializes the lnwire.OpaqueAddrs type to a raw set of
-// bytes that we will persist.
-func encodeOpaqueAddrs(w io.Writer, addr *lnwire.OpaqueAddrs) error {
-	// Write the type byte.
-	if _, err := w.Write([]byte{byte(opaqueAddrs)}); err != nil {
-		return err
-	}
-
-	// Write the length of the payload.
-	var l [2]byte
-	binary.BigEndian.PutUint16(l[:], uint16(len(addr.Payload)))
-	if _, err := w.Write(l[:]); err != nil {
-		return err
-	}
-
-	// Write the payload.
-	_, err := w.Write(addr.Payload)
-
-	return err
-}
-
-// DeserializeAddr reads the serialized raw representation of an address and
+// deserializeAddr reads the serialized raw representation of an address and
 // deserializes it into the actual address. This allows us to avoid address
 // resolution within the channeldb package.
-func DeserializeAddr(r io.Reader) (net.Addr, error) {
+func deserializeAddr(r io.Reader) (net.Addr, error) {
 	var addrType [1]byte
 	if _, err := r.Read(addrType[:]); err != nil {
 		return nil, err
@@ -173,7 +147,6 @@ func DeserializeAddr(r io.Reader) (net.Addr, error) {
 			IP:   net.IP(ip[:]),
 			Port: int(binary.BigEndian.Uint16(port[:])),
 		}
-
 	case tcp6Addr:
 		var ip [16]byte
 		if _, err := r.Read(ip[:]); err != nil {
@@ -189,7 +162,6 @@ func DeserializeAddr(r io.Reader) (net.Addr, error) {
 			IP:   net.IP(ip[:]),
 			Port: int(binary.BigEndian.Uint16(port[:])),
 		}
-
 	case v2OnionAddr:
 		var h [tor.V2DecodedLen]byte
 		if _, err := r.Read(h[:]); err != nil {
@@ -209,7 +181,6 @@ func DeserializeAddr(r io.Reader) (net.Addr, error) {
 			OnionService: onionService,
 			Port:         port,
 		}
-
 	case v3OnionAddr:
 		var h [tor.V3DecodedLen]byte
 		if _, err := r.Read(h[:]); err != nil {
@@ -229,24 +200,6 @@ func DeserializeAddr(r io.Reader) (net.Addr, error) {
 			OnionService: onionService,
 			Port:         port,
 		}
-
-	case opaqueAddrs:
-		// Read the length of the payload.
-		var l [2]byte
-		if _, err := r.Read(l[:]); err != nil {
-			return nil, err
-		}
-
-		// Read the payload.
-		payload := make([]byte, binary.BigEndian.Uint16(l[:]))
-		if _, err := r.Read(payload); err != nil {
-			return nil, err
-		}
-
-		address = &lnwire.OpaqueAddrs{
-			Payload: payload,
-		}
-
 	default:
 		return nil, ErrUnknownAddressType
 	}
@@ -254,16 +207,14 @@ func DeserializeAddr(r io.Reader) (net.Addr, error) {
 	return address, nil
 }
 
-// SerializeAddr serializes an address into its raw bytes representation so that
+// serializeAddr serializes an address into its raw bytes representation so that
 // it can be deserialized without requiring address resolution.
-func SerializeAddr(w io.Writer, address net.Addr) error {
+func serializeAddr(w io.Writer, address net.Addr) error {
 	switch addr := address.(type) {
 	case *net.TCPAddr:
 		return encodeTCPAddr(w, addr)
 	case *tor.OnionAddr:
 		return encodeOnionAddr(w, addr)
-	case *lnwire.OpaqueAddrs:
-		return encodeOpaqueAddrs(w, addr)
 	default:
 		return ErrUnknownAddressType
 	}

channeldb/addr_source.go

@@ -1,83 +0,0 @@
-package channeldb
-
-import (
-	"errors"
-	"net"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-)
-
-// AddrSource is an interface that allow us to get the addresses for a target
-// node. It may combine the results of multiple address sources.
-type AddrSource interface {
-	// AddrsForNode returns all known addresses for the target node public
-	// key. The returned boolean must indicate if the given node is unknown
-	// to the backing source.
-	AddrsForNode(nodePub *btcec.PublicKey) (bool, []net.Addr, error)
-}
-
-// multiAddrSource is an implementation of AddrSource which gathers all the
-// known addresses for a given node from multiple backends and de-duplicates the
-// results.
-type multiAddrSource struct {
-	sources []AddrSource
-}
-
-// NewMultiAddrSource constructs a new AddrSource which will query all the
-// provided sources for a node's addresses and will then de-duplicate the
-// results.
-func NewMultiAddrSource(sources ...AddrSource) AddrSource {
-	return &multiAddrSource{
-		sources: sources,
-	}
-}
-
-// AddrsForNode returns all known addresses for the target node public key. It
-// queries all the address sources provided and de-duplicates the results. The
-// returned boolean is false only if none of the backing sources know of the
-// node.
-//
-// NOTE: this implements the AddrSource interface.
-func (c *multiAddrSource) AddrsForNode(nodePub *btcec.PublicKey) (bool,
-	[]net.Addr, error) {
-
-	if len(c.sources) == 0 {
-		return false, nil, errors.New("no address sources")
-	}
-
-	// The multiple address sources will likely contain duplicate addresses,
-	// so we use a map here to de-dup them.
-	dedupedAddrs := make(map[string]net.Addr)
-
-	// known will be set to true if any backing source is aware of the node.
-	var known bool
-
-	// Iterate over all the address sources and query each one for the
-	// addresses it has for the node in question.
-	for _, src := range c.sources {
-		isKnown, addrs, err := src.AddrsForNode(nodePub)
-		if err != nil {
-			return false, nil, err
-		}
-
-		if isKnown {
-			known = true
-		}
-
-		for _, addr := range addrs {
-			dedupedAddrs[addr.String()] = addr
-		}
-	}
-
-	// Convert the map into a list we can return.
-	addrs := make([]net.Addr, 0, len(dedupedAddrs))
-	for _, addr := range dedupedAddrs {
-		addrs = append(addrs, addr)
-	}
-
-	return known, addrs, nil
-}
-
-// A compile-time check to ensure that multiAddrSource implements the AddrSource
-// interface.
-var _ AddrSource = (*multiAddrSource)(nil)

channeldb/addr_source_test.go

@@ -1,149 +0,0 @@
-package channeldb
-
-import (
-	"net"
-	"testing"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-)
-
-var (
-	addr1 = &net.TCPAddr{IP: (net.IP)([]byte{0x1}), Port: 1}
-	addr2 = &net.TCPAddr{IP: (net.IP)([]byte{0x2}), Port: 2}
-	addr3 = &net.TCPAddr{IP: (net.IP)([]byte{0x3}), Port: 3}
-)
-
-// TestMultiAddrSource tests that the multiAddrSource correctly merges and
-// deduplicates the results of a set of AddrSource implementations.
-func TestMultiAddrSource(t *testing.T) {
-	t.Parallel()
-
-	var pk1 = newTestPubKey(t)
-
-	t.Run("both sources have results", func(t *testing.T) {
-		t.Parallel()
-
-		var (
-			src1 = newMockAddrSource(t)
-			src2 = newMockAddrSource(t)
-		)
-		t.Cleanup(func() {
-			src1.AssertExpectations(t)
-			src2.AssertExpectations(t)
-		})
-
-		// Let source 1 know of 2 addresses (addr 1 and 2) for node 1.
-		src1.On("AddrsForNode", pk1).Return(
-			true, []net.Addr{addr1, addr2}, nil,
-		).Once()
-
-		// Let source 2 know of 2 addresses (addr 2 and 3) for node 1.
-		src2.On("AddrsForNode", pk1).Return(
-			true, []net.Addr{addr2, addr3}, nil,
-			[]net.Addr{addr2, addr3}, nil,
-		).Once()
-
-		// Create a multi-addr source that consists of both source 1
-		// and 2.
-		multiSrc := NewMultiAddrSource(src1, src2)
-
-		// Query it for the addresses known for node 1. The results
-		// should contain addr 1, 2 and 3.
-		known, addrs, err := multiSrc.AddrsForNode(pk1)
-		require.NoError(t, err)
-		require.True(t, known)
-		require.ElementsMatch(t, addrs, []net.Addr{addr1, addr2, addr3})
-	})
-
-	t.Run("only once source has results", func(t *testing.T) {
-		t.Parallel()
-
-		var (
-			src1 = newMockAddrSource(t)
-			src2 = newMockAddrSource(t)
-		)
-		t.Cleanup(func() {
-			src1.AssertExpectations(t)
-			src2.AssertExpectations(t)
-		})
-
-		// Let source 1 know of address 1 for node 1.
-		src1.On("AddrsForNode", pk1).Return(
-			true, []net.Addr{addr1}, nil,
-		).Once()
-		src2.On("AddrsForNode", pk1).Return(false, nil, nil).Once()
-
-		// Create a multi-addr source that consists of both source 1
-		// and 2.
-		multiSrc := NewMultiAddrSource(src1, src2)
-
-		// Query it for the addresses known for node 1. The results
-		// should contain addr 1.
-		known, addrs, err := multiSrc.AddrsForNode(pk1)
-		require.NoError(t, err)
-		require.True(t, known)
-		require.ElementsMatch(t, addrs, []net.Addr{addr1})
-	})
-
-	t.Run("unknown address", func(t *testing.T) {
-		t.Parallel()
-
-		var (
-			src1 = newMockAddrSource(t)
-			src2 = newMockAddrSource(t)
-		)
-		t.Cleanup(func() {
-			src1.AssertExpectations(t)
-			src2.AssertExpectations(t)
-		})
-
-		// Create a multi-addr source that consists of both source 1
-		// and 2. Neither source known of node 1.
-		multiSrc := NewMultiAddrSource(src1, src2)
-
-		src1.On("AddrsForNode", pk1).Return(false, nil, nil).Once()
-		src2.On("AddrsForNode", pk1).Return(false, nil, nil).Once()
-
-		// Query it for the addresses known for node 1. It should return
-		// false to indicate that the node is unknown to all backing
-		// sources.
-		known, addrs, err := multiSrc.AddrsForNode(pk1)
-		require.NoError(t, err)
-		require.False(t, known)
-		require.Empty(t, addrs)
-	})
-}
-
-type mockAddrSource struct {
-	t *testing.T
-	mock.Mock
-}
-
-var _ AddrSource = (*mockAddrSource)(nil)
-
-func newMockAddrSource(t *testing.T) *mockAddrSource {
-	return &mockAddrSource{t: t}
-}
-
-func (m *mockAddrSource) AddrsForNode(pub *btcec.PublicKey) (bool, []net.Addr,
-	error) {
-
-	args := m.Called(pub)
-	if args.Get(1) == nil {
-		return args.Bool(0), nil, args.Error(2)
-	}
-
-	addrs, ok := args.Get(1).([]net.Addr)
-	require.True(m.t, ok)
-
-	return args.Bool(0), addrs, args.Error(2)
-}
-
-func newTestPubKey(t *testing.T) *btcec.PublicKey {
-	priv, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-
-	return priv.PubKey()
-}

channeldb/addr_test.go

@@ -1,4 +1,4 @@
-package graphdb
+package channeldb
 
 import (
 	"bytes"
@@ -117,7 +117,7 @@ func TestAddrSerialization(t *testing.T) {
 
 	var b bytes.Buffer
 	for _, test := range addrTests {
-		err := SerializeAddr(&b, test.expAddr)
+		err := serializeAddr(&b, test.expAddr)
 		switch {
 		case err == nil && test.serErr != "":
 			t.Fatalf("expected serialization err for addr %v",
@@ -136,7 +136,7 @@ func TestAddrSerialization(t *testing.T) {
 			continue
 		}
 
-		addr, err := DeserializeAddr(&b)
+		addr, err := deserializeAddr(&b)
 		if err != nil {
 			t.Fatalf("unable to deserialize address: %v", err)
 		}

channeldb/channel.go

@@ -19,9 +19,8 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcwallet/walletdb"
-	"github.com/lightningnetwork/lnd/fn/v2"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
-	"github.com/lightningnetwork/lnd/graph/db/models"
+	"github.com/lightningnetwork/lnd/channeldb/models"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/htlcswitch/hop"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/keychain"
@@ -1331,7 +1330,7 @@ func fetchChanBucket(tx kvdb.RTx, nodeKey *btcec.PublicKey,
 	// With the bucket for the node and chain fetched, we can now go down
 	// another level, for this channel itself.
 	var chanPointBuf bytes.Buffer
-	if err := graphdb.WriteOutpoint(&chanPointBuf, outPoint); err != nil {
+	if err := writeOutpoint(&chanPointBuf, outPoint); err != nil {
 		return nil, err
 	}
 	chanBucket := chainBucket.NestedReadBucket(chanPointBuf.Bytes())
@@ -1378,7 +1377,7 @@ func fetchChanBucketRw(tx kvdb.RwTx, nodeKey *btcec.PublicKey,
 	// With the bucket for the node and chain fetched, we can now go down
 	// another level, for this channel itself.
 	var chanPointBuf bytes.Buffer
-	if err := graphdb.WriteOutpoint(&chanPointBuf, outPoint); err != nil {
+	if err := writeOutpoint(&chanPointBuf, outPoint); err != nil {
 		return nil, err
 	}
 	chanBucket := chainBucket.NestedReadWriteBucket(chanPointBuf.Bytes())
@@ -1423,8 +1422,7 @@ func (c *OpenChannel) fullSync(tx kvdb.RwTx) error {
 	}
 
 	var chanPointBuf bytes.Buffer
-	err := graphdb.WriteOutpoint(&chanPointBuf, &c.FundingOutpoint)
-	if err != nil {
+	if err := writeOutpoint(&chanPointBuf, &c.FundingOutpoint); err != nil {
 		return err
 	}
 
@@ -1691,7 +1689,7 @@ var (
 
 // DeriveMusig2Shachain derives a shachain producer for the taproot channel
 // from normal shachain revocation root.
-func DeriveMusig2Shachain(revRoot shachain.Producer) (shachain.Producer, error) { //nolint:ll
+func DeriveMusig2Shachain(revRoot shachain.Producer) (shachain.Producer, error) { //nolint:lll
 	// In order to obtain the revocation root hash to create the taproot
 	// revocation, we'll encode the producer into a buffer, then use that
 	// to derive the shachain root needed.
@@ -3146,7 +3144,7 @@ func (c *OpenChannel) RemoteCommitChainTip() (*CommitDiff, error) {
 		return nil, err
 	}
 
-	return cd, nil
+	return cd, err
 }
 
 // UnsignedAckedUpdates retrieves the persisted unsigned acked remote log
@@ -3824,7 +3822,7 @@ func (c *OpenChannel) CloseChannel(summary *ChannelCloseSummary,
 		}
 
 		var chanPointBuf bytes.Buffer
-		err := graphdb.WriteOutpoint(&chanPointBuf, &c.FundingOutpoint)
+		err := writeOutpoint(&chanPointBuf, &c.FundingOutpoint)
 		if err != nil {
 			return err
 		}
@@ -4104,34 +4102,6 @@ func (c *OpenChannel) AbsoluteThawHeight() (uint32, error) {
 	return c.ThawHeight, nil
 }
 
-// DeriveHeightHint derives the block height for the channel opening.
-func (c *OpenChannel) DeriveHeightHint() uint32 {
-	// As a height hint, we'll try to use the opening height, but if the
-	// channel isn't yet open, then we'll use the height it was broadcast
-	// at. This may be an unconfirmed zero-conf channel.
-	heightHint := c.ShortChanID().BlockHeight
-	if heightHint == 0 {
-		heightHint = c.BroadcastHeight()
-	}
-
-	// Since no zero-conf state is stored in a channel backup, the below
-	// logic will not be triggered for restored, zero-conf channels. Set
-	// the height hint for zero-conf channels.
-	if c.IsZeroConf() {
-		if c.ZeroConfConfirmed() {
-			// If the zero-conf channel is confirmed, we'll use the
-			// confirmed SCID's block height.
-			heightHint = c.ZeroConfRealScid().BlockHeight
-		} else {
-			// The zero-conf channel is unconfirmed. We'll need to
-			// use the FundingBroadcastHeight.
-			heightHint = c.BroadcastHeight()
-		}
-	}
-
-	return heightHint
-}
-
 func putChannelCloseSummary(tx kvdb.RwTx, chanID []byte,
 	summary *ChannelCloseSummary, lastChanState *OpenChannel) error {
 

channeldb/channel_cache.go

@@ -1,4 +1,4 @@
-package graphdb
+package channeldb
 
 // channelCache is an in-memory cache used to improve the performance of
 // ChanUpdatesInHorizon. It caches the chan info and edge policies for a

channeldb/channel_cache_test.go

@@ -1,10 +1,10 @@
-package graphdb
+package channeldb
 
 import (
 	"reflect"
 	"testing"
 
-	"github.com/lightningnetwork/lnd/graph/db/models"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 )
 
 // TestChannelCache checks the behavior of the channelCache with respect to

channeldb/channel_test.go

@@ -2,7 +2,6 @@ package channeldb
 
 import (
 	"bytes"
-	"encoding/hex"
 	"math/rand"
 	"net"
 	"reflect"
@@ -11,22 +10,20 @@ import (
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	_ "github.com/btcsuite/btcwallet/walletdb/bdb"
 	"github.com/davecgh/go-spew/spew"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/clock"
-	"github.com/lightningnetwork/lnd/fn/v2"
-	"github.com/lightningnetwork/lnd/graph/db/models"
+	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/lightningnetwork/lnd/lnmock"
 	"github.com/lightningnetwork/lnd/lntest/channels"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
-	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/lightningnetwork/lnd/shachain"
 	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/stretchr/testify/require"
@@ -46,20 +43,8 @@ var (
 	}
 	privKey, pubKey = btcec.PrivKeyFromBytes(key[:])
 
-	testRBytes, _ = hex.DecodeString("8ce2bc69281ce27da07e6683571319d18e" +
-		"949ddfa2965fb6caa1bf0314f882d7")
-	testSBytes, _ = hex.DecodeString("299105481d63e0f4bc2a88121167221b67" +
-		"00d72a0ead154c03be696a292d24ae")
-	testRScalar = new(btcec.ModNScalar)
-	testSScalar = new(btcec.ModNScalar)
-	_           = testRScalar.SetByteSlice(testRBytes)
-	_           = testSScalar.SetByteSlice(testSBytes)
-	testSig     = ecdsa.NewSignature(testRScalar, testSScalar)
-
 	wireSig, _ = lnwire.NewSigFromSignature(testSig)
 
-	testPub = route.Vertex{2, 202, 4}
-
 	testClock = clock.NewTestClock(testNow)
 
 	// defaultPendingHeight is the default height at which we set
@@ -107,10 +92,6 @@ type testChannelParams struct {
 	// openChannel is set to true if the channel should be fully marked as
 	// open if this is false, the channel will be left in pending state.
 	openChannel bool
-
-	// closedChannel is set to true if the channel should be marked as
-	// closed after opening it.
-	closedChannel bool
 }
 
 // testChannelOption is a functional option which can be used to alter the
@@ -133,21 +114,6 @@ func openChannelOption() testChannelOption {
 	}
 }
 
-// closedChannelOption is an option which can be used to create a test channel
-// that is closed.
-func closedChannelOption() testChannelOption {
-	return func(params *testChannelParams) {
-		params.closedChannel = true
-	}
-}
-
-// pubKeyOption is an option which can be used to set the remote's pubkey.
-func pubKeyOption(pubKey *btcec.PublicKey) testChannelOption {
-	return func(params *testChannelParams) {
-		params.channel.IdentityPub = pubKey
-	}
-}
-
 // localHtlcsOption is an option which allows setting of htlcs on the local
 // commitment.
 func localHtlcsOption(htlcs []HTLC) testChannelOption {
@@ -250,17 +216,6 @@ func createTestChannel(t *testing.T, cdb *ChannelStateDB,
 	err = params.channel.MarkAsOpen(params.channel.ShortChannelID)
 	require.NoError(t, err, "unable to mark channel open")
 
-	if params.closedChannel {
-		// Set the other public keys so that serialization doesn't
-		// panic.
-		err = params.channel.CloseChannel(&ChannelCloseSummary{
-			RemotePub:               params.channel.IdentityPub,
-			RemoteCurrentRevocation: params.channel.IdentityPub,
-			RemoteNextRevocation:    params.channel.IdentityPub,
-		})
-		require.NoError(t, err, "unable to close channel")
-	}
-
 	return params.channel
 }