Merge pull request #1673 from comit-network/bob-extensive-quote-log

feat (Bob): Log extensive information about deposit requirements

.github/workflows/build-release-binaries.yml

@@ -6,8 +6,9 @@ on:
 
 jobs:
   build_binaries:
-    name: Build swap and asb binaries
+    name: Build
     strategy:
+      fail-fast: false
       matrix:
         include:
           - bin: swap
@@ -20,6 +21,10 @@ jobs:
             archive_ext: tar
           - bin: swap
             target: x86_64-apple-darwin
+            os: macos-12
+            archive_ext: tar
+          - bin: swap
+            target: aarch64-apple-darwin
             os: macos-latest
             archive_ext: tar
           - bin: swap
@@ -36,6 +41,10 @@ jobs:
             archive_ext: tar
           - bin: asb
             target: x86_64-apple-darwin
+            os: macos-12
+            archive_ext: tar
+          - bin: asb
+            target: aarch64-apple-darwin
             os: macos-latest
             archive_ext: tar
           - bin: asb
@@ -45,32 +54,33 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout tagged commit
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v4.1.6
         with:
           ref: ${{ github.event.release.target_commitish }}
           token: ${{ secrets.BOTTY_GITHUB_TOKEN }}
 
-      - uses: Swatinem/rust-cache@v1.3.0
+      - uses: Swatinem/rust-cache@v2.7.3
 
-      - name: Install compiler for armhf arch
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "1.74"
+
+      - name: Cross Build ${{ matrix.target }} ${{ matrix.bin }} binary
         if: matrix.target == 'armv7-unknown-linux-gnueabihf'
         run: |
-          sudo apt-get update
-          sudo apt-get install gcc-arm-linux-gnueabihf
+          curl -L "https://github.com/cross-rs/cross/releases/download/v0.2.5/cross-x86_64-unknown-linux-gnu.tar.gz" | tar xzv
+          sudo mv cross /usr/bin
+          sudo mv cross-util /usr/bin
+          cross build --target=${{ matrix.target }} --release --package swap --bin ${{ matrix.bin }}
 
       - name: Build ${{ matrix.target }} ${{ matrix.bin }} release binary
-
+        if: matrix.target != 'armv7-unknown-linux-gnueabihf'
         run: cargo build --target=${{ matrix.target }} --release --package swap --bin ${{ matrix.bin }}
 
       - name: Smoke test the binary
-        if: matrix.target != 'armv7-unknown-linux-gnueabihf' # armv7-unknown-linux-gnueabihf is only cross-compiled, no smoke test
+        if: matrix.target != 'armv7-unknown-linux-gnueabihf'
         run: target/${{ matrix.target }}/release/${{ matrix.bin }} --help
 
-      # Remove once python 3 is the default
-      - uses: actions/setup-python@v2.3.1
-        with:
-          python-version: '3.x'
-
       - id: create-archive-name
         shell: python # Use python to have a prettier name for the archive on Windows.
         run: |
@@ -87,7 +97,7 @@ jobs:
           print(f'::set-output name=archive::{archive_name}')
 
       - name: Pack macos archive
-        if: matrix.os == 'macos-latest'
+        if: startsWith(matrix.os, 'macos')
         shell: bash
         run: gtar -C ./target/${{ matrix.target }}/release --create --file=${{ steps.create-archive-name.outputs.archive }} ${{ matrix.bin }}
 

.github/workflows/ci.yml

@@ -4,21 +4,26 @@ on:
   pull_request: # Need to run on pull-requests, otherwise PRs from forks don't run
   push:
     branches:
-      - 'staging' # Bors uses this branch
-      - 'trying' # Bors uses this branch
-      - 'master' # Always build head of master for the badge in the README
+      - "master" # Always build head of master for the badge in the README
 
 jobs:
   static_analysis:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v4.1.6
 
-      - uses: Swatinem/rust-cache@v1.3.0
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "1.74"
+          components: clippy,rustfmt
+
+      - uses: Swatinem/rust-cache@v2.7.3
 
       - name: Check formatting
-        uses: dprint/check@v2.0
+        uses: dprint/check@v2.2
+        with:
+          dprint-version: 0.39.1
 
       - name: Run clippy with default features
         run: cargo clippy --workspace --all-targets -- -D warnings
@@ -26,6 +31,36 @@ jobs:
       - name: Run clippy with all features enabled
         run: cargo clippy --workspace --all-targets --all-features -- -D warnings
 
+  bdk_test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4.1.6
+
+      - uses: Swatinem/rust-cache@v2.7.3
+
+      - name: Build swap
+        run: cargo build --bin swap
+
+      - name: Run BDK regression script
+        run: ./swap/tests/bdk.sh
+
+  sqlx_test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4.1.6
+
+      - uses: Swatinem/rust-cache@v2.7.3
+
+      - name: Install sqlx-cli
+        run: cargo install --locked --version 0.6.3 sqlx-cli
+
+      - name: Run sqlite_dev_setup.sh script
+        run: |
+          cd swap
+          ./sqlite_dev_setup.sh
+
   build:
     strategy:
       matrix:
@@ -35,35 +70,43 @@ jobs:
           - target: armv7-unknown-linux-gnueabihf
             os: ubuntu-latest
           - target: x86_64-apple-darwin
+            os: macos-12
+          - target: aarch64-apple-darwin
             os: macos-latest
           - target: x86_64-pc-windows-msvc
             os: windows-latest
     runs-on: ${{ matrix.os }}
     steps:
-
       - name: Checkout sources
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v4.1.6
 
-      - uses: Swatinem/rust-cache@v1.3.0
+      - uses: Swatinem/rust-cache@v2.7.3
 
-      - name: Install compiler for armhf arch
-        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
-        run: |
-          sudo apt-get update
-          sudo apt-get install gcc-arm-linux-gnueabihf
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "1.74"
+          targets: armv7-unknown-linux-gnueabihf
 
       - name: Build binary
-        run: |
-          cargo build -p swap --target ${{ matrix.target }}
+        if: matrix.target != 'armv7-unknown-linux-gnueabihf'
+        run: cargo build -p swap --target ${{ matrix.target }}
+
+      - name: Install cross (armv7)
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: cargo install cross --locked
+
+      - name: Build binary (armv7)
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: cross build -p swap --target ${{ matrix.target }}
 
       - name: Upload swap binary
-        uses: actions/upload-artifact@v2-preview
+        uses: actions/upload-artifact@v4
         with:
           name: swap-${{ matrix.target }}
           path: target/${{ matrix.target }}/debug/swap
 
       - name: Upload asb binary
-        uses: actions/upload-artifact@v2-preview
+        uses: actions/upload-artifact@v4
         with:
           name: asb-${{ matrix.target }}
           path: target/${{ matrix.target }}/debug/asb
@@ -71,13 +114,26 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [ ubuntu-latest, macos-latest ]
+        os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     steps:
+      - name: (Free disk space on Ubuntu)
+        if: matrix.os == 'ubuntu-latest'
+        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be
+        with:
+          # removing all of these takes ~10 mins, so just do as needed
+          android: true
+          dotnet: true
+          haskell: true
+          docker-images: false
+          large-packages: false
+          swap-storage: false
+          tool-cache: false
+
       - name: Checkout sources
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v4.1.6
 
-      - uses: Swatinem/rust-cache@v1.3.0
+      - uses: Swatinem/rust-cache@v2.7.3
 
       - name: Build tests
         run: cargo build --tests --workspace --all-features
@@ -92,12 +148,14 @@ jobs:
   docker_tests:
     strategy:
       matrix:
-        test_name: [
+        test_name:
+          [
             happy_path,
             happy_path_restart_bob_after_xmr_locked,
             happy_path_restart_bob_before_xmr_locked,
             happy_path_restart_alice_after_xmr_locked,
             alice_and_bob_refund_using_cancel_and_refund_command,
+            alice_and_bob_refund_using_cancel_then_refund_command,
             alice_and_bob_refund_using_cancel_and_refund_command_timelock_not_expired,
             punish,
             alice_punishes_after_restart_bob_dead,
@@ -105,15 +163,39 @@ jobs:
             alice_refunds_after_restart_bob_refunded,
             ensure_same_swap_id,
             concurrent_bobs_before_xmr_lock_proof_sent,
-            alice_manually_redeems_after_enc_sig_learned
-        ]
+            alice_manually_redeems_after_enc_sig_learned,
+            happy_path_bob_offline_while_alice_redeems_btc,
+          ]
     runs-on: ubuntu-latest
     steps:
-
       - name: Checkout sources
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v4.1.6
 
-      - uses: Swatinem/rust-cache@v1.3.0
+      - uses: Swatinem/rust-cache@v2.7.3
 
       - name: Run test ${{ matrix.test_name }}
         run: cargo test --package swap --all-features --test ${{ matrix.test_name }} -- --nocapture
+
+  rpc_tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4.1.6
+
+      - uses: Swatinem/rust-cache@v2.7.3
+
+      - name: Run RPC server tests
+        run: cargo test --package swap --all-features --test rpc -- --nocapture
+
+  check_stable:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4.1.6
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: Swatinem/rust-cache@v2.7.3
+
+      - name: Run cargo check on stable rust
+        run: cargo check --all-targets

.github/workflows/create-release.yml

@@ -11,7 +11,7 @@ jobs:
     if: github.event.pull_request.merged == true && startsWith(github.event.pull_request.head.ref, 'release/')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v4.1.6
 
       - name: Extract version from branch name
         id: extract-version

.github/workflows/draft-new-release.yml

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
     inputs:
       version:
-        description: 'The new version in X.Y.Z format.'
+        description: "The new version in X.Y.Z format."
         required: true
 
 jobs:
@@ -12,7 +12,7 @@ jobs:
     name: "Draft a new release"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v4.1.6
         with:
           token: ${{ secrets.BOTTY_GITHUB_TOKEN }}
 
@@ -20,7 +20,7 @@ jobs:
         run: git checkout -b release/${{ github.event.inputs.version }}
 
       - name: Update changelog
-        uses: thomaseizinger/keep-a-changelog-new-release@1.2.1
+        uses: thomaseizinger/keep-a-changelog-new-release@3.0.0
         with:
           version: ${{ github.event.inputs.version }}
           changelogPath: CHANGELOG.md
@@ -41,8 +41,12 @@ jobs:
 
       - name: Commit changelog and manifest files
         id: make-commit
+        env:
+          DPRINT_VERSION: "0.39.1"
+          RUST_TOOLCHAIN: "1.74"
         run: |
-          curl -fsSL https://dprint.dev/install.sh | sh
+          rustup component add rustfmt --toolchain "$RUST_TOOLCHAIN-x86_64-unknown-linux-gnu"
+          curl -fsSL https://dprint.dev/install.sh | sh -s $DPRINT_VERSION
           /home/runner/.dprint/bin/dprint fmt
 
           git add CHANGELOG.md Cargo.lock swap/Cargo.toml
@@ -54,7 +58,7 @@ jobs:
         run: git push origin release/${{ github.event.inputs.version }} --force
 
       - name: Create pull request
-        uses: thomaseizinger/create-pull-request@1.2.2
+        uses: thomaseizinger/create-pull-request@1.4.0
         with:
           GITHUB_TOKEN: ${{ secrets.BOTTY_GITHUB_TOKEN }}
           head: release/${{ github.event.inputs.version }}

.github/workflows/preview-release.yml

@@ -10,7 +10,7 @@ jobs:
     name: Create preview release
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v4.1.6
 
       - name: Delete 'preview' release
         uses: larryjoelane/delete-release-action@v1.0.24

.gitignore

@@ -157,3 +157,7 @@ flycheck_*.el
 .swap-db/
 
 # End of https://www.toptal.com/developers/gitignore/api/rust,clion+all,emacs
+
+*.log
+.vscode
+swap/tempdb

CHANGELOG.md

@@ -7,6 +7,62 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.0] - 2024-05-29
+
+- Minimum Supported Rust Version (MSRV) bumped to 1.74
+- Lowered default Bitcoin confirmation target for Bob to 1 to make sure Bitcoin transactions get confirmed in time
+- Added support for starting the CLI (using the `start-daemon` subcommand) as a Daemon that accepts JSON-RPC requests
+- Update monero-wallet-rpc version to v0.18.3.1
+
+## [0.12.3] - 2023-09-20
+
+- Swap: If no Monero daemon is manually specified, we will automatically choose one from a list of public daemons by connecting to each and checking their availability.
+
+## [0.12.2] - 2023-08-08
+
+### Changed
+
+- Minimum Supported Rust Version (MSRV) bumped to 1.67
+- ASB can now register with multiple rendezvous nodes. The `rendezvous_point` option in `config.toml` can be a string with comma separated addresses, or a toml array of address strings.
+
+## [0.12.1] - 2023-01-09
+
+### Changed
+
+- Swap: merge separate cancel/refund commands into one `cancel-and-refund` command for stuck swaps
+
+## [0.12.0] - 2022-12-31
+
+### Changed
+
+- Update `bdk` library to latest version. This introduces an incompatability with previous versions due to different formats being used to exchange Bitcoin transactions
+- Changed ASB to quote on Monero unlocked balance instead of total balance
+- Allow `asb` to set a bitcoin address that is controlled by the asb itself to redeem/punish bitcoin to
+
+### Added
+
+- Allow asb config overrides using environment variables. See [1231](https://github.com/comit-network/xmr-btc-swap/pull/1231)
+
+## [0.11.0] - 2022-08-11
+
+### Changed
+
+- Update from Monero v0.17.2.0 to Monero v0.18.0.0
+- Change Monero nodes to [Rino tool nodes](https://community.rino.io/nodes.html)
+- Always write logs as JSON to files
+- Change to UTC time for log messages, due to a bug causing no logging at all to be printed (linux/macos), and an [unsoundness issue](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/fmt/time/struct.LocalTime.html) with local time in [the time crate](https://github.com/time-rs/time/issues/293#issuecomment-748151025)
+- Fix potential integer overflow in ASB when calculating maximum Bitcoin amount for Monero balance
+- Reduce Monero locking transaction fee amount from 0.000030 to 0.000016 XMR, which is still double the current median fee as reported at [monero.how](https://www.monero.how/monero-transaction-fees)
+
+### Added
+
+- Adjust quote based on Bitcoin balance.
+  If the max_buy_btc in the ASB config is higher than the available balance to trade, it will return the max available balance discounting the Monero locking fees. In the case the balance is lower than the min_buy_btc config it will return 0 to the CLI. If the ASB returns a quote of 0 the CLI will not allow you continue with a trade.
+- Reduce required confirmations for Bitcoin transactions from 2 to 1
+- Both the ASB and CLI now support the [Identify](https://github.com/libp2p/specs/blob/master/identify/README.md) protocol. This makes its version and network (testnet/mainnet) avaliable to others
+- Display minimum BTC deposit required to cover the minimum quantity plus fee in the Swap CLI
+- Swap CLI will check its monero-wallet-rpc version and remove it if it's older than Fluorine Fermi (0.18)
+
 ## [0.10.2] - 2021-12-25
 
 ### Changed
@@ -16,7 +72,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   This is a breaking database change!
   Swaps that were saved prior to this change may fail to load if they are in state `SwapSetupCompleted` of `BtcLocked`.
   Make sure to finish your swaps before upgrading.
-- logs to use rfc3339 local time formatting.
 
 ## [0.10.1] - 2021-12-23
 
@@ -301,7 +356,13 @@ It is possible to migrate critical data from the old db to the sqlite but there
 - Fixed an issue where Alice would not verify if Bob's Bitcoin lock transaction is semantically correct, i.e. pays the agreed upon amount to an output owned by both of them.
   Fixing this required a **breaking change** on the network layer and hence old versions are not compatible with this version.
 
-[Unreleased]: https://github.com/comit-network/xmr-btc-swap/compare/0.10.2...HEAD
+[unreleased]: https://github.com/comit-network/xmr-btc-swap/compare/0.13.0...HEAD
+[0.13.0]: https://github.com/comit-network/xmr-btc-swap/compare/0.12.3...0.13.0
+[0.12.3]: https://github.com/comit-network/xmr-btc-swap/compare/0.12.2...0.12.3
+[0.12.2]: https://github.com/comit-network/xmr-btc-swap/compare/0.12.1...0.12.2
+[0.12.1]: https://github.com/comit-network/xmr-btc-swap/compare/0.12.0...0.12.1
+[0.12.0]: https://github.com/comit-network/xmr-btc-swap/compare/0.11.0...0.12.0
+[0.11.0]: https://github.com/comit-network/xmr-btc-swap/compare/0.10.2...0.11.0
 [0.10.2]: https://github.com/comit-network/xmr-btc-swap/compare/0.10.1...0.10.2
 [0.10.1]: https://github.com/comit-network/xmr-btc-swap/compare/0.10.0...0.10.1
 [0.10.0]: https://github.com/comit-network/xmr-btc-swap/compare/0.9.0...0.10.0

Cargo.toml

@@ -1,5 +1,8 @@
 [workspace]
+resolver = "2"
 members = [ "monero-harness", "monero-rpc", "swap", "monero-wallet" ]
 
 [patch.crates-io]
+# patch until new release https://github.com/thomaseizinger/rust-jsonrpc-client/pull/51
+jsonrpc_client = { git = "https://github.com/delta1/rust-jsonrpc-client.git", rev = "3b6081697cd616c952acb9c2f02d546357d35506" }
 monero = { git = "https://github.com/comit-network/monero-rs", rev = "818f38b" }

README.md

@@ -44,9 +44,14 @@ It is not recommended to bump fees when swapping because it can have unpredictab
 
 ## Contributing
 
-We are encourage community contributions whether it be a bug fix or an improvement to the documentation.
+We encourage community contributions whether it be a bug fix or an improvement to the documentation.
 Please have a look at the [contribution guidelines](./CONTRIBUTING.md).
 
+## Rust Version Support
+
+Please note that only the latest stable Rust toolchain is supported.
+All stable toolchains since 1.74 _should_ work.
+
 ## Contact
 
 Feel free to reach out to us in the [COMIT-Monero Matrix channel](https://matrix.to/#/#comit-monero:matrix.org).

bors.toml

@@ -1,22 +0,0 @@
-status = [
-    "static_analysis",
-    "build (x86_64-unknown-linux-gnu, ubuntu-latest)",
-    "build (armv7-unknown-linux-gnueabihf, ubuntu-latest)",
-    "build (x86_64-apple-darwin, macos-latest)",
-    "build (x86_64-pc-windows-msvc, windows-latest)",
-    "test (ubuntu-latest)",
-    "test (macos-latest)",
-    "docker_tests (happy_path)",
-    "docker_tests (happy_path_restart_bob_after_xmr_locked)",
-    "docker_tests (happy_path_restart_alice_after_xmr_locked)",
-    "docker_tests (happy_path_restart_bob_before_xmr_locked)",
-    "docker_tests (alice_and_bob_refund_using_cancel_and_refund_command)",
-    "docker_tests (alice_and_bob_refund_using_cancel_and_refund_command_timelock_not_expired)",
-    "docker_tests (punish)",
-    "docker_tests (alice_punishes_after_restart_bob_dead)",
-    "docker_tests (alice_manually_punishes_after_bob_dead)",
-    "docker_tests (alice_refunds_after_restart_bob_refunded)",
-    "docker_tests (ensure_same_swap_id)",
-    "docker_tests (concurrent_bobs_before_xmr_lock_proof_sent)",
-    "docker_tests (alice_manually_redeems_after_enc_sig_learned)"
-]

docs/asb/README.md

@@ -12,7 +12,7 @@ This quickstart guide assumes that you are running the software on testnet (i.e.
 3. Run the ASB in terminal: `./asb --testnet start`
 4. Follow the setup wizard in the terminal
 
-Public Monero nodes for running the Monero Wallet RPC can be found [here](https://melo.tools/nodes.html).
+Public Monero nodes for running the Monero Wallet RPC can be found [here](https://community.rino.io/nodes.html).
 
 Run `./asb --help` for more information.
 
@@ -42,13 +42,16 @@ Since the ASB is a long running task we specify the person running an ASB as ser
 The ASB daemon supports the libp2p [rendezvous-protocol](https://github.com/libp2p/specs/tree/master/rendezvous).
 Usage of the rendezvous functionality is entirely optional.
 
-You can configure a rendezvous point in the `[network]` section of your config file.
+You can configure one or more rendezvous points in the `[network]` section of your config file.
 For the registration to be successful, you also need to configure the externally reachable addresses within the `[network]` section.
 For example:
 
 ```toml
 [network]
-rendezvous_point = "/dnsaddr/rendezvous.coblox.tech/p2p/12D3KooWQUt9DkNZxEn2R5ymJzWj15MpG6mTW84kyd8vDaRZi46o"
+rendezvous_point = [
+   "/dns4/discover.unstoppableswap.net/tcp/8888/p2p/12D3KooWA6cnqJpVnreBVnoro8midDL9Lpzmg8oJPoAGi7YYaamE",
+   "/dns4/eratosthen.es/tcp/7798/p2p/12D3KooWAh7EXXa2ZyegzLGdjvj1W4G3EXrTGrf6trraoT1MEobs",
+]
 external_addresses = ["/dns4/example.com/tcp/9939"]
 ```
 
@@ -107,7 +110,7 @@ The minimum and maximum amount as well as a spread, that is added on top of the
 In order to be able to trade, the ASB must define a price to be able to agree on the amounts to be swapped with a CLI.
 The `XMR<>BTC` price is currently determined by the price from the central exchange Kraken.
 Upon startup the ASB connects to the Kraken price websocket and listens on the stream for price updates.
-You can plug in a different price ticker websocket using the the `price_ticker_ws_url` configuration option.
+You can plug in a different price ticker websocket using the `price_ticker_ws_url` configuration option.
 You will have to make sure that the format returned is the same as the format used by Kraken.
 
 Currently, we use a spot-price model, i.e. the ASB dictates the price to the CLI.
@@ -161,3 +164,38 @@ May 01 01:32:05.018  INFO Tor found. Setting up hidden service.
 May 01 01:32:07.475  INFO /onion3/z4findrdwtfbpoq64ayjtmxvr52vvxnsynerlenlfkmm52dqxsl4deyd:9939
 May 01 01:32:07.476  INFO /onion3/z4findrdwtfbpoq64ayjtmxvr52vvxnsynerlenlfkmm52dqxsl4deyd:9940
 ```
+
+### Exporting the Bitcoin wallet descriptor
+
+First use `swap` or `asb` with the `export-bitcoin-wallet` subcommand.
+
+Output example:
+
+```json
+{"descriptor":"wpkh(tprv8Zgredacted.../84'/1'/0'/0/*)","blockheight":2415616,"label":"asb-testnet"}
+```
+
+The wallet can theoretically be directly imported into
+[bdk-cli](https://bitcoindevkit.org/bdk-cli/installation/) but it is easier to
+use Sparrow Wallet.
+
+Sparrow wallet import works as follows:
+
+- File -> New wallet -> Give it a name
+- Select "New or Imported Software Wallet"
+- Click "Enter Private Key" for "Master Private Key (BIP32)"
+- Enter the `xprv...` or `tprv...` part of the descriptor (example above is `tprv8Zgredacted...`:
+
+![image](enter-master-private-key.png)
+
+- Click "Import"
+- Leave the derivation path as `m/84'/0'/0'` and click "Import Keystore" button
+- Click "Apply" and then supply password
+
+![image](import-keystore.png)
+
+- Click Transactions tab
+- ???
+- Profit!
+
+![image](transactions-tab.png)

docs/cli/README.md

@@ -100,7 +100,7 @@ OPTIONS:
         --tor-socks5-port <tor-socks5-port>         Your local Tor socks5 proxy port [default: 9050]
 ```
 
-Running `swap --testnet list-sellers --rendezvous-point /dnsaddr/rendezvous.coblox.tech/p2p/12D3KooWQUt9DkNZxEn2R5ymJzWj15MpG6mTW84kyd8vDaRZi46o` will give you something like:
+Running `swap --testnet list-sellers --rendezvous-point /dns4/discover.unstoppableswap.net/tcp/8888/p2p/12D3KooWA6cnqJpVnreBVnoro8midDL9Lpzmg8oJPoAGi7YYaamE` will give you something like:
 
 ```
 Connected to rendezvous point, discovering nodes in 'xmr-btc-swap-testnet' namespace ...

docs/cli/discover_and_take.sh

@@ -8,7 +8,7 @@
 # 4th param: Your bech32 Bitcoin testnet address that will be used for any change output (e.g. refund scenario or when swapping an amount smaller than the transferred BTC)
 #
 # Example usage:
-# discover_and_take.sh "PATH/TO/swap" "/dnsaddr/rendezvous.coblox.tech/p2p/12D3KooWQUt9DkNZxEn2R5ymJzWj15MpG6mTW84kyd8vDaRZi46o" "YOUR_XMR_STAGENET_ADDRESS" "YOUR_BECH32_BITCOIN_TESTNET_ADDRESS"
+# discover_and_take.sh "PATH/TO/swap" "/dns4/discover.unstoppableswap.net/tcp/8888/p2p/12D3KooWA6cnqJpVnreBVnoro8midDL9Lpzmg8oJPoAGi7YYaamE" "YOUR_XMR_STAGENET_ADDRESS" "YOUR_BECH32_BITCOIN_TESTNET_ADDRESS"
 
 CLI_PATH=$1
 RENDEZVOUS_POINT=$2

dprint.json

@@ -2,24 +2,17 @@
   "$schema": "https://dprint.dev/schemas/v0.json",
   "projectType": "openSource",
   "incremental": true,
-  "markdown": {
-  },
-  "rustfmt": {
-    "edition": 2018,
-    "condense_wildcard_suffixes": true,
-    "format_macro_matchers": true,
-    "imports_granularity" : "Module",
-    "use_field_init_shorthand": true,
-    "format_code_in_doc_comments": true,
-    "normalize_comments": true,
-    "wrap_comments": true,
-    "overflow_delimited_expr": true
+  "markdown": {},
+  "exec": {
+    "associations": "**/*.{rs}",
+    "rustfmt": "rustfmt --edition 2021",
+    "rustfmt.associations": "**/*.rs"
   },
   "includes": ["**/*.{md}", "**/*.{toml}", "**/*.{rs}"],
-  "excludes": [ "target/" ],
+  "excludes": ["target/"],
   "plugins": [
-    "https://plugins.dprint.dev/markdown-0.6.1.wasm",
+    "https://plugins.dprint.dev/markdown-0.13.1.wasm",
     "https://github.com/thomaseizinger/dprint-plugin-cargo-toml/releases/download/0.1.0/cargo-toml-0.1.0.wasm",
-    "https://plugins.dprint.dev/rustfmt-0.4.0.exe-plugin@c6bb223ef6e5e87580177f6461a0ab0554ac9ea6b54f78ea7ae8bf63b14f5bc2"
+    "https://plugins.dprint.dev/exec-0.3.5.json@d687dda57be0fe9a0088ccdaefa5147649ff24127d8b3ea227536c68ee7abeab"
   ]
 }

monero-harness/Cargo.toml

@@ -2,7 +2,7 @@
 name = "monero-harness"
 version = "0.1.0"
 authors = [ "CoBloX Team <team@coblox.tech>" ]
-edition = "2018"
+edition = "2021"
 publish = false
 
 [dependencies]
@@ -10,8 +10,7 @@ anyhow = "1"
 futures = "0.3"
 monero-rpc = { path = "../monero-rpc" }
 rand = "0.7"
-spectral = "0.6"
-testcontainers = "0.12"
+testcontainers = "0.15"
 tokio = { version = "1", default-features = false, features = [ "rt-multi-thread", "time", "macros" ] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = [ "fmt", "ansi", "env-filter", "tracing-log" ] }

monero-harness/src/image.rs

@@ -1,6 +1,4 @@
-use std::collections::HashMap;
-use testcontainers::core::{Container, Docker, WaitForMessage};
-use testcontainers::Image;
+use testcontainers::{core::WaitFor, Image, ImageArgs};
 
 pub const MONEROD_DAEMON_CONTAINER_NAME: &str = "monerod";
 pub const MONEROD_DEFAULT_NETWORK: &str = "monero_network";
@@ -13,43 +11,22 @@ pub const MONEROD_DEFAULT_NETWORK: &str = "monero_network";
 /// this doesn't matter.
 pub const RPC_PORT: u16 = 18081;
 
-#[derive(Debug)]
-pub struct Monerod {
-    args: MonerodArgs,
-}
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Monerod;
 
 impl Image for Monerod {
     type Args = MonerodArgs;
-    type EnvVars = HashMap<String, String>;
-    type Volumes = HashMap<String, String>;
-    type EntryPoint = str;
-
-    fn descriptor(&self) -> String {
-        "xmrto/monero:v0.17.2.0".to_owned()
-    }
-
-    fn wait_until_ready<D: Docker>(&self, container: &Container<'_, D, Self>) {
-        container
-            .logs()
-            .stdout
-            .wait_for_message("RPC server started ok")
-            .unwrap();
-    }
 
-    fn args(&self) -> <Self as Image>::Args {
-        self.args.clone()
+    fn name(&self) -> String {
+        "rinocommunity/monero".into()
     }
 
-    fn volumes(&self) -> Self::Volumes {
-        HashMap::new()
+    fn tag(&self) -> String {
+        "v0.18.1.2".into()
     }
 
-    fn env_vars(&self) -> Self::EnvVars {
-        HashMap::new()
-    }
-
-    fn with_args(self, args: <Self as Image>::Args) -> Self {
-        Self { args }
+    fn ready_conditions(&self) -> Vec<WaitFor> {
+        vec![WaitFor::message_on_stdout("RPC server started ok")]
     }
 
     fn entrypoint(&self) -> Option<String> {
@@ -58,51 +35,22 @@ impl Image for Monerod {
     }
 }
 
-impl Default for Monerod {
-    fn default() -> Self {
-        Self {
-            args: MonerodArgs::default(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MoneroWalletRpc {
-    args: MoneroWalletRpcArgs,
-}
+#[derive(Clone, Copy, Debug)]
+pub struct MoneroWalletRpc;
 
 impl Image for MoneroWalletRpc {
     type Args = MoneroWalletRpcArgs;
-    type EnvVars = HashMap<String, String>;
-    type Volumes = HashMap<String, String>;
-    type EntryPoint = str;
-
-    fn descriptor(&self) -> String {
-        "xmrto/monero:v0.17.2.0".to_owned()
-    }
-
-    fn wait_until_ready<D: Docker>(&self, container: &Container<'_, D, Self>) {
-        container
-            .logs()
-            .stdout
-            .wait_for_message("Run server thread name: RPC")
-            .unwrap();
-    }
-
-    fn args(&self) -> <Self as Image>::Args {
-        self.args.clone()
-    }
 
-    fn volumes(&self) -> Self::Volumes {
-        HashMap::new()
+    fn name(&self) -> String {
+        "rinocommunity/monero".into()
     }
 
-    fn env_vars(&self) -> Self::EnvVars {
-        HashMap::new()
+    fn tag(&self) -> String {
+        "v0.18.1.2".into()
     }
 
-    fn with_args(self, args: <Self as Image>::Args) -> Self {
-        Self { args }
+    fn ready_conditions(&self) -> Vec<WaitFor> {
+        vec![WaitFor::message_on_stdout("Run server thread name: RPC")]
     }
 
     fn entrypoint(&self) -> Option<String> {
@@ -111,19 +59,10 @@ impl Image for MoneroWalletRpc {
     }
 }
 
-impl Default for MoneroWalletRpc {
-    fn default() -> Self {
-        Self {
-            args: MoneroWalletRpcArgs::default(),
-        }
-    }
-}
-
 impl MoneroWalletRpc {
-    pub fn new(name: &str, daemon_address: String) -> Self {
-        Self {
-            args: MoneroWalletRpcArgs::new(name, daemon_address),
-        }
+    pub fn new(name: &str, daemon_address: String) -> (Self, MoneroWalletRpcArgs) {
+        let args = MoneroWalletRpcArgs::new(name, daemon_address);
+        (Self, args)
     }
 }
 
@@ -207,6 +146,12 @@ impl IntoIterator for MonerodArgs {
     }
 }
 
+impl ImageArgs for MonerodArgs {
+    fn into_iterator(self) -> Box<dyn Iterator<Item = String>> {
+        Box::new(self.into_iter())
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct MoneroWalletRpcArgs {
     pub disable_rpc_login: bool,
@@ -216,12 +161,6 @@ pub struct MoneroWalletRpcArgs {
     pub daemon_address: String,
 }
 
-impl Default for MoneroWalletRpcArgs {
-    fn default() -> Self {
-        unimplemented!("A default instance for `MoneroWalletRpc` doesn't make sense because we always need to connect to a node.")
-    }
-}
-
 impl MoneroWalletRpcArgs {
     pub fn new(wallet_name: &str, daemon_address: String) -> Self {
         Self {
@@ -245,6 +184,7 @@ impl IntoIterator for MoneroWalletRpcArgs {
             format!("--daemon-address={}", self.daemon_address),
             format!("--rpc-bind-port={}", RPC_PORT),
             "--log-level=4".to_string(),
+            "--allow-mismatched-daemon-version".to_string(), /* https://github.com/monero-project/monero/issues/8600 */
         ];
 
         if self.disable_rpc_login {
@@ -262,3 +202,9 @@ impl IntoIterator for MoneroWalletRpcArgs {
         args.into_iter()
     }
 }
+
+impl ImageArgs for MoneroWalletRpcArgs {
+    fn into_iterator(self) -> Box<dyn Iterator<Item = String>> {
+        Box::new(self.into_iter())
+    }
+}

monero-harness/src/lib.rs

@@ -20,17 +20,20 @@
 //! every BLOCK_TIME_SECS seconds.
 //!
 //! Also provides standalone JSON RPC clients for monerod and monero-wallet-rpc.
-pub mod image;
+use std::time::Duration;
 
-use crate::image::{MONEROD_DAEMON_CONTAINER_NAME, MONEROD_DEFAULT_NETWORK, RPC_PORT};
 use anyhow::{anyhow, bail, Context, Result};
+use testcontainers::clients::Cli;
+use testcontainers::{Container, RunnableImage};
+use tokio::time;
+
 use monero_rpc::monerod;
 use monero_rpc::monerod::MonerodRpc as _;
 use monero_rpc::wallet::{self, GetAddress, MoneroWalletRpc as _, Refreshed, Transfer};
-use std::time::Duration;
-use testcontainers::clients::Cli;
-use testcontainers::{Container, Docker, RunArgs};
-use tokio::time;
+
+use crate::image::{MONEROD_DAEMON_CONTAINER_NAME, MONEROD_DEFAULT_NETWORK, RPC_PORT};
+
+pub mod image;
 
 /// How often we mine a block.
 const BLOCK_TIME_SECS: u64 = 1;
@@ -56,8 +59,8 @@ impl<'c> Monero {
         additional_wallets: Vec<&'static str>,
     ) -> Result<(
         Self,
-        Container<'c, Cli, image::Monerod>,
-        Vec<Container<'c, Cli, image::MoneroWalletRpc>>,
+        Container<'c, image::Monerod>,
+        Vec<Container<'c, image::MoneroWalletRpc>>,
     )> {
         let prefix = format!("{}_", random_prefix());
         let monerod_name = format!("{}{}", prefix, MONEROD_DAEMON_CONTAINER_NAME);
@@ -71,7 +74,7 @@ impl<'c> Monero {
         let miner = "miner";
         tracing::info!("Starting miner wallet: {}", miner);
         let (miner_wallet, miner_container) =
-            MoneroWalletRpc::new(cli, &miner, &monerod, prefix.clone()).await?;
+            MoneroWalletRpc::new(cli, miner, &monerod, prefix.clone()).await?;
 
         wallets.push(miner_wallet);
         containers.push(miner_container);
@@ -83,7 +86,7 @@ impl<'c> Monero {
             // trying for 5 minutes
             let (wallet, container) = tokio::time::timeout(Duration::from_secs(300), async {
                 loop {
-                    let result = MoneroWalletRpc::new(cli, &wallet, &monerod, prefix.clone()).await;
+                    let result = MoneroWalletRpc::new(cli, wallet, &monerod, prefix.clone()).await;
 
                     match result {
                         Ok(tuple) => { return tuple; }
@@ -117,11 +120,12 @@ impl<'c> Monero {
         let miner_wallet = self.wallet("miner")?;
         let miner_address = miner_wallet.address().await?.address;
 
-        // generate the first 70 as bulk
+        // generate the first 120 as bulk
+        let amount_of_blocks = 120;
         let monerod = &self.monerod;
         let res = monerod
             .client()
-            .generateblocks(70, miner_address.clone())
+            .generateblocks(amount_of_blocks, miner_address.clone())
             .await?;
         tracing::info!("Generated {:?} blocks", res.blocks.len());
         miner_wallet.refresh().await?;
@@ -137,15 +141,30 @@ impl<'c> Monero {
         let wallet = self.wallet(name)?;
         let address = wallet.address().await?.address;
 
+        let mut expected_total = 0;
+        let mut expected_unlocked = 0;
+        let mut unlocked = 0;
         for amount in amount_in_outputs {
             if amount > 0 {
                 miner_wallet.transfer(&address, amount).await?;
+                expected_total += amount;
                 tracing::info!("Funded {} wallet with {}", wallet.name, amount);
+
+                // sanity checks for total/unlocked balance
+                let total = wallet.balance().await?;
+                assert_eq!(total, expected_total);
+                assert_eq!(unlocked, expected_unlocked);
+
                 monerod
                     .client()
                     .generateblocks(10, miner_address.clone())
                     .await?;
                 wallet.refresh().await?;
+                expected_unlocked += amount;
+
+                unlocked = wallet.unlocked_balance().await?;
+                assert_eq!(unlocked, expected_unlocked);
+                assert_eq!(total, expected_total);
             }
         }
 
@@ -188,7 +207,6 @@ fn random_prefix() -> String {
 
 #[derive(Clone, Debug)]
 pub struct Monerod {
-    rpc_port: u16,
     name: String,
     network: String,
     client: monerod::Client,
@@ -196,9 +214,7 @@ pub struct Monerod {
 
 #[derive(Clone, Debug)]
 pub struct MoneroWalletRpc {
-    rpc_port: u16,
     name: String,
-    network: String,
     client: wallet::Client,
 }
 
@@ -208,19 +224,17 @@ impl<'c> Monerod {
         cli: &'c Cli,
         name: String,
         network: String,
-    ) -> Result<(Self, Container<'c, Cli, image::Monerod>)> {
-        let image = image::Monerod::default();
-        let run_args = RunArgs::default()
-            .with_name(name.clone())
+    ) -> Result<(Self, Container<'c, image::Monerod>)> {
+        let image = image::Monerod;
+        let image: RunnableImage<image::Monerod> = RunnableImage::from(image)
+            .with_container_name(name.clone())
             .with_network(network.clone());
-        let container = cli.run_with_args(image, run_args);
-        let monerod_rpc_port = container
-            .get_host_port(RPC_PORT)
-            .context("port not exposed")?;
+
+        let container = cli.run(image);
+        let monerod_rpc_port = container.get_host_port_ipv4(RPC_PORT);
 
         Ok((
             Self {
-                rpc_port: monerod_rpc_port,
                 name,
                 network,
                 client: monerod::Client::localhost(monerod_rpc_port)?,
@@ -237,7 +251,7 @@ impl<'c> Monerod {
     /// address
     pub async fn start_miner(&self, miner_wallet_address: &str) -> Result<()> {
         let monerod = self.client().clone();
-        let _ = tokio::spawn(mine(monerod, miner_wallet_address.to_string()));
+        tokio::spawn(mine(monerod, miner_wallet_address.to_string()));
         Ok(())
     }
 }
@@ -250,19 +264,15 @@ impl<'c> MoneroWalletRpc {
         name: &str,
         monerod: &Monerod,
         prefix: String,
-    ) -> Result<(Self, Container<'c, Cli, image::MoneroWalletRpc>)> {
+    ) -> Result<(Self, Container<'c, image::MoneroWalletRpc>)> {
         let daemon_address = format!("{}:{}", monerod.name, RPC_PORT);
-        let image = image::MoneroWalletRpc::new(&name, daemon_address);
+        let (image, args) = image::MoneroWalletRpc::new(name, daemon_address);
+        let image = RunnableImage::from((image, args))
+            .with_container_name(format!("{}{}", prefix, name))
+            .with_network(monerod.network.clone());
 
-        let network = monerod.network.clone();
-        let run_args = RunArgs::default()
-            // prefix the container name so we can run multiple tests
-            .with_name(format!("{}{}", prefix, name))
-            .with_network(network.clone());
-        let container = cli.run_with_args(image, run_args);
-        let wallet_rpc_port = container
-            .get_host_port(RPC_PORT)
-            .context("port not exposed")?;
+        let container = cli.run(image);
+        let wallet_rpc_port = container.get_host_port_ipv4(RPC_PORT);
 
         let client = wallet::Client::localhost(wallet_rpc_port)?;
 
@@ -272,9 +282,7 @@ impl<'c> MoneroWalletRpc {
 
         Ok((
             Self {
-                rpc_port: wallet_rpc_port,
                 name: name.to_string(),
-                network,
                 client,
             },
             container,
@@ -301,7 +309,7 @@ impl<'c> MoneroWalletRpc {
 
     /// Sends amount to address
     pub async fn transfer(&self, address: &str, amount: u64) -> Result<Transfer> {
-        Ok(self.client().transfer_single(0, amount, address).await?)
+        self.client().transfer_single(0, amount, address).await
     }
 
     pub async fn address(&self) -> Result<GetAddress> {
@@ -315,10 +323,18 @@ impl<'c> MoneroWalletRpc {
         Ok(balance)
     }
 
+    pub async fn unlocked_balance(&self) -> Result<u64> {
+        self.client().refresh().await?;
+        let balance = self.client().get_balance(0).await?.unlocked_balance;
+
+        Ok(balance)
+    }
+
     pub async fn refresh(&self) -> Result<Refreshed> {
         Ok(self.client().refresh().await?)
     }
 }
+
 /// Mine a block ever BLOCK_TIME_SECS seconds.
 async fn mine(monerod: monerod::Client, reward_address: String) -> Result<()> {
     loop {

monero-harness/tests/monerod.rs

@@ -1,6 +1,5 @@
 use monero_harness::Monero;
 use monero_rpc::monerod::MonerodRpc as _;
-use spectral::prelude::*;
 use std::time::Duration;
 use testcontainers::clients::Cli;
 use tokio::time;
@@ -21,12 +20,12 @@ async fn init_miner_and_mine_to_miner_address() {
     let miner_wallet = monero.wallet("miner").unwrap();
 
     let got_miner_balance = miner_wallet.balance().await.unwrap();
-    assert_that!(got_miner_balance).is_greater_than(0);
+    assert!(got_miner_balance > 0);
 
     time::sleep(Duration::from_millis(1010)).await;
 
     // after a bit more than 1 sec another block should have been mined
     let block_height = monerod.client().get_block_count().await.unwrap().count;
 
-    assert_that(&block_height).is_greater_than(70);
+    assert!(block_height > 70);
 }

monero-harness/tests/wallet.rs

@@ -1,6 +1,5 @@
 use monero_harness::{Monero, MoneroWalletRpc};
 use monero_rpc::wallet::MoneroWalletRpc as _;
-use spectral::prelude::*;
 use std::time::Duration;
 use testcontainers::clients::Cli;
 use tokio::time::sleep;
@@ -29,7 +28,7 @@ async fn fund_transfer_and_check_tx_key() {
 
     // check alice balance
     let got_alice_balance = alice_wallet.balance().await.unwrap();
-    assert_that(&got_alice_balance).is_equal_to(fund_alice);
+    assert_eq!(got_alice_balance, fund_alice);
 
     // transfer from alice to bob
     let bob_address = bob_wallet.address().await.unwrap().address;
@@ -41,7 +40,7 @@ async fn fund_transfer_and_check_tx_key() {
     wait_for_wallet_to_catch_up(bob_wallet, send_to_bob).await;
 
     let got_bob_balance = bob_wallet.balance().await.unwrap();
-    assert_that(&got_bob_balance).is_equal_to(send_to_bob);
+    assert_eq!(got_bob_balance, send_to_bob);
 
     // check if tx was actually seen
     let tx_id = transfer.tx_hash;
@@ -52,7 +51,7 @@ async fn fund_transfer_and_check_tx_key() {
         .await
         .expect("failed to check tx by key");
 
-    assert_that!(res.received).is_equal_to(send_to_bob);
+    assert_eq!(res.received, send_to_bob);
 }
 
 async fn wait_for_wallet_to_catch_up(wallet: &MoneroWalletRpc, expected_balance: u64) {

monero-rpc/Cargo.toml

@@ -2,7 +2,7 @@
 name = "monero-rpc"
 version = "0.1.0"
 authors = [ "CoBloX Team <team@coblox.tech>" ]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 anyhow = "1"
@@ -12,11 +12,12 @@ jsonrpc_client = { version = "0.7", features = [ "reqwest" ] }
 monero = "0.12"
 monero-epee-bin-serde = "1"
 rand = "0.7"
-reqwest = { version = "0.11", default-features = false, features = [ "json" ] }
+reqwest = { version = "0.12", default-features = false, features = [ "json" ] }
+rust_decimal = { version = "1", features = [ "serde-float" ] }
 serde = { version = "1.0", features = [ "derive" ] }
 serde_json = "1.0"
 tracing = "0.1"
 
 [dev-dependencies]
-hex-literal = "0.3"
+hex-literal = "0.4"
 tokio = { version = "1", features = [ "full" ] }

monero-rpc/src/monerod.rs

@@ -47,9 +47,10 @@ impl Client {
     }
 
     pub async fn get_o_indexes(&self, txid: Hash) -> Result<GetOIndexesResponse> {
-        self.binary_request(self.get_o_indexes_bin_url.clone(), GetOIndexesPayload {
-            txid,
-        })
+        self.binary_request(
+            self.get_o_indexes_bin_url.clone(),
+            GetOIndexesPayload { txid },
+        )
         .await
     }
 
@@ -157,7 +158,7 @@ pub struct OutKey {
     pub unlocked: bool,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
 pub struct BaseResponse {
     pub credits: u64,
     pub status: Status,
@@ -165,7 +166,7 @@ pub struct BaseResponse {
     pub untrusted: bool,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
 pub struct GetOIndexesResponse {
     #[serde(flatten)]
     pub base: BaseResponse,
@@ -173,7 +174,7 @@ pub struct GetOIndexesResponse {
     pub o_indexes: Vec<u64>,
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
 pub enum Status {
     #[serde(rename = "OK")]
     Ok,
@@ -194,7 +195,7 @@ mod monero_serde_hex_block {
     {
         let hex = String::deserialize(deserializer)?;
 
-        let bytes = hex::decode(&hex).map_err(D::Error::custom)?;
+        let bytes = hex::decode(hex).map_err(D::Error::custom)?;
         let mut cursor = Cursor::new(bytes);
 
         let block = monero::Block::consensus_decode(&mut cursor).map_err(D::Error::custom)?;

monero-rpc/src/wallet.rs

@@ -1,4 +1,7 @@
+use std::fmt;
+
 use anyhow::{Context, Result};
+use rust_decimal::Decimal;
 use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize};
 
@@ -86,10 +89,30 @@ pub struct GetAddress {
 #[derive(Deserialize, Debug, Clone, Copy)]
 pub struct GetBalance {
     pub balance: u64,
-    pub blocks_to_unlock: u32,
+    pub unlocked_balance: u64,
     pub multisig_import_needed: bool,
+    pub blocks_to_unlock: u32,
     pub time_to_unlock: u32,
-    pub unlocked_balance: u64,
+}
+
+impl fmt::Display for GetBalance {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut total = Decimal::from(self.balance);
+        total
+            .set_scale(12)
+            .expect("12 is smaller than max precision of 28");
+
+        let mut unlocked = Decimal::from(self.unlocked_balance);
+        unlocked
+            .set_scale(12)
+            .expect("12 is smaller than max precision of 28");
+
+        write!(
+            f,
+            "total balance: {}, unlocked balance: {}",
+            total, unlocked
+        )
+    }
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -134,7 +157,7 @@ pub struct Transfer {
     pub unsigned_txset: String,
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq)]
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
 pub struct BlockHeight {
     pub height: u32,
 }
@@ -184,12 +207,7 @@ pub struct Refreshed {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct SweepAll {
-    amount_list: Vec<u64>,
-    fee_list: Vec<u64>,
-    multisig_txset: String,
     pub tx_hash_list: Vec<String>,
-    unsigned_txset: String,
-    weight_list: Vec<u32>,
 }
 
 #[derive(Debug, Copy, Clone, Deserialize)]
@@ -244,7 +262,7 @@ mod tests {
           }
         }"#;
 
-        let _: Response<SweepAll> = serde_json::from_str(&response).unwrap();
+        let _: Response<SweepAll> = serde_json::from_str(response).unwrap();
     }
 
     #[test]
@@ -256,6 +274,6 @@ mod tests {
           }
         }"#;
 
-        let _: Response<WalletCreated> = serde_json::from_str(&response).unwrap();
+        let _: Response<WalletCreated> = serde_json::from_str(response).unwrap();
     }
 }

monero-wallet/Cargo.toml

@@ -2,7 +2,7 @@
 name = "monero-wallet"
 version = "0.1.0"
 authors = [ "CoBloX Team <team@coblox.tech>" ]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 anyhow = "1"
@@ -14,6 +14,6 @@ rand = "0.7"
 curve25519-dalek = "3"
 monero-harness = { path = "../monero-harness" }
 rand = "0.7"
-testcontainers = "0.12"
+testcontainers = "0.15"
 tokio = { version = "1", features = [ "rt-multi-thread", "time", "macros", "sync", "process", "fs" ] }
 tracing-subscriber = { version = "0.2", default-features = false, features = [ "fmt", "ansi", "env-filter", "chrono", "tracing-log" ] }

monero-wallet/src/lib.rs

@@ -61,13 +61,12 @@ mod tests {
     use monero_harness::image::Monerod;
     use monero_rpc::monerod::{Client, GetOutputsOut};
     use testcontainers::clients::Cli;
-    use testcontainers::Docker;
 
     #[tokio::test]
     async fn get_outs_for_key_offsets() {
         let cli = Cli::default();
-        let container = cli.run(Monerod::default());
-        let rpc_client = Client::localhost(container.get_host_port(18081).unwrap()).unwrap();
+        let container = cli.run(Monerod);
+        let rpc_client = Client::localhost(container.get_host_port_ipv4(18081)).unwrap();
         rpc_client.generateblocks(150, "498AVruCDWgP9Az9LjMm89VWjrBrSZ2W2K3HFBiyzzrRjUJWUcCVxvY1iitfuKoek2FdX6MKGAD9Qb1G1P8QgR5jPmmt3Vj".to_owned()).await.unwrap();
         let wallet = Wallet {
             client: rpc_client.clone(),
@@ -77,8 +76,8 @@ mod tests {
         let result = rpc_client
             .get_outs(
                 key_offsets
-                    .to_vec()
-                    .into_iter()
+                    .iter()
+                    .cloned()
                     .map(|varint| GetOutputsOut {
                         amount: 0,
                         index: varint.0,

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "1.53"
+channel = "1.74" # also update this in the readme, changelog, and github actions
 components = ["clippy"]
 targets = ["armv7-unknown-linux-gnueabihf"]

swap/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "swap"
-version = "0.10.2"
+version = "0.13.0"
 authors = [ "The COMIT guys <hello@comit.network>" ]
-edition = "2018"
+edition = "2021"
 description = "XMR/BTC trustless atomic swaps."
 
 [lib]
@@ -13,58 +13,61 @@ anyhow = "1"
 async-compression = { version = "0.3", features = [ "bzip2", "tokio" ] }
 async-trait = "0.1"
 atty = "0.2"
-backoff = { version = "0.3", features = [ "tokio" ] }
-base64 = "0.13"
-bdk = "0.12"
+backoff = { version = "0.4", features = [ "tokio" ] }
+base64 = "0.22"
+bdk = "0.28"
 big-bytes = "1"
-bitcoin = { version = "0.27", features = [ "rand", "use-serde" ] }
+bitcoin = { version = "0.29", features = [ "rand", "serde" ] }
 bmrng = "0.5"
-comfy-table = "4.1.1"
-config = { version = "0.11", default-features = false, features = [ "toml" ] }
-conquer-once = "0.3"
+comfy-table = "7.1"
+config = { version = "0.14", default-features = false, features = [ "toml" ] }
+conquer-once = "0.4"
 curve25519-dalek = { package = "curve25519-dalek-ng", version = "4" }
-data-encoding = "2.3"
-dialoguer = "0.8"
+data-encoding = "2.6"
+dialoguer = "0.11"
+digest = "0.10.7"
 directories-next = "2"
-ecdsa_fun = { git = "https://github.com/LLFourn/secp256kfun", default-features = false, features = [ "libsecp_compat", "serde" ] }
+ecdsa_fun = { version = "0.10", default-features = false, features = [ "libsecp_compat", "serde", "adaptor" ] }
 ed25519-dalek = "1"
 futures = { version = "0.3", default-features = false }
 hex = "0.4"
-itertools = "0.10"
-libp2p = { git = "https://github.com/libp2p/rust-libp2p.git", default-features = false, features = [ "tcp-tokio", "yamux", "mplex", "dns-tokio", "noise", "request-response", "websocket", "ping", "rendezvous" ] }
+itertools = "0.13"
+jsonrpsee = { version = "0.16.2", features = [ "server" ] }
+jsonrpsee-core = "0.16.2"
+libp2p = { version = "0.42.2", default-features = false, features = [ "tcp-tokio", "yamux", "mplex", "dns-tokio", "noise", "request-response", "websocket", "ping", "rendezvous", "identify" ] }
 monero = { version = "0.12", features = [ "serde_support" ] }
 monero-rpc = { path = "../monero-rpc" }
-pem = "1.0"
+pem = "3.0"
 proptest = "1"
-qrcode = "0.12"
+qrcode = "0.14"
 rand = "0.8"
 rand_chacha = "0.3"
-reqwest = { version = "0.11", features = [ "rustls-tls", "stream", "socks" ], default-features = false }
+reqwest = { version = "0.12", features = [ "http2", "rustls-tls", "stream", "socks" ], default-features = false }
 rust_decimal = { version = "1", features = [ "serde-float" ] }
 rust_decimal_macros = "1"
 serde = { version = "1", features = [ "derive" ] }
 serde_cbor = "0.11"
 serde_json = "1"
 serde_with = { version = "1", features = [ "macros" ] }
-sha2 = "0.9"
-sigma_fun = { git = "https://github.com/LLFourn/secp256kfun", default-features = false, features = [ "ed25519", "serde" ] }
-sqlx = { version = "0.5", features = [ "sqlite", "runtime-tokio-rustls", "offline" ] }
+sha2 = "0.10"
+sigma_fun = { version = "0.7", default-features = false, features = [ "ed25519", "serde", "secp256k1", "alloc" ] }
+sqlx = { version = "0.6.3", features = [ "sqlite", "runtime-tokio-rustls", "offline" ] }
 structopt = "0.3"
-strum = { version = "0.23", features = [ "derive" ] }
+strum = { version = "0.26", features = [ "derive" ] }
 thiserror = "1"
 time = "0.3"
-tokio = { version = "1", features = [ "rt-multi-thread", "time", "macros", "sync", "process", "fs", "net" ] }
+tokio = { version = "1", features = [ "rt-multi-thread", "time", "macros", "sync", "process", "fs", "net", "parking_lot" ] }
 tokio-socks = "0.5"
 tokio-tungstenite = { version = "0.15", features = [ "rustls-tls" ] }
-tokio-util = { version = "0.6", features = [ "io" ] }
-toml = "0.5"
+tokio-util = { version = "0.7", features = [ "io", "codec" ] }
+toml = "0.8"
 torut = { version = "0.2", default-features = false, features = [ "v3", "control" ] }
 tracing = { version = "0.1", features = [ "attributes" ] }
 tracing-appender = "0.2"
 tracing-futures = { version = "0.2", features = [ "std-future", "futures-03" ] }
-tracing-subscriber = { version = "0.3", default-features = false, features = [ "fmt", "ansi", "env-filter", "local-time", "tracing-log", "json" ] }
+tracing-subscriber = { version = "0.3", default-features = false, features = [ "fmt", "ansi", "env-filter", "time", "tracing-log", "json" ] }
 url = { version = "2", features = [ "serde" ] }
-uuid = { version = "0.8", features = [ "serde", "v4" ] }
+uuid = { version = "1.8", features = [ "serde", "v4" ] }
 void = "1"
 
 [target.'cfg(not(windows))'.dependencies]
@@ -74,17 +77,20 @@ tokio-tar = "0.3"
 zip = "0.5"
 
 [dev-dependencies]
-bitcoin-harness = { git = "https://github.com/coblox/bitcoin-harness-rs" }
+bitcoin-harness = { git = "https://github.com/delta1/bitcoin-harness-rs.git", rev = "80cc8d05db2610d8531011be505b7bee2b5cdf9f" }
 get-port = "3"
-hyper = "0.14"
+hyper = "1.3"
+jsonrpsee = { version = "0.16.2", features = [ "ws-client" ] }
+mockito = "1.3.0"
 monero-harness = { path = "../monero-harness" }
-port_check = "0.1"
+port_check = "0.2"
 proptest = "1"
+sequential-test = "0.2.4"
 serde_cbor = "0.11"
-spectral = "0.6"
+serial_test = "3.0"
 tempfile = "3"
-testcontainers = "0.12"
+testcontainers = "0.15"
 
 [build-dependencies]
-vergen = { version = "6", default-features = false, features = [ "git", "build" ] }
 anyhow = "1"
+vergen = { version = "8.3", default-features = false, features = [ "build", "git", "git2" ] }

swap/build.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
-use vergen::{vergen, Config, SemverKind};
+use vergen::EmitBuilder;
 
 fn main() -> Result<()> {
-    let mut config = Config::default();
-    *config.git_mut().semver_kind_mut() = SemverKind::Lightweight;
-
-    vergen(config)
+    EmitBuilder::builder()
+        .git_describe(true, true, None)
+        .emit()?;
+    Ok(())
 }

swap/sqlite_dev_setup.sh

@@ -1,6 +1,15 @@
-# crated temporary DB
-# run the migration scripts to create the tables
-# prepare the sqlx-data.json rust mappings
+#!/bin/bash
+
+# run this script from the swap dir
+# make sure you have sqlx-cli installed: cargo install --version 0.6.3 sqlx-cli
+# it's advised for the sqlx-cli to be the same version as specified in cargo.toml
+
+# this script creates a temporary sqlite database
+# then runs the migration scripts to create the tables (migrations folder)
+# then it prepares the offline sqlx-data.json rust mappings
 DATABASE_URL=sqlite:tempdb cargo sqlx database create
 DATABASE_URL=sqlite:tempdb cargo sqlx migrate run
-DATABASE_URL=sqlite:./swap/tempdb cargo sqlx prepare -- --bin swap
+# needs the absolute path here
+# https://github.com/launchbadge/sqlx/issues/1399
+DB_PATH=$(readlink -f tempdb)
+DATABASE_URL="sqlite:$DB_PATH" cargo sqlx prepare -- --bin swap

swap/sqlx-data.json

@@ -1,7 +1,6 @@
 {
   "db": "SQLite",
   "081c729a0f1ad6e4ff3e13d6702c946bc4d37d50f40670b4f51d2efcce595aa6": {
-    "query": "\n        SELECT peer_id\n        FROM peers\n        WHERE swap_id = ?\n        ",
     "describe": {
       "columns": [
         {
@@ -10,26 +9,44 @@
           "type_info": "Text"
         }
       ],
-      "parameters": {
-        "Right": 1
-      },
       "nullable": [
         false
-      ]
-    }
+      ],
+      "parameters": {
+        "Right": 1
+      }
+    },
+    "query": "\n        SELECT peer_id\n        FROM peers\n        WHERE swap_id = ?\n        "
   },
   "0ab84c094964968e96a3f2bf590d9ae92227d057386921e0e57165b887de3c75": {
-    "query": "\n        insert into peer_addresses (\n            peer_id,\n            address\n            ) values (?, ?);\n        ",
     "describe": {
       "columns": [],
+      "nullable": [],
       "parameters": {
         "Right": 2
-      },
-      "nullable": []
-    }
+      }
+    },
+    "query": "\n        insert into peer_addresses (\n            peer_id,\n            address\n            ) values (?, ?);\n        "
+  },
+  "0d465a17ebbb5761421def759c73cad023c30705d5b41a1399ef79d8d2571d7c": {
+    "describe": {
+      "columns": [
+        {
+          "name": "start_date",
+          "ordinal": 0,
+          "type_info": "Text"
+        }
+      ],
+      "nullable": [
+        true
+      ],
+      "parameters": {
+        "Right": 1
+      }
+    },
+    "query": "\n                SELECT min(entered_at) as start_date\n                FROM swap_states\n                WHERE swap_id = ?\n                "
   },
   "1ec38c85e7679b2eb42b3df75d9098772ce44fdb8db3012d3c2410d828b74157": {
-    "query": "\n           SELECT swap_id, state\n           FROM (\n           SELECT max(id), swap_id, state\n           FROM swap_states\n           GROUP BY swap_id\n           )\n        ",
     "describe": {
       "columns": [
         {
@@ -43,37 +60,61 @@
           "type_info": "Text"
         }
       ],
-      "parameters": {
-        "Right": 0
-      },
       "nullable": [
         false,
         false
-      ]
-    }
+      ],
+      "parameters": {
+        "Right": 0
+      }
+    },
+    "query": "\n           SELECT swap_id, state\n           FROM (\n           SELECT max(id), swap_id, state\n           FROM swap_states\n           GROUP BY swap_id\n           )\n        "
   },
   "2a356078a41b321234adf2aa385b501749f907f7c422945a8bdda2b6274f5225": {
-    "query": "\n        insert into peers (\n            swap_id,\n            peer_id\n            ) values (?, ?);\n        ",
     "describe": {
       "columns": [],
+      "nullable": [],
       "parameters": {
         "Right": 2
-      },
-      "nullable": []
-    }
+      }
+    },
+    "query": "\n        insert into peers (\n            swap_id,\n            peer_id\n            ) values (?, ?);\n        "
+  },
+  "3f2bfdd2d134586ccad22171cd85a465800fc5c4fdaf191d206974e530240c87": {
+    "describe": {
+      "columns": [
+        {
+          "name": "swap_id",
+          "ordinal": 0,
+          "type_info": "Text"
+        },
+        {
+          "name": "state",
+          "ordinal": 1,
+          "type_info": "Text"
+        }
+      ],
+      "nullable": [
+        false,
+        false
+      ],
+      "parameters": {
+        "Right": 0
+      }
+    },
+    "query": "\n                SELECT swap_id, state\n                FROM swap_states\n                "
   },
   "50a5764546f69c118fa0b64120da50f51073d36257d49768de99ff863e3511e0": {
-    "query": "\n        insert into monero_addresses (\n            swap_id,\n            address\n            ) values (?, ?);\n        ",
     "describe": {
       "columns": [],
+      "nullable": [],
       "parameters": {
         "Right": 2
-      },
-      "nullable": []
-    }
+      }
+    },
+    "query": "\n        insert into monero_addresses (\n            swap_id,\n            address\n            ) values (?, ?);\n        "
   },
   "88f761a4f7a0429cad1df0b1bebb1c0a27b2a45656549b23076d7542cfa21ecf": {
-    "query": "\n           SELECT state\n           FROM swap_states\n           WHERE swap_id = ?\n           ORDER BY id desc\n           LIMIT 1;\n\n        ",
     "describe": {
       "columns": [
         {
@@ -82,16 +123,26 @@
           "type_info": "Text"
         }
       ],
-      "parameters": {
-        "Right": 1
-      },
       "nullable": [
         false
-      ]
-    }
+      ],
+      "parameters": {
+        "Right": 1
+      }
+    },
+    "query": "\n           SELECT state\n           FROM swap_states\n           WHERE swap_id = ?\n           ORDER BY id desc\n           LIMIT 1;\n\n        "
+  },
+  "b703032b4ddc627a1124817477e7a8e5014bdc694c36a14053ef3bb2fc0c69b0": {
+    "describe": {
+      "columns": [],
+      "nullable": [],
+      "parameters": {
+        "Right": 3
+      }
+    },
+    "query": "\n            insert into swap_states (\n                swap_id,\n                entered_at,\n                state\n                ) values (?, ?, ?);\n        "
   },
-  "a0eb85d04ee3842c52291dad4d225941d1141af735922fcbc665868997fce304": {
-    "query": "\n        SELECT address\n        FROM peer_addresses\n        WHERE peer_id = ?\n        ",
+  "ce270dd4a4b9615695a79864240c5401e2122077365e5e5a19408c068c7f9454": {
     "describe": {
       "columns": [
         {
@@ -100,26 +151,16 @@
           "type_info": "Text"
         }
       ],
-      "parameters": {
-        "Right": 1
-      },
       "nullable": [
         false
-      ]
-    }
-  },
-  "b703032b4ddc627a1124817477e7a8e5014bdc694c36a14053ef3bb2fc0c69b0": {
-    "query": "\n            insert into swap_states (\n                swap_id,\n                entered_at,\n                state\n                ) values (?, ?, ?);\n        ",
-    "describe": {
-      "columns": [],
+      ],
       "parameters": {
-        "Right": 3
-      },
-      "nullable": []
-    }
+        "Right": 1
+      }
+    },
+    "query": "\n        SELECT address\n        FROM monero_addresses\n        WHERE swap_id = ?\n        "
   },
-  "ce270dd4a4b9615695a79864240c5401e2122077365e5e5a19408c068c7f9454": {
-    "query": "\n        SELECT address\n        FROM monero_addresses\n        WHERE swap_id = ?\n        ",
+  "d78acba5eb8563826dd190e0886aa665aae3c6f1e312ee444e65df1c95afe8b2": {
     "describe": {
       "columns": [
         {
@@ -128,12 +169,31 @@
           "type_info": "Text"
         }
       ],
+      "nullable": [
+        false
+      ],
       "parameters": {
         "Right": 1
-      },
+      }
+    },
+    "query": "\n        SELECT DISTINCT address\n        FROM peer_addresses\n        WHERE peer_id = ?\n        "
+  },
+  "e05620f420f8c1022971eeb66a803323a8cf258cbebb2834e3f7cf8f812fa646": {
+    "describe": {
+      "columns": [
+        {
+          "name": "state",
+          "ordinal": 0,
+          "type_info": "Text"
+        }
+      ],
       "nullable": [
         false
-      ]
-    }
+      ],
+      "parameters": {
+        "Right": 1
+      }
+    },
+    "query": "\n           SELECT state\n           FROM swap_states\n           WHERE swap_id = ?\n        "
   }
 }

swap/src/api.rs

@@ -0,0 +1,460 @@
+pub mod request;
+use crate::cli::command::{Bitcoin, Monero, Tor};
+use crate::database::open_db;
+use crate::env::{Config as EnvConfig, GetConfig, Mainnet, Testnet};
+use crate::fs::system_data_dir;
+use crate::network::rendezvous::XmrBtcNamespace;
+use crate::protocol::Database;
+use crate::seed::Seed;
+use crate::{bitcoin, cli, monero};
+use anyhow::{bail, Context as AnyContext, Error, Result};
+use futures::future::try_join_all;
+use std::fmt;
+use std::future::Future;
+use std::net::SocketAddr;
+use std::path::PathBuf;
+use std::sync::{Arc, Once};
+use tokio::sync::{broadcast, broadcast::Sender, Mutex, RwLock};
+use tokio::task::JoinHandle;
+use url::Url;
+
+static START: Once = Once::new();
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct Config {
+    tor_socks5_port: u16,
+    namespace: XmrBtcNamespace,
+    server_address: Option<SocketAddr>,
+    pub env_config: EnvConfig,
+    seed: Option<Seed>,
+    debug: bool,
+    json: bool,
+    data_dir: PathBuf,
+    is_testnet: bool,
+}
+
+use uuid::Uuid;
+
+#[derive(Default)]
+pub struct PendingTaskList(Mutex<Vec<JoinHandle<()>>>);
+
+impl PendingTaskList {
+    pub async fn spawn<F, T>(&self, future: F)
+    where
+        F: Future<Output = T> + Send + 'static,
+        T: Send + 'static,
+    {
+        let handle = tokio::spawn(async move {
+            let _ = future.await;
+        });
+
+        self.0.lock().await.push(handle);
+    }
+
+    pub async fn wait_for_tasks(&self) -> Result<()> {
+        let tasks = {
+            // Scope for the lock, to avoid holding it for the entire duration of the async block
+            let mut guard = self.0.lock().await;
+            guard.drain(..).collect::<Vec<_>>()
+        };
+
+        try_join_all(tasks).await?;
+
+        Ok(())
+    }
+}
+
+pub struct SwapLock {
+    current_swap: RwLock<Option<Uuid>>,
+    suspension_trigger: Sender<()>,
+}
+
+impl SwapLock {
+    pub fn new() -> Self {
+        let (suspension_trigger, _) = broadcast::channel(10);
+        SwapLock {
+            current_swap: RwLock::new(None),
+            suspension_trigger,
+        }
+    }
+
+    pub async fn listen_for_swap_force_suspension(&self) -> Result<(), Error> {
+        let mut listener = self.suspension_trigger.subscribe();
+        let event = listener.recv().await;
+        match event {
+            Ok(_) => Ok(()),
+            Err(e) => {
+                tracing::error!("Error receiving swap suspension signal: {}", e);
+                bail!(e)
+            }
+        }
+    }
+
+    pub async fn acquire_swap_lock(&self, swap_id: Uuid) -> Result<(), Error> {
+        let mut current_swap = self.current_swap.write().await;
+        if current_swap.is_some() {
+            bail!("There already exists an active swap lock");
+        }
+
+        tracing::debug!(swap_id = %swap_id, "Acquiring swap lock");
+        *current_swap = Some(swap_id);
+        Ok(())
+    }
+
+    pub async fn get_current_swap_id(&self) -> Option<Uuid> {
+        *self.current_swap.read().await
+    }
+
+    /// Sends a signal to suspend all ongoing swap processes.
+    ///
+    /// This function performs the following steps:
+    /// 1. Triggers the suspension by sending a unit `()` signal to all listeners via `self.suspension_trigger`.
+    /// 2. Polls the `current_swap` state every 50 milliseconds to check if it has been set to `None`, indicating that the swap processes have been suspended and the lock released.
+    /// 3. If the lock is not released within 10 seconds, the function returns an error.
+    ///
+    /// If we send a suspend signal while no swap is in progress, the function will not fail, but will return immediately.
+    ///
+    /// # Returns
+    /// - `Ok(())` if the swap lock is successfully released.
+    /// - `Err(Error)` if the function times out waiting for the swap lock to be released.
+    ///
+    /// # Notes
+    /// The 50ms polling interval is considered negligible overhead compared to the typical time required to suspend ongoing swap processes.
+    pub async fn send_suspend_signal(&self) -> Result<(), Error> {
+        const TIMEOUT: u64 = 10_000;
+        const INTERVAL: u64 = 50;
+
+        let _ = self.suspension_trigger.send(())?;
+
+        for _ in 0..(TIMEOUT / INTERVAL) {
+            if self.get_current_swap_id().await.is_none() {
+                return Ok(());
+            }
+            tokio::time::sleep(tokio::time::Duration::from_millis(INTERVAL)).await;
+        }
+
+        bail!("Timed out waiting for swap lock to be released");
+    }
+
+    pub async fn release_swap_lock(&self) -> Result<Uuid, Error> {
+        let mut current_swap = self.current_swap.write().await;
+        if let Some(swap_id) = current_swap.as_ref() {
+            tracing::debug!(swap_id = %swap_id, "Releasing swap lock");
+
+            let prev_swap_id = *swap_id;
+            *current_swap = None;
+            drop(current_swap);
+            Ok(prev_swap_id)
+        } else {
+            bail!("There is no current swap lock to release");
+        }
+    }
+}
+
+impl Default for SwapLock {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// workaround for warning over monero_rpc_process which we must own but not read
+#[allow(dead_code)]
+pub struct Context {
+    pub db: Arc<dyn Database + Send + Sync>,
+    bitcoin_wallet: Option<Arc<bitcoin::Wallet>>,
+    monero_wallet: Option<Arc<monero::Wallet>>,
+    monero_rpc_process: Option<monero::WalletRpcProcess>,
+    pub swap_lock: Arc<SwapLock>,
+    pub config: Config,
+    pub tasks: Arc<PendingTaskList>,
+}
+
+#[allow(clippy::too_many_arguments)]
+impl Context {
+    pub async fn build(
+        bitcoin: Option<Bitcoin>,
+        monero: Option<Monero>,
+        tor: Option<Tor>,
+        data: Option<PathBuf>,
+        is_testnet: bool,
+        debug: bool,
+        json: bool,
+        server_address: Option<SocketAddr>,
+    ) -> Result<Context> {
+        let data_dir = data::data_dir_from(data, is_testnet)?;
+        let env_config = env_config_from(is_testnet);
+
+        START.call_once(|| {
+            let _ = cli::tracing::init(debug, json, data_dir.join("logs"));
+        });
+
+        let seed = Seed::from_file_or_generate(data_dir.as_path())
+            .context("Failed to read seed in file")?;
+
+        let bitcoin_wallet = {
+            if let Some(bitcoin) = bitcoin {
+                let (bitcoin_electrum_rpc_url, bitcoin_target_block) =
+                    bitcoin.apply_defaults(is_testnet)?;
+                Some(Arc::new(
+                    init_bitcoin_wallet(
+                        bitcoin_electrum_rpc_url,
+                        &seed,
+                        data_dir.clone(),
+                        env_config,
+                        bitcoin_target_block,
+                    )
+                    .await?,
+                ))
+            } else {
+                None
+            }
+        };
+
+        let (monero_wallet, monero_rpc_process) = {
+            if let Some(monero) = monero {
+                let monero_daemon_address = monero.apply_defaults(is_testnet);
+                let (wlt, prc) =
+                    init_monero_wallet(data_dir.clone(), monero_daemon_address, env_config).await?;
+                (Some(Arc::new(wlt)), Some(prc))
+            } else {
+                (None, None)
+            }
+        };
+
+        let tor_socks5_port = tor.map_or(9050, |tor| tor.tor_socks5_port);
+
+        let context = Context {
+            db: open_db(data_dir.join("sqlite")).await?,
+            bitcoin_wallet,
+            monero_wallet,
+            monero_rpc_process,
+            config: Config {
+                tor_socks5_port,
+                namespace: XmrBtcNamespace::from_is_testnet(is_testnet),
+                env_config,
+                seed: Some(seed),
+                server_address,
+                debug,
+                json,
+                is_testnet,
+                data_dir,
+            },
+            swap_lock: Arc::new(SwapLock::new()),
+            tasks: Arc::new(PendingTaskList::default()),
+        };
+
+        Ok(context)
+    }
+
+    pub async fn for_harness(
+        seed: Seed,
+        env_config: EnvConfig,
+        db_path: PathBuf,
+        bob_bitcoin_wallet: Arc<bitcoin::Wallet>,
+        bob_monero_wallet: Arc<monero::Wallet>,
+    ) -> Self {
+        let config = Config::for_harness(seed, env_config);
+
+        Self {
+            bitcoin_wallet: Some(bob_bitcoin_wallet),
+            monero_wallet: Some(bob_monero_wallet),
+            config,
+            db: open_db(db_path)
+                .await
+                .expect("Could not open sqlite database"),
+            monero_rpc_process: None,
+            swap_lock: Arc::new(SwapLock::new()),
+            tasks: Arc::new(PendingTaskList::default()),
+        }
+    }
+}
+
+impl fmt::Debug for Context {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "")
+    }
+}
+
+async fn init_bitcoin_wallet(
+    electrum_rpc_url: Url,
+    seed: &Seed,
+    data_dir: PathBuf,
+    env_config: EnvConfig,
+    bitcoin_target_block: usize,
+) -> Result<bitcoin::Wallet> {
+    let wallet_dir = data_dir.join("wallet");
+
+    let wallet = bitcoin::Wallet::new(
+        electrum_rpc_url.clone(),
+        &wallet_dir,
+        seed.derive_extended_private_key(env_config.bitcoin_network)?,
+        env_config,
+        bitcoin_target_block,
+    )
+    .await
+    .context("Failed to initialize Bitcoin wallet")?;
+
+    wallet.sync().await?;
+
+    Ok(wallet)
+}
+
+async fn init_monero_wallet(
+    data_dir: PathBuf,
+    monero_daemon_address: String,
+    env_config: EnvConfig,
+) -> Result<(monero::Wallet, monero::WalletRpcProcess)> {
+    let network = env_config.monero_network;
+
+    const MONERO_BLOCKCHAIN_MONITORING_WALLET_NAME: &str = "swap-tool-blockchain-monitoring-wallet";
+
+    let monero_wallet_rpc = monero::WalletRpc::new(data_dir.join("monero")).await?;
+
+    let monero_wallet_rpc_process = monero_wallet_rpc
+        .run(network, Some(monero_daemon_address))
+        .await?;
+
+    let monero_wallet = monero::Wallet::open_or_create(
+        monero_wallet_rpc_process.endpoint(),
+        MONERO_BLOCKCHAIN_MONITORING_WALLET_NAME.to_string(),
+        env_config,
+    )
+    .await?;
+
+    Ok((monero_wallet, monero_wallet_rpc_process))
+}
+
+mod data {
+    use super::*;
+
+    pub fn data_dir_from(arg_dir: Option<PathBuf>, testnet: bool) -> Result<PathBuf> {
+        let base_dir = match arg_dir {
+            Some(custom_base_dir) => custom_base_dir,
+            None => os_default()?,
+        };
+
+        let sub_directory = if testnet { "testnet" } else { "mainnet" };
+
+        Ok(base_dir.join(sub_directory))
+    }
+
+    fn os_default() -> Result<PathBuf> {
+        Ok(system_data_dir()?.join("cli"))
+    }
+}
+
+fn env_config_from(testnet: bool) -> EnvConfig {
+    if testnet {
+        Testnet::get_config()
+    } else {
+        Mainnet::get_config()
+    }
+}
+
+impl Config {
+    pub fn for_harness(seed: Seed, env_config: EnvConfig) -> Self {
+        let data_dir = data::data_dir_from(None, false).expect("Could not find data directory");
+
+        Self {
+            tor_socks5_port: 9050,
+            namespace: XmrBtcNamespace::from_is_testnet(false),
+            server_address: None,
+            env_config,
+            seed: Some(seed),
+            debug: false,
+            json: false,
+            is_testnet: false,
+            data_dir,
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod api_test {
+    use super::*;
+    use crate::api::request::{Method, Request};
+
+    use libp2p::Multiaddr;
+    use std::str::FromStr;
+    use uuid::Uuid;
+
+    pub const MULTI_ADDRESS: &str =
+        "/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi";
+    pub const MONERO_STAGENET_ADDRESS: &str = "53gEuGZUhP9JMEBZoGaFNzhwEgiG7hwQdMCqFxiyiTeFPmkbt1mAoNybEUvYBKHcnrSgxnVWgZsTvRBaHBNXPa8tHiCU51a";
+    pub const BITCOIN_TESTNET_ADDRESS: &str = "tb1qr3em6k3gfnyl8r7q0v7t4tlnyxzgxma3lressv";
+    pub const MONERO_MAINNET_ADDRESS: &str = "44Ato7HveWidJYUAVw5QffEcEtSH1DwzSP3FPPkHxNAS4LX9CqgucphTisH978FLHE34YNEx7FcbBfQLQUU8m3NUC4VqsRa";
+    pub const BITCOIN_MAINNET_ADDRESS: &str = "bc1qe4epnfklcaa0mun26yz5g8k24em5u9f92hy325";
+    pub const SWAP_ID: &str = "ea030832-3be9-454f-bb98-5ea9a788406b";
+
+    impl Config {
+        pub fn default(
+            is_testnet: bool,
+            data_dir: Option<PathBuf>,
+            debug: bool,
+            json: bool,
+        ) -> Self {
+            let data_dir = data::data_dir_from(data_dir, is_testnet).unwrap();
+
+            let seed = Seed::from_file_or_generate(data_dir.as_path()).unwrap();
+
+            let env_config = env_config_from(is_testnet);
+            Self {
+                tor_socks5_port: 9050,
+                namespace: XmrBtcNamespace::from_is_testnet(is_testnet),
+                server_address: None,
+                env_config,
+                seed: Some(seed),
+                debug,
+                json,
+                is_testnet,
+                data_dir,
+            }
+        }
+    }
+
+    impl Request {
+        pub fn buy_xmr(is_testnet: bool) -> Request {
+            let seller = Multiaddr::from_str(MULTI_ADDRESS).unwrap();
+            let bitcoin_change_address = {
+                if is_testnet {
+                    bitcoin::Address::from_str(BITCOIN_TESTNET_ADDRESS).unwrap()
+                } else {
+                    bitcoin::Address::from_str(BITCOIN_MAINNET_ADDRESS).unwrap()
+                }
+            };
+
+            let monero_receive_address = {
+                if is_testnet {
+                    monero::Address::from_str(MONERO_STAGENET_ADDRESS).unwrap()
+                } else {
+                    monero::Address::from_str(MONERO_MAINNET_ADDRESS).unwrap()
+                }
+            };
+
+            Request::new(Method::BuyXmr {
+                seller,
+                bitcoin_change_address,
+                monero_receive_address,
+                swap_id: Uuid::new_v4(),
+            })
+        }
+
+        pub fn resume() -> Request {
+            Request::new(Method::Resume {
+                swap_id: Uuid::from_str(SWAP_ID).unwrap(),
+            })
+        }
+
+        pub fn cancel() -> Request {
+            Request::new(Method::CancelAndRefund {
+                swap_id: Uuid::from_str(SWAP_ID).unwrap(),
+            })
+        }
+
+        pub fn refund() -> Request {
+            Request::new(Method::CancelAndRefund {
+                swap_id: Uuid::from_str(SWAP_ID).unwrap(),
+            })
+        }
+    }
+}

swap/src/api/request.rs

@@ -0,0 +1,935 @@
+use crate::api::Context;
+use crate::bitcoin::{Amount, ExpiredTimelocks, TxLock};
+use crate::cli::{list_sellers, EventLoop, SellerStatus};
+use crate::libp2p_ext::MultiAddrExt;
+use crate::network::quote::{BidQuote, ZeroQuoteReceived};
+use crate::network::swarm;
+use crate::protocol::bob::{BobState, Swap};
+use crate::protocol::{bob, State};
+use crate::{bitcoin, cli, monero, rpc};
+use anyhow::{bail, Context as AnyContext, Result};
+use libp2p::core::Multiaddr;
+use qrcode::render::unicode;
+use qrcode::QrCode;
+use serde_json::json;
+use std::cmp::min;
+use std::convert::TryInto;
+use std::future::Future;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::{debug_span, field, Instrument, Span};
+use uuid::Uuid;
+
+#[derive(PartialEq, Debug)]
+pub struct Request {
+    pub cmd: Method,
+    pub log_reference: Option<String>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Method {
+    BuyXmr {
+        seller: Multiaddr,
+        bitcoin_change_address: bitcoin::Address,
+        monero_receive_address: monero::Address,
+        swap_id: Uuid,
+    },
+    Resume {
+        swap_id: Uuid,
+    },
+    CancelAndRefund {
+        swap_id: Uuid,
+    },
+    MoneroRecovery {
+        swap_id: Uuid,
+    },
+    History,
+    Config,
+    WithdrawBtc {
+        amount: Option<Amount>,
+        address: bitcoin::Address,
+    },
+    Balance {
+        force_refresh: bool,
+    },
+    ListSellers {
+        rendezvous_point: Multiaddr,
+    },
+    ExportBitcoinWallet,
+    SuspendCurrentSwap,
+    StartDaemon {
+        server_address: Option<SocketAddr>,
+    },
+    GetCurrentSwap,
+    GetSwapInfo {
+        swap_id: Uuid,
+    },
+    GetRawStates,
+}
+
+impl Method {
+    fn get_tracing_span(&self, log_reference_id: Option<String>) -> Span {
+        let span = match self {
+            Method::Balance { .. } => {
+                debug_span!(
+                    "method",
+                    method_name = "Balance",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::BuyXmr { swap_id, .. } => {
+                debug_span!("method", method_name="BuyXmr", swap_id=%swap_id, log_reference_id=field::Empty)
+            }
+            Method::CancelAndRefund { swap_id } => {
+                debug_span!("method", method_name="CancelAndRefund", swap_id=%swap_id, log_reference_id=field::Empty)
+            }
+            Method::Resume { swap_id } => {
+                debug_span!("method", method_name="Resume", swap_id=%swap_id, log_reference_id=field::Empty)
+            }
+            Method::Config => {
+                debug_span!(
+                    "method",
+                    method_name = "Config",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::ExportBitcoinWallet => {
+                debug_span!(
+                    "method",
+                    method_name = "ExportBitcoinWallet",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::GetCurrentSwap => {
+                debug_span!(
+                    "method",
+                    method_name = "GetCurrentSwap",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::GetSwapInfo { .. } => {
+                debug_span!(
+                    "method",
+                    method_name = "GetSwapInfo",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::History => {
+                debug_span!(
+                    "method",
+                    method_name = "History",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::ListSellers { .. } => {
+                debug_span!(
+                    "method",
+                    method_name = "ListSellers",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::MoneroRecovery { .. } => {
+                debug_span!(
+                    "method",
+                    method_name = "MoneroRecovery",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::GetRawStates => debug_span!(
+                "method",
+                method_name = "RawHistory",
+                log_reference_id = field::Empty
+            ),
+            Method::StartDaemon { .. } => {
+                debug_span!(
+                    "method",
+                    method_name = "StartDaemon",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::SuspendCurrentSwap => {
+                debug_span!(
+                    "method",
+                    method_name = "SuspendCurrentSwap",
+                    log_reference_id = field::Empty
+                )
+            }
+            Method::WithdrawBtc { .. } => {
+                debug_span!(
+                    "method",
+                    method_name = "WithdrawBtc",
+                    log_reference_id = field::Empty
+                )
+            }
+        };
+        if let Some(log_reference_id) = log_reference_id {
+            span.record("log_reference_id", log_reference_id.as_str());
+        }
+        span
+    }
+}
+
+impl Request {
+    pub fn new(cmd: Method) -> Request {
+        Request {
+            cmd,
+            log_reference: None,
+        }
+    }
+
+    pub fn with_id(cmd: Method, id: Option<String>) -> Request {
+        Request {
+            cmd,
+            log_reference: id,
+        }
+    }
+
+    async fn handle_cmd(self, context: Arc<Context>) -> Result<serde_json::Value> {
+        match self.cmd {
+            Method::SuspendCurrentSwap => {
+                let swap_id = context.swap_lock.get_current_swap_id().await;
+
+                if let Some(id_value) = swap_id {
+                    context.swap_lock.send_suspend_signal().await?;
+
+                    Ok(json!({ "swapId": id_value }))
+                } else {
+                    bail!("No swap is currently running")
+                }
+            }
+            Method::GetSwapInfo { swap_id } => {
+                let bitcoin_wallet = context
+                    .bitcoin_wallet
+                    .as_ref()
+                    .context("Could not get Bitcoin wallet")?;
+
+                let state = context.db.get_state(swap_id).await?;
+                let is_completed = state.swap_finished();
+
+                let peerId = context
+                    .db
+                    .get_peer_id(swap_id)
+                    .await
+                    .with_context(|| "Could not get PeerID")?;
+
+                let addresses = context
+                    .db
+                    .get_addresses(peerId)
+                    .await
+                    .with_context(|| "Could not get addressess")?;
+
+                let start_date = context.db.get_swap_start_date(swap_id).await?;
+
+                let swap_state: BobState = state.try_into()?;
+                let state_name = format!("{}", swap_state);
+
+                let (
+                    xmr_amount,
+                    btc_amount,
+                    tx_lock_id,
+                    tx_cancel_fee,
+                    tx_refund_fee,
+                    tx_lock_fee,
+                    btc_refund_address,
+                    cancel_timelock,
+                    punish_timelock,
+                ) = context
+                    .db
+                    .get_states(swap_id)
+                    .await?
+                    .iter()
+                    .find_map(|state| {
+                        if let State::Bob(BobState::SwapSetupCompleted(state2)) = state {
+                            let xmr_amount = state2.xmr;
+                            let btc_amount = state2.tx_lock.lock_amount().to_sat();
+                            let tx_cancel_fee = state2.tx_cancel_fee.to_sat();
+                            let tx_refund_fee = state2.tx_refund_fee.to_sat();
+                            let tx_lock_id = state2.tx_lock.txid();
+                            let btc_refund_address = state2.refund_address.to_string();
+
+                            if let Ok(tx_lock_fee) = state2.tx_lock.fee() {
+                                let tx_lock_fee = tx_lock_fee.to_sat();
+
+                                Some((
+                                    xmr_amount,
+                                    btc_amount,
+                                    tx_lock_id,
+                                    tx_cancel_fee,
+                                    tx_refund_fee,
+                                    tx_lock_fee,
+                                    btc_refund_address,
+                                    state2.cancel_timelock,
+                                    state2.punish_timelock,
+                                ))
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    })
+                    .with_context(|| "Did not find SwapSetupCompleted state for swap")?;
+
+                let timelock = match swap_state {
+                    BobState::Started { .. }
+                    | BobState::SafelyAborted
+                    | BobState::SwapSetupCompleted(_) => None,
+                    BobState::BtcLocked { state3: state, .. }
+                    | BobState::XmrLockProofReceived { state, .. } => {
+                        Some(state.expired_timelock(bitcoin_wallet).await)
+                    }
+                    BobState::XmrLocked(state) | BobState::EncSigSent(state) => {
+                        Some(state.expired_timelock(bitcoin_wallet).await)
+                    }
+                    BobState::CancelTimelockExpired(state) | BobState::BtcCancelled(state) => {
+                        Some(state.expired_timelock(bitcoin_wallet).await)
+                    }
+                    BobState::BtcPunished { .. } => Some(Ok(ExpiredTimelocks::Punish)),
+                    BobState::BtcRefunded(_)
+                    | BobState::BtcRedeemed(_)
+                    | BobState::XmrRedeemed { .. } => None,
+                };
+
+                Ok(json!({
+                    "swapId": swap_id,
+                    "seller": {
+                        "peerId": peerId.to_string(),
+                        "addresses": addresses
+                    },
+                    "completed": is_completed,
+                    "startDate": start_date,
+                    "stateName": state_name,
+                    "xmrAmount": xmr_amount,
+                    "btcAmount": btc_amount,
+                    "txLockId": tx_lock_id,
+                    "txCancelFee": tx_cancel_fee,
+                    "txRefundFee": tx_refund_fee,
+                    "txLockFee": tx_lock_fee,
+                    "btcRefundAddress": btc_refund_address.to_string(),
+                    "cancelTimelock": cancel_timelock,
+                    "punishTimelock": punish_timelock,
+                    // If the timelock is None, it means that the swap is in a state where the timelock is not accessible to us.
+                    // If that is the case, we return null. Otherwise, we return the timelock.
+                    "timelock": timelock.map(|tl| tl.map(|tl| json!(tl)).unwrap_or(json!(null))).unwrap_or(json!(null)),
+                }))
+            }
+            Method::BuyXmr {
+                seller,
+                bitcoin_change_address,
+                monero_receive_address,
+                swap_id,
+            } => {
+                let bitcoin_wallet = Arc::clone(
+                    context
+                        .bitcoin_wallet
+                        .as_ref()
+                        .expect("Could not find Bitcoin wallet"),
+                );
+                let monero_wallet = Arc::clone(
+                    context
+                        .monero_wallet
+                        .as_ref()
+                        .context("Could not get Monero wallet")?,
+                );
+                let env_config = context.config.env_config;
+                let seed = context.config.seed.clone().context("Could not get seed")?;
+
+                let seller_peer_id = seller
+                    .extract_peer_id()
+                    .context("Seller address must contain peer ID")?;
+                context
+                    .db
+                    .insert_address(seller_peer_id, seller.clone())
+                    .await?;
+
+                let behaviour = cli::Behaviour::new(
+                    seller_peer_id,
+                    env_config,
+                    bitcoin_wallet.clone(),
+                    (seed.derive_libp2p_identity(), context.config.namespace),
+                );
+                let mut swarm = swarm::cli(
+                    seed.derive_libp2p_identity(),
+                    context.config.tor_socks5_port,
+                    behaviour,
+                )
+                .await?;
+
+                swarm.behaviour_mut().add_address(seller_peer_id, seller);
+
+                context
+                    .db
+                    .insert_monero_address(swap_id, monero_receive_address)
+                    .await?;
+
+                tracing::debug!(peer_id = %swarm.local_peer_id(), "Network layer initialized");
+
+                context.swap_lock.acquire_swap_lock(swap_id).await?;
+
+                let initialize_swap = tokio::select! {
+                    biased;
+                    _ = context.swap_lock.listen_for_swap_force_suspension() => {
+                        tracing::debug!("Shutdown signal received, exiting");
+                        context.swap_lock.release_swap_lock().await.expect("Shutdown signal received but failed to release swap lock. The swap process has been terminated but the swap lock is still active.");
+                        bail!("Shutdown signal received");
+                    },
+                    result = async {
+                        let (event_loop, mut event_loop_handle) =
+                            EventLoop::new(swap_id, swarm, seller_peer_id)?;
+                        let event_loop = tokio::spawn(event_loop.run().in_current_span());
+
+                        let bid_quote = event_loop_handle.request_quote().await?;
+
+                        Ok::<_, anyhow::Error>((event_loop, event_loop_handle, bid_quote))
+                    } => {
+                        result
+                    },
+                };
+
+                let (event_loop, event_loop_handle, bid_quote) = match initialize_swap {
+                    Ok(result) => result,
+                    Err(error) => {
+                        tracing::error!(%swap_id, "Swap initialization failed: {:#}", error);
+                        context
+                            .swap_lock
+                            .release_swap_lock()
+                            .await
+                            .expect("Could not release swap lock");
+                        bail!(error);
+                    }
+                };
+
+                context.tasks.clone().spawn(async move {
+                    tokio::select! {
+                        biased;
+                        _ = context.swap_lock.listen_for_swap_force_suspension() => {
+                            tracing::debug!("Shutdown signal received, exiting");
+                            context.swap_lock.release_swap_lock().await.expect("Shutdown signal received but failed to release swap lock. The swap process has been terminated but the swap lock is still active.");
+                            bail!("Shutdown signal received");
+                        },
+                        event_loop_result = event_loop => {
+                            match event_loop_result {
+                                Ok(_) => {
+                                    tracing::debug!(%swap_id, "EventLoop completed")
+                                }
+                                Err(error) => {
+                                    tracing::error!(%swap_id, "EventLoop failed: {:#}", error)
+                                }
+                            }
+                        },
+                        swap_result = async {
+                            let max_givable = || bitcoin_wallet.max_giveable(TxLock::script_size());
+                            let estimate_fee = |amount| bitcoin_wallet.estimate_fee(TxLock::weight(), amount);
+
+                            let determine_amount = determine_btc_to_swap(
+                                context.config.json,
+                                bid_quote,
+                                bitcoin_wallet.new_address(),
+                                || bitcoin_wallet.balance(),
+                                max_givable,
+                                || bitcoin_wallet.sync(),
+                                estimate_fee,
+                            );
+
+                            let (amount, fees) = match determine_amount.await {
+                                Ok(val) => val,
+                                Err(error) => match error.downcast::<ZeroQuoteReceived>() {
+                                    Ok(_) => {
+                                        bail!("Seller's XMR balance is currently too low to initiate a swap, please try again later")
+                                    }
+                                    Err(other) => bail!(other),
+                                },
+                            };
+
+                            tracing::info!(%amount, %fees,  "Determined swap amount");
+
+                            context.db.insert_peer_id(swap_id, seller_peer_id).await?;
+
+                            let swap = Swap::new(
+                                Arc::clone(&context.db),
+                                swap_id,
+                                Arc::clone(&bitcoin_wallet),
+                                monero_wallet,
+                                env_config,
+                                event_loop_handle,
+                                monero_receive_address,
+                                bitcoin_change_address,
+                                amount,
+                            );
+
+                            bob::run(swap).await
+                        } => {
+                            match swap_result {
+                                Ok(state) => {
+                                    tracing::debug!(%swap_id, state=%state, "Swap completed")
+                                }
+                                Err(error) => {
+                                    tracing::error!(%swap_id, "Failed to complete swap: {:#}", error)
+                                }
+                            }
+                        },
+                    };
+                    tracing::debug!(%swap_id, "Swap completed");
+
+                    context
+                        .swap_lock
+                        .release_swap_lock()
+                        .await
+                        .expect("Could not release swap lock");
+                    Ok::<_, anyhow::Error>(())
+                }.in_current_span()).await;
+
+                Ok(json!({
+                    "swapId": swap_id.to_string(),
+                    "quote": bid_quote,
+                }))
+            }
+            Method::Resume { swap_id } => {
+                context.swap_lock.acquire_swap_lock(swap_id).await?;
+
+                let seller_peer_id = context.db.get_peer_id(swap_id).await?;
+                let seller_addresses = context.db.get_addresses(seller_peer_id).await?;
+
+                let seed = context
+                    .config
+                    .seed
+                    .as_ref()
+                    .context("Could not get seed")?
+                    .derive_libp2p_identity();
+
+                let behaviour = cli::Behaviour::new(
+                    seller_peer_id,
+                    context.config.env_config,
+                    Arc::clone(
+                        context
+                            .bitcoin_wallet
+                            .as_ref()
+                            .context("Could not get Bitcoin wallet")?,
+                    ),
+                    (seed.clone(), context.config.namespace),
+                );
+                let mut swarm =
+                    swarm::cli(seed.clone(), context.config.tor_socks5_port, behaviour).await?;
+                let our_peer_id = swarm.local_peer_id();
+
+                tracing::debug!(peer_id = %our_peer_id, "Network layer initialized");
+
+                for seller_address in seller_addresses {
+                    swarm
+                        .behaviour_mut()
+                        .add_address(seller_peer_id, seller_address);
+                }
+
+                let (event_loop, event_loop_handle) =
+                    EventLoop::new(swap_id, swarm, seller_peer_id)?;
+                let monero_receive_address = context.db.get_monero_address(swap_id).await?;
+                let swap = Swap::from_db(
+                    Arc::clone(&context.db),
+                    swap_id,
+                    Arc::clone(
+                        context
+                            .bitcoin_wallet
+                            .as_ref()
+                            .context("Could not get Bitcoin wallet")?,
+                    ),
+                    Arc::clone(
+                        context
+                            .monero_wallet
+                            .as_ref()
+                            .context("Could not get Monero wallet")?,
+                    ),
+                    context.config.env_config,
+                    event_loop_handle,
+                    monero_receive_address,
+                )
+                .await?;
+
+                context.tasks.clone().spawn(
+                    async move {
+                        let handle = tokio::spawn(event_loop.run().in_current_span());
+                        tokio::select! {
+                            biased;
+                            _ = context.swap_lock.listen_for_swap_force_suspension() => {
+                                 tracing::debug!("Shutdown signal received, exiting");
+                                context.swap_lock.release_swap_lock().await.expect("Shutdown signal received but failed to release swap lock. The swap process has been terminated but the swap lock is still active.");
+                                bail!("Shutdown signal received");
+                            },
+
+                            event_loop_result = handle => {
+                                match event_loop_result {
+                                    Ok(_) => {
+                                        tracing::debug!(%swap_id, "EventLoop completed during swap resume")
+                                    }
+                                    Err(error) => {
+                                        tracing::error!(%swap_id, "EventLoop failed during swap resume: {:#}", error)
+                                    }
+                                }
+                            },
+                            swap_result = bob::run(swap) => {
+                                match swap_result {
+                                    Ok(state) => {
+                                        tracing::debug!(%swap_id, state=%state, "Swap completed after resuming")
+                                    }
+                                    Err(error) => {
+                                        tracing::error!(%swap_id, "Failed to resume swap: {:#}", error)
+                                    }
+                                }
+
+                            }
+                        }
+                        context
+                            .swap_lock
+                            .release_swap_lock()
+                            .await
+                            .expect("Could not release swap lock");
+                        Ok::<(), anyhow::Error>(())
+                    }
+                    .in_current_span(),
+                ).await;
+                Ok(json!({
+                    "result": "ok",
+                }))
+            }
+            Method::CancelAndRefund { swap_id } => {
+                let bitcoin_wallet = context
+                    .bitcoin_wallet
+                    .as_ref()
+                    .context("Could not get Bitcoin wallet")?;
+
+                context.swap_lock.acquire_swap_lock(swap_id).await?;
+
+                let state = cli::cancel_and_refund(
+                    swap_id,
+                    Arc::clone(bitcoin_wallet),
+                    Arc::clone(&context.db),
+                )
+                .await;
+
+                context
+                    .swap_lock
+                    .release_swap_lock()
+                    .await
+                    .expect("Could not release swap lock");
+
+                state.map(|state| {
+                    json!({
+                        "result": state,
+                    })
+                })
+            }
+            Method::History => {
+                let swaps = context.db.all().await?;
+                let mut vec: Vec<(Uuid, String)> = Vec::new();
+                for (swap_id, state) in swaps {
+                    let state: BobState = state.try_into()?;
+                    vec.push((swap_id, state.to_string()));
+                }
+
+                Ok(json!({ "swaps": vec }))
+            }
+            Method::GetRawStates => {
+                let raw_history = context.db.raw_all().await?;
+
+                Ok(json!({ "raw_states": raw_history }))
+            }
+            Method::Config => {
+                let data_dir_display = context.config.data_dir.display();
+                tracing::info!(path=%data_dir_display, "Data directory");
+                tracing::info!(path=%format!("{}/logs", data_dir_display), "Log files directory");
+                tracing::info!(path=%format!("{}/sqlite", data_dir_display), "Sqlite file location");
+                tracing::info!(path=%format!("{}/seed.pem", data_dir_display), "Seed file location");
+                tracing::info!(path=%format!("{}/monero", data_dir_display), "Monero-wallet-rpc directory");
+                tracing::info!(path=%format!("{}/wallet", data_dir_display), "Internal bitcoin wallet directory");
+
+                Ok(json!({
+                    "log_files": format!("{}/logs", data_dir_display),
+                    "sqlite": format!("{}/sqlite", data_dir_display),
+                    "seed": format!("{}/seed.pem", data_dir_display),
+                    "monero-wallet-rpc": format!("{}/monero", data_dir_display),
+                    "bitcoin_wallet": format!("{}/wallet", data_dir_display),
+                }))
+            }
+            Method::WithdrawBtc { address, amount } => {
+                let bitcoin_wallet = context
+                    .bitcoin_wallet
+                    .as_ref()
+                    .context("Could not get Bitcoin wallet")?;
+
+                let amount = match amount {
+                    Some(amount) => amount,
+                    None => {
+                        bitcoin_wallet
+                            .max_giveable(address.script_pubkey().len())
+                            .await?
+                    }
+                };
+                let psbt = bitcoin_wallet
+                    .send_to_address(address, amount, None)
+                    .await?;
+                let signed_tx = bitcoin_wallet.sign_and_finalize(psbt).await?;
+
+                bitcoin_wallet
+                    .broadcast(signed_tx.clone(), "withdraw")
+                    .await?;
+
+                Ok(json!({
+                    "signed_tx": signed_tx,
+                    "amount": amount.to_sat(),
+                    "txid": signed_tx.txid(),
+                }))
+            }
+            Method::StartDaemon { server_address } => {
+                // Default to 127.0.0.1:1234
+                let server_address = server_address.unwrap_or("127.0.0.1:1234".parse()?);
+
+                let (addr, server_handle) =
+                    rpc::run_server(server_address, Arc::clone(&context)).await?;
+
+                tracing::info!(%addr, "Started RPC server");
+
+                server_handle.stopped().await;
+
+                tracing::info!("Stopped RPC server");
+
+                Ok(json!({}))
+            }
+            Method::Balance { force_refresh } => {
+                let bitcoin_wallet = context
+                    .bitcoin_wallet
+                    .as_ref()
+                    .context("Could not get Bitcoin wallet")?;
+
+                if force_refresh {
+                    bitcoin_wallet.sync().await?;
+                }
+
+                let bitcoin_balance = bitcoin_wallet.balance().await?;
+
+                if force_refresh {
+                    tracing::info!(
+                        balance = %bitcoin_balance,
+                        "Checked Bitcoin balance",
+                    );
+                } else {
+                    tracing::debug!(
+                        balance = %bitcoin_balance,
+                        "Current Bitcoin balance as of last sync",
+                    );
+                }
+
+                Ok(json!({
+                    "balance": bitcoin_balance.to_sat()
+                }))
+            }
+            Method::ListSellers { rendezvous_point } => {
+                let rendezvous_node_peer_id = rendezvous_point
+                    .extract_peer_id()
+                    .context("Rendezvous node address must contain peer ID")?;
+
+                let identity = context
+                    .config
+                    .seed
+                    .as_ref()
+                    .context("Cannot extract seed")?
+                    .derive_libp2p_identity();
+
+                let sellers = list_sellers(
+                    rendezvous_node_peer_id,
+                    rendezvous_point,
+                    context.config.namespace,
+                    context.config.tor_socks5_port,
+                    identity,
+                )
+                .await?;
+
+                for seller in &sellers {
+                    match seller.status {
+                        SellerStatus::Online(quote) => {
+                            tracing::info!(
+                                price = %quote.price.to_string(),
+                                min_quantity = %quote.min_quantity.to_string(),
+                                max_quantity = %quote.max_quantity.to_string(),
+                                status = "Online",
+                                address = %seller.multiaddr.to_string(),
+                                "Fetched peer status"
+                            );
+                        }
+                        SellerStatus::Unreachable => {
+                            tracing::info!(
+                                status = "Unreachable",
+                                address = %seller.multiaddr.to_string(),
+                                "Fetched peer status"
+                            );
+                        }
+                    }
+                }
+
+                Ok(json!({ "sellers": sellers }))
+            }
+            Method::ExportBitcoinWallet => {
+                let bitcoin_wallet = context
+                    .bitcoin_wallet
+                    .as_ref()
+                    .context("Could not get Bitcoin wallet")?;
+
+                let wallet_export = bitcoin_wallet.wallet_export("cli").await?;
+                tracing::info!(descriptor=%wallet_export.to_string(), "Exported bitcoin wallet");
+                Ok(json!({
+                    "descriptor": wallet_export.to_string(),
+                }))
+            }
+            Method::MoneroRecovery { swap_id } => {
+                let swap_state: BobState = context.db.get_state(swap_id).await?.try_into()?;
+
+                if let BobState::BtcRedeemed(state5) = swap_state {
+                    let (spend_key, view_key) = state5.xmr_keys();
+                    let restore_height = state5.monero_wallet_restore_blockheight.height;
+
+                    let address = monero::Address::standard(
+                        context.config.env_config.monero_network,
+                        monero::PublicKey::from_private_key(&spend_key),
+                        monero::PublicKey::from(view_key.public()),
+                    );
+
+                    tracing::info!(restore_height=%restore_height, address=%address, spend_key=%spend_key, view_key=%view_key, "Monero recovery information");
+
+                    Ok(json!({
+                        "address": address,
+                        "spend_key": spend_key.to_string(),
+                        "view_key": view_key.to_string(),
+                        "restore_height": state5.monero_wallet_restore_blockheight.height,
+                    }))
+                } else {
+                    bail!(
+                        "Cannot print monero recovery information in state {}, only possible for BtcRedeemed",
+                        swap_state
+                    )
+                }
+            }
+            Method::GetCurrentSwap => Ok(json!({
+                "swap_id": context.swap_lock.get_current_swap_id().await
+            })),
+        }
+    }
+
+    pub async fn call(self, context: Arc<Context>) -> Result<serde_json::Value> {
+        let method_span = self.cmd.get_tracing_span(self.log_reference.clone());
+
+        self.handle_cmd(context)
+            .instrument(method_span.clone())
+            .await
+            .map_err(|err| {
+                method_span.in_scope(|| {
+                    tracing::debug!(err = format!("{:?}", err), "API call resulted in an error");
+                });
+                err
+            })
+    }
+}
+
+fn qr_code(value: &impl ToString) -> Result<String> {
+    let code = QrCode::new(value.to_string())?;
+    let qr_code = code
+        .render::<unicode::Dense1x2>()
+        .dark_color(unicode::Dense1x2::Light)
+        .light_color(unicode::Dense1x2::Dark)
+        .build();
+    Ok(qr_code)
+}
+
+pub async fn determine_btc_to_swap<FB, TB, FMG, TMG, FS, TS, FFE, TFE>(
+    json: bool,
+    bid_quote: BidQuote,
+    get_new_address: impl Future<Output = Result<bitcoin::Address>>,
+    balance: FB,
+    max_giveable_fn: FMG,
+    sync: FS,
+    estimate_fee: FFE,
+) -> Result<(Amount, Amount)>
+where
+    TB: Future<Output = Result<Amount>>,
+    FB: Fn() -> TB,
+    TMG: Future<Output = Result<Amount>>,
+    FMG: Fn() -> TMG,
+    TS: Future<Output = Result<()>>,
+    FS: Fn() -> TS,
+    FFE: Fn(Amount) -> TFE,
+    TFE: Future<Output = Result<Amount>>,
+{
+    if bid_quote.max_quantity == Amount::ZERO {
+        bail!(ZeroQuoteReceived)
+    }
+
+    tracing::info!(
+        price = %bid_quote.price,
+        minimum_amount = %bid_quote.min_quantity,
+        maximum_amount = %bid_quote.max_quantity,
+        "Received quote",
+    );
+
+    sync().await?;
+    let mut max_giveable = max_giveable_fn().await?;
+
+    if max_giveable == Amount::ZERO || max_giveable < bid_quote.min_quantity {
+        let deposit_address = get_new_address.await?;
+        let minimum_amount = bid_quote.min_quantity;
+        let maximum_amount = bid_quote.max_quantity;
+
+        if !json {
+            eprintln!("{}", qr_code(&deposit_address)?);
+        }
+
+        loop {
+            let min_outstanding = bid_quote.min_quantity - max_giveable;
+            let min_bitcoin_lock_tx_fee = estimate_fee(min_outstanding).await?;
+            let min_deposit_until_swap_will_start = min_outstanding + min_bitcoin_lock_tx_fee;
+            let max_deposit_until_maximum_amount_is_reached =
+                maximum_amount - max_giveable + min_bitcoin_lock_tx_fee;
+
+            tracing::info!(
+                "Deposit at least {} to cover the min quantity with fee!",
+                min_deposit_until_swap_will_start
+            );
+            tracing::info!(
+                %deposit_address,
+                %min_deposit_until_swap_will_start,
+                %max_deposit_until_maximum_amount_is_reached,
+                %max_giveable,
+                %minimum_amount,
+                %maximum_amount,
+                %min_bitcoin_lock_tx_fee,
+                price = %bid_quote.price,
+                "Waiting for Bitcoin deposit",
+            );
+
+            max_giveable = loop {
+                sync().await?;
+                let new_max_givable = max_giveable_fn().await?;
+
+                if new_max_givable > max_giveable {
+                    break new_max_givable;
+                }
+
+                tokio::time::sleep(Duration::from_secs(1)).await;
+            };
+
+            let new_balance = balance().await?;
+            tracing::info!(%new_balance, %max_giveable, "Received Bitcoin");
+
+            if max_giveable < bid_quote.min_quantity {
+                tracing::info!("Deposited amount is not enough to cover `min_quantity` when accounting for network fees");
+                continue;
+            }
+
+            break;
+        }
+    };
+
+    let balance = balance().await?;
+    let fees = balance - max_giveable;
+    let max_accepted = bid_quote.max_quantity;
+    let btc_swap_amount = min(max_giveable, max_accepted);
+
+    Ok((btc_swap_amount, fees))
+}

swap/src/asb.rs

@@ -8,6 +8,7 @@ pub mod tracing;
 
 pub use event_loop::{EventLoop, EventLoopHandle, FixedRate, KrakenRate, LatestRate};
 pub use network::behaviour::{Behaviour, OutEvent};
+pub use network::rendezvous::RendezvousNode;
 pub use network::transport;
 pub use rate::Rate;
 pub use recovery::cancel::cancel;
@@ -18,4 +19,4 @@ pub use recovery::safely_abort::safely_abort;
 pub use recovery::{cancel, refund};
 
 #[cfg(test)]
-pub use network::rendezous;
+pub use network::rendezvous;

swap/src/asb/command.rs

@@ -171,7 +171,7 @@ fn env_config(is_testnet: bool) -> env::Config {
     }
 }
 
-#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Serialize)]
+#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[error("Invalid Bitcoin address provided, expected address on network {expected:?}  but address provided is on {actual:?}")]
 pub struct BitcoinAddressNetworkMismatch {
     #[serde(with = "crate::bitcoin::network")]
@@ -180,7 +180,7 @@ pub struct BitcoinAddressNetworkMismatch {
     actual: bitcoin::Network,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct Arguments {
     pub testnet: bool,
     pub json: bool,
@@ -190,7 +190,7 @@ pub struct Arguments {
     pub cmd: Command,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Command {
     Start {
         resume_only: bool,
@@ -226,7 +226,7 @@ pub enum Command {
     name = "asb",
     about = "Automated Swap Backend for swapping XMR for BTC",
     author,
-    version = env!("VERGEN_GIT_SEMVER_LIGHTWEIGHT")
+    version = env!("VERGEN_GIT_DESCRIBE")
 )]
 pub struct RawArguments {
     #[structopt(long, help = "Swap on testnet")]
@@ -276,7 +276,7 @@ pub enum RawCommand {
     WithdrawBtc {
         #[structopt(
             long = "amount",
-            help = "Optionally specify the amount of Bitcoin to be withdrawn. If not specified the wallet will be drained."
+            help = "Optionally specify the amount of Bitcoin to be withdrawn. If not specified the wallet will be drained. Amount must be specified in quotes with denomination, e.g `--amount '0.1 BTC'`"
         )]
         amount: Option<Amount>,
         #[structopt(long = "address", help = "The address to receive the Bitcoin.")]

swap/src/asb/config.rs

@@ -84,7 +84,7 @@ const DEFAULT_MIN_BUY_AMOUNT: f64 = 0.002f64;
 const DEFAULT_MAX_BUY_AMOUNT: f64 = 0.02f64;
 const DEFAULT_SPREAD: f64 = 0.02f64;
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
 #[serde(deny_unknown_fields)]
 pub struct Config {
     pub data: Data,
@@ -102,29 +102,86 @@ impl Config {
     {
         let config_file = Path::new(&config_file);
 
-        let mut config = config::Config::new();
-        config.merge(config::File::from(config_file))?;
+        let config = config::Config::builder()
+            .add_source(config::File::from(config_file))
+            .add_source(
+                config::Environment::with_prefix("ASB")
+                    .separator("__")
+                    .list_separator(","),
+            )
+            .build()?;
+
         config.try_into()
     }
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+impl TryFrom<config::Config> for Config {
+    type Error = config::ConfigError;
+
+    fn try_from(value: config::Config) -> Result<Self, Self::Error> {
+        value.try_deserialize()
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Data {
     pub dir: PathBuf,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Network {
+    #[serde(deserialize_with = "addr_list::deserialize")]
     pub listen: Vec<Multiaddr>,
-    #[serde(default)]
-    pub rendezvous_point: Option<Multiaddr>,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "addr_list::deserialize")]
+    pub rendezvous_point: Vec<Multiaddr>,
+    #[serde(default, deserialize_with = "addr_list::deserialize")]
     pub external_addresses: Vec<Multiaddr>,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+mod addr_list {
+    use libp2p::Multiaddr;
+    use serde::de::Unexpected;
+    use serde::{de, Deserialize, Deserializer};
+    use serde_json::Value;
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Multiaddr>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = Value::deserialize(deserializer)?;
+        return match s {
+            Value::String(s) => {
+                let list: Result<Vec<_>, _> = s
+                    .split(',')
+                    .filter(|s| !s.is_empty())
+                    .map(|s| s.trim().parse().map_err(de::Error::custom))
+                    .collect();
+                Ok(list?)
+            }
+            Value::Array(a) => {
+                let list: Result<Vec<_>, _> = a
+                    .iter()
+                    .map(|v| {
+                        if let Value::String(s) = v {
+                            s.trim().parse().map_err(de::Error::custom)
+                        } else {
+                            Err(de::Error::custom("expected a string"))
+                        }
+                    })
+                    .collect();
+                Ok(list?)
+            }
+            value => Err(de::Error::invalid_type(
+                Unexpected::Other(&value.to_string()),
+                &"a string or array",
+            )),
+        };
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Bitcoin {
     pub electrum_rpc_url: Url,
@@ -134,7 +191,7 @@ pub struct Bitcoin {
     pub network: bitcoin::Network,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Monero {
     pub wallet_rpc_url: Url,
@@ -143,14 +200,14 @@ pub struct Monero {
     pub network: monero::Network,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct TorConf {
     pub control_port: u16,
     pub socks5_port: u16,
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Maker {
     #[serde(with = "::bitcoin::util::amount::serde::as_btc")]
@@ -159,6 +216,7 @@ pub struct Maker {
     pub max_buy_btc: bitcoin::Amount,
     pub ask_spread: Decimal,
     pub price_ticker_ws_url: Url,
+    pub external_bitcoin_redeem_address: Option<bitcoin::Address>,
 }
 
 impl Default for TorConf {
@@ -172,7 +230,7 @@ impl Default for TorConf {
 
 #[derive(thiserror::Error, Debug, Clone, Copy)]
 #[error("config not initialized")]
-pub struct ConfigNotInitialized {}
+pub struct ConfigNotInitialized;
 
 pub fn read_config(config_path: PathBuf) -> Result<Result<Config, ConfigNotInitialized>> {
     if config_path.exists() {
@@ -289,10 +347,27 @@ pub fn query_user_for_initial_config(testnet: bool) -> Result<Config> {
     }
     let ask_spread = Decimal::from_f64(ask_spread).context("Unable to parse spread")?;
 
-    let rendezvous_point = Input::<Multiaddr>::with_theme(&ColorfulTheme::default())
-        .with_prompt("Do you want to advertise your ASB instance with a rendezvous node? Enter an empty string if not.")
-        .allow_empty(true)
-        .interact_text()?;
+    let mut number = 1;
+    let mut done = false;
+    let mut rendezvous_points = Vec::new();
+    println!("ASB can register with multiple rendezvous nodes for discoverability. This can also be edited in the config file later.");
+    while !done {
+        let prompt = format!(
+            "Enter the address for rendezvous node ({number}). Or just hit Enter to continue."
+        );
+        let rendezvous_addr = Input::<Multiaddr>::with_theme(&ColorfulTheme::default())
+            .with_prompt(prompt)
+            .allow_empty(true)
+            .interact_text()?;
+        if rendezvous_addr.is_empty() {
+            done = true;
+        } else if rendezvous_points.contains(&rendezvous_addr) {
+            println!("That rendezvous address is already in the list.");
+        } else {
+            rendezvous_points.push(rendezvous_addr);
+            number += 1;
+        }
+    }
 
     println!();
 
@@ -300,11 +375,7 @@ pub fn query_user_for_initial_config(testnet: bool) -> Result<Config> {
         data: Data { dir: data_dir },
         network: Network {
             listen: listen_addresses,
-            rendezvous_point: if rendezvous_point.is_empty() {
-                None
-            } else {
-                Some(rendezvous_point)
-            },
+            rendezvous_point: rendezvous_points, // keeping the singular key name for backcompat
             external_addresses: vec![],
         },
         bitcoin: Bitcoin {
@@ -327,6 +398,7 @@ pub fn query_user_for_initial_config(testnet: bool) -> Result<Config> {
             max_buy_btc: max_buy,
             ask_spread,
             price_ticker_ws_url: defaults.price_ticker_ws_url,
+            external_bitcoin_redeem_address: None,
         },
     })
 }
@@ -334,9 +406,12 @@ pub fn query_user_for_initial_config(testnet: bool) -> Result<Config> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
     use tempfile::tempdir;
 
+    // these tests are run serially since env vars affect the whole process
     #[test]
+    #[serial]
     fn config_roundtrip_testnet() {
         let temp_dir = tempdir().unwrap().path().to_path_buf();
         let config_path = Path::join(&temp_dir, "config.toml");
@@ -355,10 +430,9 @@ mod tests {
             },
             network: Network {
                 listen: vec![defaults.listen_address_tcp, defaults.listen_address_ws],
-                rendezvous_point: None,
+                rendezvous_point: vec![],
                 external_addresses: vec![],
             },
-
             monero: Monero {
                 wallet_rpc_url: defaults.monero_wallet_rpc_url,
                 finality_confirmations: None,
@@ -370,6 +444,7 @@ mod tests {
                 max_buy_btc: bitcoin::Amount::from_btc(DEFAULT_MAX_BUY_AMOUNT).unwrap(),
                 ask_spread: Decimal::from_f64(DEFAULT_SPREAD).unwrap(),
                 price_ticker_ws_url: defaults.price_ticker_ws_url,
+                external_bitcoin_redeem_address: None,
             },
         };
 
@@ -380,6 +455,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn config_roundtrip_mainnet() {
         let temp_dir = tempdir().unwrap().path().to_path_buf();
         let config_path = Path::join(&temp_dir, "config.toml");
@@ -398,10 +474,63 @@ mod tests {
             },
             network: Network {
                 listen: vec![defaults.listen_address_tcp, defaults.listen_address_ws],
-                rendezvous_point: None,
+                rendezvous_point: vec![],
                 external_addresses: vec![],
             },
+            monero: Monero {
+                wallet_rpc_url: defaults.monero_wallet_rpc_url,
+                finality_confirmations: None,
+                network: monero::Network::Mainnet,
+            },
+            tor: Default::default(),
+            maker: Maker {
+                min_buy_btc: bitcoin::Amount::from_btc(DEFAULT_MIN_BUY_AMOUNT).unwrap(),
+                max_buy_btc: bitcoin::Amount::from_btc(DEFAULT_MAX_BUY_AMOUNT).unwrap(),
+                ask_spread: Decimal::from_f64(DEFAULT_SPREAD).unwrap(),
+                price_ticker_ws_url: defaults.price_ticker_ws_url,
+                external_bitcoin_redeem_address: None,
+            },
+        };
+
+        initial_setup(config_path.clone(), expected.clone()).unwrap();
+        let actual = read_config(config_path).unwrap().unwrap();
+
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    #[serial]
+    fn env_override() {
+        let temp_dir = tempfile::tempdir().unwrap().path().to_path_buf();
+        let config_path = Path::join(&temp_dir, "config.toml");
 
+        let defaults = Mainnet::getConfigFileDefaults().unwrap();
+
+        let dir = PathBuf::from("/tmp/dir");
+        std::env::set_var("ASB__DATA__DIR", dir.clone());
+        let addr1 = "/dns4/example.com/tcp/9939";
+        let addr2 = "/ip4/1.2.3.4/tcp/9940";
+        let external_addresses = vec![addr1.parse().unwrap(), addr2.parse().unwrap()];
+        let listen = external_addresses.clone();
+        std::env::set_var(
+            "ASB__NETWORK__EXTERNAL_ADDRESSES",
+            format!("{},{}", addr1, addr2),
+        );
+        std::env::set_var("ASB__NETWORK__LISTEN", format!("{},{}", addr1, addr2));
+
+        let expected = Config {
+            data: Data { dir },
+            bitcoin: Bitcoin {
+                electrum_rpc_url: defaults.electrum_rpc_url,
+                target_block: defaults.bitcoin_confirmation_target,
+                finality_confirmations: None,
+                network: bitcoin::Network::Bitcoin,
+            },
+            network: Network {
+                listen,
+                rendezvous_point: vec![],
+                external_addresses,
+            },
             monero: Monero {
                 wallet_rpc_url: defaults.monero_wallet_rpc_url,
                 finality_confirmations: None,
@@ -413,6 +542,7 @@ mod tests {
                 max_buy_btc: bitcoin::Amount::from_btc(DEFAULT_MAX_BUY_AMOUNT).unwrap(),
                 ask_spread: Decimal::from_f64(DEFAULT_SPREAD).unwrap(),
                 price_ticker_ws_url: defaults.price_ticker_ws_url,
+                external_bitcoin_redeem_address: None,
             },
         };
 
@@ -420,5 +550,8 @@ mod tests {
         let actual = read_config(config_path).unwrap().unwrap();
 
         assert_eq!(expected, actual);
+        std::env::remove_var("ASB__DATA__DIR");
+        std::env::remove_var("ASB__NETWORK__EXTERNAL_ADDRESSES");
+        std::env::remove_var("ASB__NETWORK__LISTEN");
     }
 }

swap/src/asb/event_loop.rs

@@ -1,4 +1,5 @@
 use crate::asb::{Behaviour, OutEvent, Rate};
+use crate::monero::Amount;
 use crate::network::quote::BidQuote;
 use crate::network::swap_setup::alice::WalletSnapshot;
 use crate::network::transfer_proof;
@@ -43,6 +44,7 @@ where
     latest_rate: LR,
     min_buy: bitcoin::Amount,
     max_buy: bitcoin::Amount,
+    external_redeem_address: Option<bitcoin::Address>,
 
     swap_sender: mpsc::Sender<Swap>,
 
@@ -75,6 +77,7 @@ where
         latest_rate: LR,
         min_buy: bitcoin::Amount,
         max_buy: bitcoin::Amount,
+        external_redeem_address: Option<bitcoin::Address>,
     ) -> Result<(Self, mpsc::Receiver<Swap>)> {
         let swap_channel = MpscChannels::default();
 
@@ -88,6 +91,7 @@ where
             swap_sender: swap_channel.sender,
             min_buy,
             max_buy,
+            external_redeem_address,
             recv_encrypted_signature: Default::default(),
             inflight_encrypted_signatures: Default::default(),
             send_transfer_proof: Default::default(),
@@ -164,7 +168,7 @@ where
                                 }
                             };
 
-                            let wallet_snapshot = match WalletSnapshot::capture(&self.bitcoin_wallet, &self.monero_wallet, btc).await {
+                            let wallet_snapshot = match WalletSnapshot::capture(&self.bitcoin_wallet, &self.monero_wallet, &self.external_redeem_address, btc).await {
                                 Ok(wallet_snapshot) => wallet_snapshot,
                                 Err(error) => {
                                     tracing::error!("Swap request will be ignored because we were unable to create wallet snapshot for swap: {:#}", error);
@@ -176,7 +180,7 @@ where
                             let _ = responder.respond(wallet_snapshot);
                         }
                         SwarmEvent::Behaviour(OutEvent::SwapSetupCompleted{peer_id, swap_id, state3}) => {
-                            let _ = self.handle_execution_setup_done(peer_id, swap_id, state3).await;
+                            self.handle_execution_setup_done(peer_id, swap_id, state3).await;
                         }
                         SwarmEvent::Behaviour(OutEvent::SwapDeclined { peer, error }) => {
                             tracing::warn!(%peer, "Ignoring spot price request: {}", error);
@@ -249,8 +253,8 @@ where
                                 channel
                             }.boxed());
                         }
-                        SwarmEvent::Behaviour(OutEvent::Rendezvous(libp2p::rendezvous::client::Event::Registered { .. })) => {
-                            tracing::info!("Successfully registered with rendezvous node");
+                        SwarmEvent::Behaviour(OutEvent::Rendezvous(libp2p::rendezvous::client::Event::Registered { rendezvous_node, ttl, namespace })) => {
+                            tracing::info!("Successfully registered with rendezvous node: {} with namespace: {} and TTL: {:?}", rendezvous_node, namespace, ttl);
                         }
                         SwarmEvent::Behaviour(OutEvent::Rendezvous(libp2p::rendezvous::client::Event::RegisterFailed(error))) => {
                             tracing::error!("Registration with rendezvous node failed: {:?}", error);
@@ -275,10 +279,10 @@ where
                         SwarmEvent::IncomingConnectionError { send_back_addr: address, error, .. } => {
                             tracing::warn!(%address, "Failed to set up connection with peer: {:#}", error);
                         }
-                        SwarmEvent::ConnectionClosed { peer_id: peer, num_established, endpoint, cause: Some(error) } if num_established == 0 => {
+                        SwarmEvent::ConnectionClosed { peer_id: peer, num_established: 0, endpoint, cause: Some(error) } => {
                             tracing::debug!(%peer, address = %endpoint.get_remote_address(), "Lost connection to peer: {:#}", error);
                         }
-                        SwarmEvent::ConnectionClosed { peer_id: peer, num_established, endpoint, cause: None } if num_established == 0 => {
+                        SwarmEvent::ConnectionClosed { peer_id: peer, num_established: 0, endpoint, cause: None } => {
                             tracing::info!(%peer, address = %endpoint.get_remote_address(), "Successfully closed connection");
                         }
                         SwarmEvent::NewListenAddr{address, ..} => {
@@ -292,7 +296,7 @@ where
                         Some(Ok((peer, transfer_proof, responder))) => {
                             if !self.swarm.behaviour_mut().transfer_proof.is_connected(&peer) {
                                 tracing::warn!(%peer, "No active connection to peer, buffering transfer proof");
-                                self.buffered_transfer_proofs.entry(peer).or_insert_with(Vec::new).push((transfer_proof, responder));
+                                self.buffered_transfer_proofs.entry(peer).or_default().push((transfer_proof, responder));
                                 continue;
                             }
 
@@ -319,13 +323,51 @@ where
         min_buy: bitcoin::Amount,
         max_buy: bitcoin::Amount,
     ) -> Result<BidQuote> {
-        let rate = self
+        let ask_price = self
             .latest_rate
             .latest_rate()
-            .context("Failed to get latest rate")?;
+            .context("Failed to get latest rate")?
+            .ask()
+            .context("Failed to compute asking price")?;
+
+        let balance = self.monero_wallet.get_balance().await?;
+
+        // use unlocked monero balance for quote
+        let xmr = Amount::from_piconero(balance.unlocked_balance);
+
+        let max_bitcoin_for_monero = xmr.max_bitcoin_for_price(ask_price).ok_or_else(|| {
+            anyhow::anyhow!("Bitcoin price ({}) x Monero ({}) overflow", ask_price, xmr)
+        })?;
+
+        tracing::debug!(%ask_price, %xmr, %max_bitcoin_for_monero);
+
+        if min_buy > max_bitcoin_for_monero {
+            tracing::warn!(
+                        "Your Monero balance is too low to initiate a swap, as your minimum swap amount is {}. You could at most swap {}",
+                        min_buy, max_bitcoin_for_monero
+                    );
+
+            return Ok(BidQuote {
+                price: ask_price,
+                min_quantity: bitcoin::Amount::ZERO,
+                max_quantity: bitcoin::Amount::ZERO,
+            });
+        }
+
+        if max_buy > max_bitcoin_for_monero {
+            tracing::warn!(
+                    "Your Monero balance is too low to initiate a swap with the maximum swap amount {} that you have specified in your config. You can at most swap {}",
+                    max_buy, max_bitcoin_for_monero
+                );
+            return Ok(BidQuote {
+                price: ask_price,
+                min_quantity: min_buy,
+                max_quantity: max_bitcoin_for_monero,
+            });
+        }
 
         Ok(BidQuote {
-            price: rate.ask().context("Failed to compute asking price")?,
+            price: ask_price,
             min_quantity: min_buy,
             max_quantity: max_buy,
         })

swap/src/asb/network.rs

@@ -13,11 +13,13 @@ use libp2p::core::connection::ConnectionId;
 use libp2p::core::muxing::StreamMuxerBox;
 use libp2p::core::transport::Boxed;
 use libp2p::dns::TokioDnsConfig;
+use libp2p::identify::{Identify, IdentifyConfig, IdentifyEvent};
 use libp2p::ping::{Ping, PingConfig, PingEvent};
 use libp2p::request_response::{RequestId, ResponseChannel};
+use libp2p::swarm::dial_opts::PeerCondition;
 use libp2p::swarm::{
-    DialPeerCondition, IntoProtocolsHandler, NetworkBehaviour, NetworkBehaviourAction,
-    PollParameters, ProtocolsHandler,
+    IntoProtocolsHandler, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
+    ProtocolsHandler,
 };
 use libp2p::tcp::TokioTcpConfig;
 use libp2p::websocket::WsConfig;
@@ -42,7 +44,9 @@ pub mod transport {
 }
 
 pub mod behaviour {
-    use super::*;
+    use libp2p::swarm::behaviour::toggle::Toggle;
+
+    use super::{rendezvous::RendezvousNode, *};
 
     #[allow(clippy::large_enum_variant)]
     #[derive(Debug)]
@@ -106,11 +110,12 @@ pub mod behaviour {
     where
         LR: LatestRate + Send + 'static,
     {
-        pub rendezvous: libp2p::swarm::toggle::Toggle<rendezous::Behaviour>,
+        pub rendezvous: Toggle<rendezvous::Behaviour>,
         pub quote: quote::Behaviour,
         pub swap_setup: alice::Behaviour<LR>,
         pub transfer_proof: transfer_proof::Behaviour,
         pub encrypted_signature: encrypted_signature::Behaviour,
+        pub identify: Identify,
 
         /// Ping behaviour that ensures that the underlying network connection
         /// is still alive. If the ping fails a connection close event
@@ -128,20 +133,23 @@ pub mod behaviour {
             latest_rate: LR,
             resume_only: bool,
             env_config: env::Config,
-            rendezvous_params: Option<(identity::Keypair, PeerId, Multiaddr, XmrBtcNamespace)>,
+            identify_params: (identity::Keypair, XmrBtcNamespace),
+            rendezvous_nodes: Vec<RendezvousNode>,
         ) -> Self {
+            let (identity, namespace) = identify_params;
+            let agent_version = format!("asb/{} ({})", env!("CARGO_PKG_VERSION"), namespace);
+            let protocol_version = "/comit/xmr/btc/1.0.0".to_string();
+            let identifyConfig = IdentifyConfig::new(protocol_version, identity.public())
+                .with_agent_version(agent_version);
+
+            let behaviour = if rendezvous_nodes.is_empty() {
+                None
+            } else {
+                Some(rendezvous::Behaviour::new(identity, rendezvous_nodes))
+            };
+
             Self {
-                rendezvous: libp2p::swarm::toggle::Toggle::from(rendezvous_params.map(
-                    |(identity, rendezvous_peer_id, rendezvous_address, namespace)| {
-                        rendezous::Behaviour::new(
-                            identity,
-                            rendezvous_peer_id,
-                            rendezvous_address,
-                            namespace,
-                            None, // use default ttl on rendezvous point
-                        )
-                    },
-                )),
+                rendezvous: Toggle::from(behaviour),
                 quote: quote::asb(),
                 swap_setup: alice::Behaviour::new(
                     min_buy,
@@ -153,6 +161,7 @@ pub mod behaviour {
                 transfer_proof: transfer_proof::alice(),
                 encrypted_signature: encrypted_signature::alice(),
                 ping: Ping::new(PingConfig::new().with_keep_alive(true)),
+                identify: Identify::new(identifyConfig),
             }
         }
     }
@@ -163,6 +172,12 @@ pub mod behaviour {
         }
     }
 
+    impl From<IdentifyEvent> for OutEvent {
+        fn from(_: IdentifyEvent) -> Self {
+            OutEvent::Other
+        }
+    }
+
     impl From<libp2p::rendezvous::client::Event> for OutEvent {
         fn from(event: libp2p::rendezvous::client::Event) -> Self {
             OutEvent::Rendezvous(event)
@@ -170,12 +185,14 @@ pub mod behaviour {
     }
 }
 
-pub mod rendezous {
+pub mod rendezvous {
     use super::*;
+    use libp2p::swarm::dial_opts::DialOpts;
     use libp2p::swarm::DialError;
+    use std::collections::VecDeque;
     use std::pin::Pin;
 
-    #[derive(PartialEq)]
+    #[derive(Clone, PartialEq)]
     enum ConnectionStatus {
         Disconnected,
         Dialling,
@@ -192,39 +209,59 @@ pub mod rendezous {
 
     pub struct Behaviour {
         inner: libp2p::rendezvous::client::Behaviour,
-        rendezvous_point: Multiaddr,
-        rendezvous_peer_id: PeerId,
-        namespace: XmrBtcNamespace,
-        registration_status: RegistrationStatus,
+        rendezvous_nodes: Vec<RendezvousNode>,
+        to_dial: VecDeque<PeerId>,
+    }
+
+    pub struct RendezvousNode {
+        pub address: Multiaddr,
         connection_status: ConnectionStatus,
-        registration_ttl: Option<u64>,
+        pub peer_id: PeerId,
+        registration_status: RegistrationStatus,
+        pub registration_ttl: Option<u64>,
+        pub namespace: XmrBtcNamespace,
     }
 
-    impl Behaviour {
+    impl RendezvousNode {
         pub fn new(
-            identity: identity::Keypair,
-            rendezvous_peer_id: PeerId,
-            rendezvous_address: Multiaddr,
+            address: &Multiaddr,
+            peer_id: PeerId,
             namespace: XmrBtcNamespace,
             registration_ttl: Option<u64>,
         ) -> Self {
             Self {
-                inner: libp2p::rendezvous::client::Behaviour::new(identity),
-                rendezvous_point: rendezvous_address,
-                rendezvous_peer_id,
+                address: address.to_owned(),
+                connection_status: ConnectionStatus::Disconnected,
                 namespace,
+                peer_id,
                 registration_status: RegistrationStatus::RegisterOnNextConnection,
-                connection_status: ConnectionStatus::Disconnected,
                 registration_ttl,
             }
         }
 
-        fn register(&mut self) {
-            self.inner.register(
-                self.namespace.into(),
-                self.rendezvous_peer_id,
-                self.registration_ttl,
-            );
+        fn set_connection(&mut self, status: ConnectionStatus) {
+            self.connection_status = status;
+        }
+
+        fn set_registration(&mut self, status: RegistrationStatus) {
+            self.registration_status = status;
+        }
+    }
+
+    impl Behaviour {
+        pub fn new(identity: identity::Keypair, rendezvous_nodes: Vec<RendezvousNode>) -> Self {
+            Self {
+                inner: libp2p::rendezvous::client::Behaviour::new(identity),
+                rendezvous_nodes,
+                to_dial: VecDeque::new(),
+            }
+        }
+
+        /// Calls the rendezvous register method of the node at node_index in the Vec of rendezvous nodes
+        fn register(&mut self, node_index: usize) {
+            let node = &self.rendezvous_nodes[node_index];
+            self.inner
+                .register(node.namespace.into(), node.peer_id, node.registration_ttl);
         }
     }
 
@@ -238,31 +275,37 @@ pub mod rendezous {
         }
 
         fn addresses_of_peer(&mut self, peer_id: &PeerId) -> Vec<Multiaddr> {
-            if peer_id == &self.rendezvous_peer_id {
-                return vec![self.rendezvous_point.clone()];
+            for node in self.rendezvous_nodes.iter() {
+                if peer_id == &node.peer_id {
+                    return vec![node.address.clone()];
+                }
             }
 
             vec![]
         }
 
         fn inject_connected(&mut self, peer_id: &PeerId) {
-            if peer_id == &self.rendezvous_peer_id {
-                self.connection_status = ConnectionStatus::Connected;
-
-                match &self.registration_status {
-                    RegistrationStatus::RegisterOnNextConnection => {
-                        self.register();
-                        self.registration_status = RegistrationStatus::Pending;
+            for i in 0..self.rendezvous_nodes.len() {
+                if peer_id == &self.rendezvous_nodes[i].peer_id {
+                    self.rendezvous_nodes[i].set_connection(ConnectionStatus::Connected);
+                    match &self.rendezvous_nodes[i].registration_status {
+                        RegistrationStatus::RegisterOnNextConnection => {
+                            self.register(i);
+                            self.rendezvous_nodes[i].set_registration(RegistrationStatus::Pending);
+                        }
+                        RegistrationStatus::Registered { .. } => {}
+                        RegistrationStatus::Pending => {}
                     }
-                    RegistrationStatus::Registered { .. } => {}
-                    RegistrationStatus::Pending => {}
                 }
             }
         }
 
         fn inject_disconnected(&mut self, peer_id: &PeerId) {
-            if peer_id == &self.rendezvous_peer_id {
-                self.connection_status = ConnectionStatus::Disconnected;
+            for i in 0..self.rendezvous_nodes.len() {
+                let node = &mut self.rendezvous_nodes[i];
+                if peer_id == &node.peer_id {
+                    node.connection_status = ConnectionStatus::Disconnected;
+                }
             }
         }
 
@@ -277,12 +320,17 @@ pub mod rendezous {
 
         fn inject_dial_failure(
             &mut self,
-            peer_id: &PeerId,
+            peer_id: Option<PeerId>,
             _handler: Self::ProtocolsHandler,
-            _error: DialError,
+            _error: &DialError,
         ) {
-            if peer_id == &self.rendezvous_peer_id {
-                self.connection_status = ConnectionStatus::Disconnected;
+            for i in 0..self.rendezvous_nodes.len() {
+                let node = &mut self.rendezvous_nodes[i];
+                if let Some(id) = peer_id {
+                    if id == node.peer_id {
+                        node.connection_status = ConnectionStatus::Disconnected;
+                    }
+                }
             }
         }
 
@@ -292,59 +340,73 @@ pub mod rendezous {
             cx: &mut std::task::Context<'_>,
             params: &mut impl PollParameters,
         ) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ProtocolsHandler>> {
-            match &mut self.registration_status {
-                RegistrationStatus::RegisterOnNextConnection => match self.connection_status {
-                    ConnectionStatus::Disconnected => {
-                        self.connection_status = ConnectionStatus::Dialling;
-
-                        return Poll::Ready(NetworkBehaviourAction::DialPeer {
-                            peer_id: self.rendezvous_peer_id,
-                            condition: DialPeerCondition::Disconnected,
-                            handler: Self::ProtocolsHandler::new(Duration::from_secs(30)),
-                        });
-                    }
-                    ConnectionStatus::Dialling => {}
-                    ConnectionStatus::Connected => {
-                        self.registration_status = RegistrationStatus::Pending;
-                        self.register();
-                    }
-                },
-                RegistrationStatus::Registered { re_register_in } => {
-                    if let Poll::Ready(()) = re_register_in.poll_unpin(cx) {
-                        match self.connection_status {
-                            ConnectionStatus::Connected => {
-                                self.registration_status = RegistrationStatus::Pending;
-                                self.register();
-                            }
-                            ConnectionStatus::Disconnected => {
-                                self.registration_status =
-                                    RegistrationStatus::RegisterOnNextConnection;
-
-                                return Poll::Ready(NetworkBehaviourAction::DialPeer {
-                                    peer_id: self.rendezvous_peer_id,
-                                    condition: DialPeerCondition::Disconnected,
-                                    handler: Self::ProtocolsHandler::new(Duration::from_secs(30)),
-                                });
+            if let Some(peer_id) = self.to_dial.pop_front() {
+                return Poll::Ready(NetworkBehaviourAction::Dial {
+                    opts: DialOpts::peer_id(peer_id)
+                        .condition(PeerCondition::Disconnected)
+                        .build(),
+
+                    handler: Self::ProtocolsHandler::new(Duration::from_secs(30)),
+                });
+            }
+            // check the status of each rendezvous node
+            for i in 0..self.rendezvous_nodes.len() {
+                let connection_status = self.rendezvous_nodes[i].connection_status.clone();
+                match &mut self.rendezvous_nodes[i].registration_status {
+                    RegistrationStatus::RegisterOnNextConnection => match connection_status {
+                        ConnectionStatus::Disconnected => {
+                            self.rendezvous_nodes[i].set_connection(ConnectionStatus::Dialling);
+                            self.to_dial.push_back(self.rendezvous_nodes[i].peer_id);
+                        }
+                        ConnectionStatus::Dialling => {}
+                        ConnectionStatus::Connected => {
+                            self.rendezvous_nodes[i].set_registration(RegistrationStatus::Pending);
+                            self.register(i);
+                        }
+                    },
+                    RegistrationStatus::Registered { re_register_in } => {
+                        if let Poll::Ready(()) = re_register_in.poll_unpin(cx) {
+                            match connection_status {
+                                ConnectionStatus::Connected => {
+                                    self.rendezvous_nodes[i]
+                                        .set_registration(RegistrationStatus::Pending);
+                                    self.register(i);
+                                }
+                                ConnectionStatus::Disconnected => {
+                                    self.rendezvous_nodes[i].set_registration(
+                                        RegistrationStatus::RegisterOnNextConnection,
+                                    );
+                                    self.to_dial.push_back(self.rendezvous_nodes[i].peer_id);
+                                }
+                                ConnectionStatus::Dialling => {}
                             }
-                            ConnectionStatus::Dialling => {}
                         }
                     }
+                    RegistrationStatus::Pending => {}
                 }
-                RegistrationStatus::Pending => {}
             }
 
             let inner_poll = self.inner.poll(cx, params);
 
-            // reset the timer if we successfully registered
+            // reset the timer for the specific rendezvous node if we successfully registered
             if let Poll::Ready(NetworkBehaviourAction::GenerateEvent(
-                libp2p::rendezvous::client::Event::Registered { ttl, .. },
+                libp2p::rendezvous::client::Event::Registered {
+                    ttl,
+                    rendezvous_node,
+                    ..
+                },
             )) = &inner_poll
             {
-                let half_of_ttl = Duration::from_secs(*ttl) / 2;
-
-                self.registration_status = RegistrationStatus::Registered {
-                    re_register_in: Box::pin(tokio::time::sleep(half_of_ttl)),
-                };
+                if let Some(i) = self
+                    .rendezvous_nodes
+                    .iter()
+                    .position(|n| &n.peer_id == rendezvous_node)
+                {
+                    let half_of_ttl = Duration::from_secs(*ttl) / 2;
+                    let re_register_in = Box::pin(tokio::time::sleep(half_of_ttl));
+                    let status = RegistrationStatus::Registered { re_register_in };
+                    self.rendezvous_nodes[i].set_registration(status);
+                }
             }
 
             inner_poll
@@ -358,6 +420,7 @@ pub mod rendezous {
         use futures::StreamExt;
         use libp2p::rendezvous;
         use libp2p::swarm::SwarmEvent;
+        use std::collections::HashMap;
 
         #[tokio::test]
         async fn given_no_initial_connection_when_constructed_asb_connects_and_registers_with_rendezvous_node(
@@ -365,16 +428,16 @@ pub mod rendezous {
             let mut rendezvous_node = new_swarm(|_, _| {
                 rendezvous::server::Behaviour::new(rendezvous::server::Config::default())
             });
-            let rendezvous_address = rendezvous_node.listen_on_random_memory_address().await;
+            let address = rendezvous_node.listen_on_random_memory_address().await;
+            let rendezvous_point = RendezvousNode::new(
+                &address,
+                rendezvous_node.local_peer_id().to_owned(),
+                XmrBtcNamespace::Testnet,
+                None,
+            );
 
             let mut asb = new_swarm(|_, identity| {
-                rendezous::Behaviour::new(
-                    identity,
-                    *rendezvous_node.local_peer_id(),
-                    rendezvous_address,
-                    XmrBtcNamespace::Testnet,
-                    None,
-                )
+                super::rendezvous::Behaviour::new(identity, vec![rendezvous_point])
             });
             asb.listen_on_random_memory_address().await; // this adds an external address
 
@@ -406,16 +469,16 @@ pub mod rendezous {
                     rendezvous::server::Config::default().with_min_ttl(2),
                 )
             });
-            let rendezvous_address = rendezvous_node.listen_on_random_memory_address().await;
+            let address = rendezvous_node.listen_on_random_memory_address().await;
+            let rendezvous_point = RendezvousNode::new(
+                &address,
+                rendezvous_node.local_peer_id().to_owned(),
+                XmrBtcNamespace::Testnet,
+                Some(5),
+            );
 
             let mut asb = new_swarm(|_, identity| {
-                rendezous::Behaviour::new(
-                    identity,
-                    *rendezvous_node.local_peer_id(),
-                    rendezvous_address,
-                    XmrBtcNamespace::Testnet,
-                    Some(5),
-                )
+                super::rendezvous::Behaviour::new(identity, vec![rendezvous_point])
             });
             asb.listen_on_random_memory_address().await; // this adds an external address
 
@@ -445,5 +508,62 @@ pub mod rendezous {
                 .unwrap()
                 .unwrap();
         }
+
+        #[tokio::test]
+        async fn asb_registers_multiple() {
+            let registration_ttl = Some(10);
+            let mut rendezvous_nodes = Vec::new();
+            let mut registrations = HashMap::new();
+            // register with 5 rendezvous nodes
+            for _ in 0..5 {
+                let mut rendezvous = new_swarm(|_, _| {
+                    rendezvous::server::Behaviour::new(
+                        rendezvous::server::Config::default().with_min_ttl(2),
+                    )
+                });
+                let address = rendezvous.listen_on_random_memory_address().await;
+                let id = *rendezvous.local_peer_id();
+                registrations.insert(id, 0);
+                rendezvous_nodes.push(RendezvousNode::new(
+                    &address,
+                    *rendezvous.local_peer_id(),
+                    XmrBtcNamespace::Testnet,
+                    registration_ttl,
+                ));
+                tokio::spawn(async move {
+                    loop {
+                        rendezvous.next().await;
+                    }
+                });
+            }
+
+            let mut asb = new_swarm(|_, identity| {
+                super::rendezvous::Behaviour::new(identity, rendezvous_nodes)
+            });
+            asb.listen_on_random_memory_address().await; // this adds an external address
+
+            let handle = tokio::spawn(async move {
+                loop {
+                    if let SwarmEvent::Behaviour(rendezvous::client::Event::Registered {
+                        rendezvous_node,
+                        ..
+                    }) = asb.select_next_some().await
+                    {
+                        registrations
+                            .entry(rendezvous_node)
+                            .and_modify(|counter| *counter += 1);
+                    }
+
+                    if registrations.iter().all(|(_, &count)| count >= 4) {
+                        break;
+                    }
+                }
+            });
+
+            tokio::time::timeout(Duration::from_secs(30), handle)
+                .await
+                .unwrap()
+                .unwrap();
+        }
     }
 }

swap/src/asb/rate.rs

@@ -5,7 +5,7 @@ use rust_decimal::Decimal;
 use std::fmt::{Debug, Display, Formatter};
 
 /// Represents the rate at which we are willing to trade 1 XMR.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Rate {
     /// Represents the asking price from the market.
     ask: bitcoin::Amount,
@@ -29,7 +29,7 @@ impl Rate {
     ///
     /// This applies the spread to the market asking price.
     pub fn ask(&self) -> Result<bitcoin::Amount> {
-        let sats = self.ask.as_sat();
+        let sats = self.ask.to_sat();
         let sats = Decimal::from(sats);
 
         let additional_sats = sats * self.ask_spread;
@@ -51,13 +51,13 @@ impl Rate {
         // quote (btc) = rate * base (xmr)
         // base = quote / rate
 
-        let quote_in_sats = quote.as_sat();
+        let quote_in_sats = quote.to_sat();
         let quote_in_btc = Decimal::from(quote_in_sats)
-            .checked_div(Decimal::from(bitcoin::Amount::ONE_BTC.as_sat()))
+            .checked_div(Decimal::from(bitcoin::Amount::ONE_BTC.to_sat()))
             .context("Division overflow")?;
 
-        let rate_in_btc = Decimal::from(rate.as_sat())
-            .checked_div(Decimal::from(bitcoin::Amount::ONE_BTC.as_sat()))
+        let rate_in_btc = Decimal::from(rate.to_sat())
+            .checked_div(Decimal::from(bitcoin::Amount::ONE_BTC.to_sat()))
             .context("Division overflow")?;
 
         let base_in_xmr = quote_in_btc
@@ -105,7 +105,7 @@ mod tests {
 
         let amount = rate.ask().unwrap();
 
-        assert_eq!(amount.as_sat(), 102);
+        assert_eq!(amount.to_sat(), 102);
     }
 
     #[test]

swap/src/asb/recovery/cancel.rs

@@ -39,7 +39,7 @@ pub async fn cancel(
         | AliceState::BtcRedeemed
         | AliceState::XmrRefunded
         | AliceState::BtcPunished
-        | AliceState::SafelyAborted => bail!("Swap is is in state {} which is not cancelable", state),
+        | AliceState::SafelyAborted => bail!("Swap is in state {} which is not cancelable", state),
     };
 
     let txid = match state3.submit_tx_cancel(bitcoin_wallet.as_ref()).await {

swap/src/asb/tracing.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
-use time::format_description::well_known::Rfc3339;
 use tracing_subscriber::filter::LevelFilter;
-use tracing_subscriber::fmt::time::LocalTime;
+use tracing_subscriber::fmt::time::UtcTime;
 use tracing_subscriber::FmtSubscriber;
 
 pub fn init(level: LevelFilter, json_format: bool, timestamp: bool) -> Result<()> {
@@ -15,7 +14,7 @@ pub fn init(level: LevelFilter, json_format: bool, timestamp: bool) -> Result<()
         .with_env_filter(format!("asb={},swap={}", level, level))
         .with_writer(std::io::stderr)
         .with_ansi(is_terminal)
-        .with_timer(LocalTime::new(Rfc3339))
+        .with_timer(UtcTime::rfc_3339())
         .with_target(false);
 
     match (json_format, timestamp) {

swap/src/bin/asb.rs

@@ -29,8 +29,8 @@ use swap::asb::config::{
     initial_setup, query_user_for_initial_config, read_config, Config, ConfigNotInitialized,
 };
 use swap::asb::{cancel, punish, redeem, refund, safely_abort, EventLoop, Finality, KrakenRate};
+use swap::common::check_latest_version;
 use swap::database::open_db;
-use swap::monero::Amount;
 use swap::network::rendezvous::XmrBtcNamespace;
 use swap::network::swarm;
 use swap::protocol::alice::{run, AliceState};
@@ -68,6 +68,10 @@ async fn main() -> Result<()> {
         }
     };
 
+    if let Err(e) = check_latest_version(env!("CARGO_PKG_VERSION")).await {
+        eprintln!("{}", e);
+    }
+
     asb::tracing::init(LevelFilter::DEBUG, json, !disable_timestamp).expect("initialize tracing");
 
     let config = match read_config(config_path.clone())? {
@@ -98,23 +102,47 @@ async fn main() -> Result<()> {
 
     match cmd {
         Command::Start { resume_only } => {
-            let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
+            // check and warn for duplicate rendezvous points
+            let mut rendezvous_addrs = config.network.rendezvous_point.clone();
+            let prev_len = rendezvous_addrs.len();
+            rendezvous_addrs.sort();
+            rendezvous_addrs.dedup();
+            let new_len = rendezvous_addrs.len();
+            if new_len < prev_len {
+                tracing::warn!(
+                    "`rendezvous_point` config has {} duplicate entries, they are being ignored.",
+                    prev_len - new_len
+                );
+            }
 
             let monero_wallet = init_monero_wallet(&config, env_config).await?;
+            let monero_address = monero_wallet.get_main_address();
+            tracing::info!(%monero_address, "Monero wallet address");
+            let monero = monero_wallet.get_balance().await?;
+            match (monero.balance, monero.unlocked_balance) {
+                (0, _) => {
+                    tracing::warn!(
+                        %monero_address,
+                        "The Monero balance is 0, make sure to deposit funds at",
+                    )
+                }
+                (total, 0) => {
+                    let total = monero::Amount::from_piconero(total);
+                    tracing::warn!(
+                        %total,
+                        "Unlocked Monero balance is 0, total balance is",
+                    )
+                }
+                (total, unlocked) => {
+                    let total = monero::Amount::from_piconero(total);
+                    let unlocked = monero::Amount::from_piconero(unlocked);
+                    tracing::info!(%total, %unlocked, "Monero wallet balance");
+                }
+            }
 
+            let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
             let bitcoin_balance = bitcoin_wallet.balance().await?;
-            tracing::info!(%bitcoin_balance, "Initialized Bitcoin wallet");
-
-            let monero_balance = monero_wallet.get_balance().await?;
-            if monero_balance == Amount::ZERO {
-                let monero_address = monero_wallet.get_main_address();
-                tracing::warn!(
-                    %monero_address,
-                    "The Monero balance is 0, make sure to deposit funds at",
-                )
-            } else {
-                tracing::info!(%monero_balance, "Initialized Monero wallet");
-            }
+            tracing::info!(%bitcoin_balance, "Bitcoin wallet balance");
 
             let kraken_price_updates = kraken::connect(config.maker.price_ticker_ws_url.clone())?;
 
@@ -136,6 +164,8 @@ async fn main() -> Result<()> {
             };
 
             let kraken_rate = KrakenRate::new(config.maker.ask_spread, kraken_price_updates);
+            let namespace = XmrBtcNamespace::from_is_testnet(testnet);
+
             let mut swarm = swarm::asb(
                 &seed,
                 config.maker.min_buy_btc,
@@ -143,16 +173,8 @@ async fn main() -> Result<()> {
                 kraken_rate.clone(),
                 resume_only,
                 env_config,
-                config.network.rendezvous_point.map(|rendezvous_point| {
-                    (
-                        rendezvous_point,
-                        if testnet {
-                            XmrBtcNamespace::Testnet
-                        } else {
-                            XmrBtcNamespace::Mainnet
-                        },
-                    )
-                }),
+                namespace,
+                &rendezvous_addrs,
             )?;
 
             for listen in config.network.listen.clone() {
@@ -179,6 +201,7 @@ async fn main() -> Result<()> {
                 kraken_rate.clone(),
                 config.maker.min_buy_btc,
                 config.maker.max_buy_btc,
+                config.maker.external_bitcoin_redeem_address,
             )
             .unwrap();
 
@@ -237,16 +260,14 @@ async fn main() -> Result<()> {
             bitcoin_wallet.broadcast(signed_tx, "withdraw").await?;
         }
         Command::Balance => {
-            let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
             let monero_wallet = init_monero_wallet(&config, env_config).await?;
-
-            let bitcoin_balance = bitcoin_wallet.balance().await?;
             let monero_balance = monero_wallet.get_balance().await?;
+            tracing::info!(%monero_balance);
 
-            tracing::info!(
-                %bitcoin_balance,
-                %monero_balance,
-                "Current balance");
+            let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
+            let bitcoin_balance = bitcoin_wallet.balance().await?;
+            tracing::info!(%bitcoin_balance);
+            tracing::info!(%bitcoin_balance, %monero_balance, "Current balance");
         }
         Command::Cancel { swap_id } => {
             let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
@@ -313,11 +334,10 @@ async fn init_bitcoin_wallet(
     env_config: swap::env::Config,
 ) -> Result<bitcoin::Wallet> {
     tracing::debug!("Opening Bitcoin wallet");
-    let wallet_dir = config.data.dir.join("wallet");
-
+    let data_dir = &config.data.dir;
     let wallet = bitcoin::Wallet::new(
         config.bitcoin.electrum_rpc_url.clone(),
-        &wallet_dir,
+        data_dir,
         seed.derive_extended_private_key(env_config.bitcoin_network)?,
         env_config,
         config.bitcoin.target_block,

swap/src/bin/swap.rs

@@ -12,616 +12,37 @@
 #![forbid(unsafe_code)]
 #![allow(non_snake_case)]
 
-use anyhow::{bail, Context, Result};
-use comfy_table::Table;
-use qrcode::render::unicode;
-use qrcode::QrCode;
-use std::cmp::min;
-use std::convert::TryInto;
+use anyhow::Result;
 use std::env;
-use std::future::Future;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-use swap::bitcoin::TxLock;
-use swap::cli::command::{parse_args_and_apply_defaults, Arguments, Command, ParseResult};
-use swap::cli::{list_sellers, EventLoop, SellerStatus};
-use swap::database::open_db;
-use swap::env::Config;
-use swap::libp2p_ext::MultiAddrExt;
-use swap::network::quote::BidQuote;
-use swap::network::swarm;
-use swap::protocol::bob;
-use swap::protocol::bob::{BobState, Swap};
-use swap::seed::Seed;
-use swap::{bitcoin, cli, monero};
-use url::Url;
-use uuid::Uuid;
+use swap::cli::command::{parse_args_and_apply_defaults, ParseResult};
+use swap::common::check_latest_version;
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let Arguments {
-        env_config,
-        data_dir,
-        debug,
-        json,
-        cmd,
-    } = match parse_args_and_apply_defaults(env::args_os())? {
-        ParseResult::Arguments(args) => args,
+    let (context, request) = match parse_args_and_apply_defaults(env::args_os()).await? {
+        ParseResult::Context(context, request) => (context, request),
         ParseResult::PrintAndExitZero { message } => {
             println!("{}", message);
             std::process::exit(0);
         }
     };
 
-    match cmd {
-        Command::BuyXmr {
-            seller,
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-            bitcoin_change_address,
-            monero_receive_address,
-            monero_daemon_address,
-            tor_socks5_port,
-        } => {
-            let swap_id = Uuid::new_v4();
-
-            cli::tracing::init(debug, json, data_dir.join("logs"), Some(swap_id))?;
-            let db = open_db(data_dir.join("sqlite")).await?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir.clone(),
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-            let (monero_wallet, _process) =
-                init_monero_wallet(data_dir, monero_daemon_address, env_config).await?;
-            let bitcoin_wallet = Arc::new(bitcoin_wallet);
-            let seller_peer_id = seller
-                .extract_peer_id()
-                .context("Seller address must contain peer ID")?;
-            db.insert_address(seller_peer_id, seller.clone()).await?;
-
-            let behaviour = cli::Behaviour::new(seller_peer_id, env_config, bitcoin_wallet.clone());
-            let mut swarm =
-                swarm::cli(seed.derive_libp2p_identity(), tor_socks5_port, behaviour).await?;
-            swarm.behaviour_mut().add_address(seller_peer_id, seller);
-
-            tracing::debug!(peer_id = %swarm.local_peer_id(), "Network layer initialized");
-
-            let (event_loop, mut event_loop_handle) =
-                EventLoop::new(swap_id, swarm, seller_peer_id, env_config)?;
-            let event_loop = tokio::spawn(event_loop.run());
-
-            let max_givable = || bitcoin_wallet.max_giveable(TxLock::script_size());
-            let (amount, fees) = determine_btc_to_swap(
-                json,
-                event_loop_handle.request_quote(),
-                bitcoin_wallet.new_address(),
-                || bitcoin_wallet.balance(),
-                max_givable,
-                || bitcoin_wallet.sync(),
-            )
-            .await?;
-
-            tracing::info!(%amount, %fees,  "Determined swap amount");
-
-            db.insert_peer_id(swap_id, seller_peer_id).await?;
-            db.insert_monero_address(swap_id, monero_receive_address)
-                .await?;
-
-            let swap = Swap::new(
-                db,
-                swap_id,
-                bitcoin_wallet,
-                Arc::new(monero_wallet),
-                env_config,
-                event_loop_handle,
-                monero_receive_address,
-                bitcoin_change_address,
-                amount,
-            );
-
-            tokio::select! {
-                result = event_loop => {
-                    result
-                        .context("EventLoop panicked")?;
-                },
-                result = bob::run(swap) => {
-                    result.context("Failed to complete swap")?;
-                }
-            }
-        }
-        Command::History => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), None)?;
-
-            let db = open_db(data_dir.join("sqlite")).await?;
-            let swaps = db.all().await?;
-
-            if json {
-                for (swap_id, state) in swaps {
-                    let state: BobState = state.try_into()?;
-                    tracing::info!(swap_id=%swap_id.to_string(), state=%state.to_string(), "Read swap state from database");
-                }
-            } else {
-                let mut table = Table::new();
-
-                table.set_header(vec!["SWAP ID", "STATE"]);
-
-                for (swap_id, state) in swaps {
-                    let state: BobState = state.try_into()?;
-                    table.add_row(vec![swap_id.to_string(), state.to_string()]);
-                }
-
-                println!("{}", table);
-            }
-        }
-        Command::Config => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), None)?;
-
-            tracing::info!(path=%data_dir.display(), "Data directory");
-            tracing::info!(path=%format!("{}/logs", data_dir.display()), "Log files directory");
-            tracing::info!(path=%format!("{}/sqlite", data_dir.display()), "Sqlite file location");
-            tracing::info!(path=%format!("{}/seed.pem", data_dir.display()), "Seed file location");
-            tracing::info!(path=%format!("{}/monero", data_dir.display()), "Monero-wallet-rpc directory");
-            tracing::info!(path=%format!("{}/wallet", data_dir.display()), "Internal bitcoin wallet directory");
-        }
-        Command::WithdrawBtc {
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-            amount,
-            address,
-        } => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), None)?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir.clone(),
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-
-            let amount = match amount {
-                Some(amount) => amount,
-                None => {
-                    bitcoin_wallet
-                        .max_giveable(address.script_pubkey().len())
-                        .await?
-                }
-            };
-
-            let psbt = bitcoin_wallet
-                .send_to_address(address, amount, None)
-                .await?;
-            let signed_tx = bitcoin_wallet.sign_and_finalize(psbt).await?;
-
-            bitcoin_wallet.broadcast(signed_tx, "withdraw").await?;
-        }
-
-        Command::Balance {
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-        } => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), None)?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir.clone(),
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-
-            let bitcoin_balance = bitcoin_wallet.balance().await?;
-            tracing::info!(
-                balance = %bitcoin_balance,
-                "Checked Bitcoin balance",
-            );
-        }
-        Command::Resume {
-            swap_id,
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-            monero_daemon_address,
-            tor_socks5_port,
-        } => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), Some(swap_id))?;
-            let db = open_db(data_dir.join("sqlite")).await?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir.clone(),
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-            let (monero_wallet, _process) =
-                init_monero_wallet(data_dir, monero_daemon_address, env_config).await?;
-            let bitcoin_wallet = Arc::new(bitcoin_wallet);
-
-            let seller_peer_id = db.get_peer_id(swap_id).await?;
-            let seller_addresses = db.get_addresses(seller_peer_id).await?;
-
-            let behaviour = cli::Behaviour::new(seller_peer_id, env_config, bitcoin_wallet.clone());
-            let mut swarm =
-                swarm::cli(seed.derive_libp2p_identity(), tor_socks5_port, behaviour).await?;
-            let our_peer_id = swarm.local_peer_id();
-            tracing::debug!(peer_id = %our_peer_id, "Network layer initialized");
-
-            for seller_address in seller_addresses {
-                swarm
-                    .behaviour_mut()
-                    .add_address(seller_peer_id, seller_address);
-            }
-
-            let (event_loop, event_loop_handle) =
-                EventLoop::new(swap_id, swarm, seller_peer_id, env_config)?;
-            let handle = tokio::spawn(event_loop.run());
-
-            let monero_receive_address = db.get_monero_address(swap_id).await?;
-            let swap = Swap::from_db(
-                db,
-                swap_id,
-                bitcoin_wallet,
-                Arc::new(monero_wallet),
-                env_config,
-                event_loop_handle,
-                monero_receive_address,
-            )
-            .await?;
-
-            tokio::select! {
-                event_loop_result = handle => {
-                    event_loop_result?;
-                },
-                swap_result = bob::run(swap) => {
-                    swap_result?;
-                }
-            }
-        }
-        Command::Cancel {
-            swap_id,
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-        } => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), Some(swap_id))?;
-            let db = open_db(data_dir.join("sqlite")).await?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir,
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-
-            let (txid, _) = cli::cancel(swap_id, Arc::new(bitcoin_wallet), db).await?;
-            tracing::debug!("Cancel transaction successfully published with id {}", txid);
-        }
-        Command::Refund {
-            swap_id,
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-        } => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), Some(swap_id))?;
-            let db = open_db(data_dir.join("sqlite")).await?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir,
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-
-            cli::refund(swap_id, Arc::new(bitcoin_wallet), db).await?;
-        }
-        Command::ListSellers {
-            rendezvous_point,
-            namespace,
-            tor_socks5_port,
-        } => {
-            let rendezvous_node_peer_id = rendezvous_point
-                .extract_peer_id()
-                .context("Rendezvous node address must contain peer ID")?;
-
-            cli::tracing::init(debug, json, data_dir.join("logs"), None)?;
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-            let identity = seed.derive_libp2p_identity();
-
-            let sellers = list_sellers(
-                rendezvous_node_peer_id,
-                rendezvous_point,
-                namespace,
-                tor_socks5_port,
-                identity,
-            )
-            .await?;
-
-            if json {
-                for seller in sellers {
-                    match seller.status {
-                        SellerStatus::Online(quote) => {
-                            tracing::info!(
-                                price = %quote.price.to_string(),
-                                min_quantity = %quote.min_quantity.to_string(),
-                                max_quantity = %quote.max_quantity.to_string(),
-                                status = "Online",
-                                address = %seller.multiaddr.to_string(),
-                                "Fetched peer status"
-                            );
-                        }
-                        SellerStatus::Unreachable => {
-                            tracing::info!(
-                                status = "Unreachable",
-                                address = %seller.multiaddr.to_string(),
-                                "Fetched peer status"
-                            );
-                        }
-                    }
-                }
-            } else {
-                let mut table = Table::new();
-
-                table.set_header(vec![
-                    "PRICE",
-                    "MIN_QUANTITY",
-                    "MAX_QUANTITY",
-                    "STATUS",
-                    "ADDRESS",
-                ]);
-
-                for seller in sellers {
-                    let row = match seller.status {
-                        SellerStatus::Online(quote) => {
-                            vec![
-                                quote.price.to_string(),
-                                quote.min_quantity.to_string(),
-                                quote.max_quantity.to_string(),
-                                "Online".to_owned(),
-                                seller.multiaddr.to_string(),
-                            ]
-                        }
-                        SellerStatus::Unreachable => {
-                            vec![
-                                "???".to_owned(),
-                                "???".to_owned(),
-                                "???".to_owned(),
-                                "Unreachable".to_owned(),
-                                seller.multiaddr.to_string(),
-                            ]
-                        }
-                    };
-
-                    table.add_row(row);
-                }
-
-                println!("{}", table);
-            }
-        }
-        Command::ExportBitcoinWallet {
-            bitcoin_electrum_rpc_url,
-            bitcoin_target_block,
-        } => {
-            cli::tracing::init(debug, json, data_dir.join("logs"), None)?;
-
-            let seed = Seed::from_file_or_generate(data_dir.as_path())
-                .context("Failed to read in seed file")?;
-            let bitcoin_wallet = init_bitcoin_wallet(
-                bitcoin_electrum_rpc_url,
-                &seed,
-                data_dir.clone(),
-                env_config,
-                bitcoin_target_block,
-            )
-            .await?;
-            let wallet_export = bitcoin_wallet.wallet_export("cli").await?;
-            tracing::info!(descriptor=%wallet_export.to_string(), "Exported bitcoin wallet");
-        }
-        Command::MoneroRecovery { swap_id } => {
-            let db = open_db(data_dir.join("sqlite")).await?;
-
-            let swap_state: BobState = db.get_state(swap_id).await?.try_into()?;
-
-            match swap_state {
-                BobState::Started { .. }
-                | BobState::SwapSetupCompleted(_)
-                | BobState::BtcLocked { .. }
-                | BobState::XmrLockProofReceived { .. }
-                | BobState::XmrLocked(_)
-                | BobState::EncSigSent(_)
-                | BobState::CancelTimelockExpired(_)
-                | BobState::BtcCancelled(_)
-                | BobState::BtcRefunded(_)
-                | BobState::BtcPunished { .. }
-                | BobState::SafelyAborted
-                | BobState::XmrRedeemed { .. } => {
-                    bail!("Cannot print monero recovery information in state {}, only possible for BtcRedeemed", swap_state)
-                }
-                BobState::BtcRedeemed(state5) => {
-                    let (spend_key, view_key) = state5.xmr_keys();
-
-                    let address = monero::Address::standard(
-                        env_config.monero_network,
-                        monero::PublicKey::from_private_key(&spend_key),
-                        monero::PublicKey::from(view_key.public()),
-                    );
-                    tracing::info!("Wallet address: {}", address.to_string());
-
-                    let view_key = serde_json::to_string(&view_key)?;
-                    println!("View key: {}", view_key);
-
-                    println!("Spend key: {}", spend_key);
-                }
-            }
-        }
-    };
+    if let Err(e) = check_latest_version(env!("CARGO_PKG_VERSION")).await {
+        eprintln!("{}", e);
+    }
+    request.call(context.clone()).await?;
+    context.tasks.wait_for_tasks().await?;
     Ok(())
 }
 
-async fn init_bitcoin_wallet(
-    electrum_rpc_url: Url,
-    seed: &Seed,
-    data_dir: PathBuf,
-    env_config: Config,
-    bitcoin_target_block: usize,
-) -> Result<bitcoin::Wallet> {
-    let wallet_dir = data_dir.join("wallet");
-
-    let wallet = bitcoin::Wallet::new(
-        electrum_rpc_url.clone(),
-        &wallet_dir,
-        seed.derive_extended_private_key(env_config.bitcoin_network)?,
-        env_config,
-        bitcoin_target_block,
-    )
-    .await
-    .context("Failed to initialize Bitcoin wallet")?;
-
-    wallet.sync().await?;
-
-    Ok(wallet)
-}
-
-async fn init_monero_wallet(
-    data_dir: PathBuf,
-    monero_daemon_address: String,
-    env_config: Config,
-) -> Result<(monero::Wallet, monero::WalletRpcProcess)> {
-    let network = env_config.monero_network;
-
-    const MONERO_BLOCKCHAIN_MONITORING_WALLET_NAME: &str = "swap-tool-blockchain-monitoring-wallet";
-
-    let monero_wallet_rpc = monero::WalletRpc::new(data_dir.join("monero")).await?;
-
-    let monero_wallet_rpc_process = monero_wallet_rpc
-        .run(network, monero_daemon_address.as_str())
-        .await?;
-
-    let monero_wallet = monero::Wallet::open_or_create(
-        monero_wallet_rpc_process.endpoint(),
-        MONERO_BLOCKCHAIN_MONITORING_WALLET_NAME.to_string(),
-        env_config,
-    )
-    .await?;
-
-    Ok((monero_wallet, monero_wallet_rpc_process))
-}
-
-fn qr_code(value: &impl ToString) -> Result<String> {
-    let code = QrCode::new(value.to_string())?;
-    let qr_code = code
-        .render::<unicode::Dense1x2>()
-        .dark_color(unicode::Dense1x2::Light)
-        .light_color(unicode::Dense1x2::Dark)
-        .build();
-    Ok(qr_code)
-}
-
-async fn determine_btc_to_swap<FB, TB, FMG, TMG, FS, TS>(
-    json: bool,
-    bid_quote: impl Future<Output = Result<BidQuote>>,
-    get_new_address: impl Future<Output = Result<bitcoin::Address>>,
-    balance: FB,
-    max_giveable_fn: FMG,
-    sync: FS,
-) -> Result<(bitcoin::Amount, bitcoin::Amount)>
-where
-    TB: Future<Output = Result<bitcoin::Amount>>,
-    FB: Fn() -> TB,
-    TMG: Future<Output = Result<bitcoin::Amount>>,
-    FMG: Fn() -> TMG,
-    TS: Future<Output = Result<()>>,
-    FS: Fn() -> TS,
-{
-    tracing::debug!("Requesting quote");
-    let bid_quote = bid_quote.await?;
-    tracing::info!(
-        price = %bid_quote.price,
-        minimum_amount = %bid_quote.min_quantity,
-        maximum_amount = %bid_quote.max_quantity,
-        "Received quote",
-    );
-
-    let mut max_giveable = max_giveable_fn().await?;
-
-    if max_giveable == bitcoin::Amount::ZERO || max_giveable < bid_quote.min_quantity {
-        let deposit_address = get_new_address.await?;
-        let minimum_amount = bid_quote.min_quantity;
-        let maximum_amount = bid_quote.max_quantity;
-
-        if !json {
-            eprintln!("{}", qr_code(&deposit_address)?);
-        }
-
-        loop {
-            tracing::info!(
-                %deposit_address,
-                %max_giveable,
-                %minimum_amount,
-                %maximum_amount,
-                "Waiting for Bitcoin deposit",
-            );
-
-            max_giveable = loop {
-                sync().await?;
-                let new_max_givable = max_giveable_fn().await?;
-
-                if new_max_givable > max_giveable {
-                    break new_max_givable;
-                }
-
-                tokio::time::sleep(Duration::from_secs(1)).await;
-            };
-
-            let new_balance = balance().await?;
-            tracing::info!(%new_balance, %max_giveable, "Received Bitcoin");
-
-            if max_giveable < bid_quote.min_quantity {
-                tracing::info!("Deposited amount is less than `min_quantity`");
-                continue;
-            }
-
-            break;
-        }
-    };
-
-    let balance = balance().await?;
-    let fees = balance - max_giveable;
-
-    let max_accepted = bid_quote.max_quantity;
-
-    let btc_swap_amount = min(max_giveable, max_accepted);
-
-    Ok((btc_swap_amount, fees))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::determine_btc_to_swap;
     use ::bitcoin::Amount;
-    use std::sync::Mutex;
+    use std::sync::{Arc, Mutex};
+    use std::time::Duration;
+    use swap::api::request::determine_btc_to_swap;
+    use swap::network::quote::BidQuote;
     use swap::tracing_ext::capture_logs;
     use tracing::level_filters::LevelFilter;
 
@@ -635,7 +56,7 @@ mod tests {
 
         let (amount, fees) = determine_btc_to_swap(
             true,
-            async { Ok(quote_with_max(0.01)) },
+            quote_with_max(0.01),
             get_dummy_address(),
             || async { Ok(Amount::from_btc(0.001)?) },
             || async {
@@ -643,6 +64,7 @@ mod tests {
                 result.give()
             },
             || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
         )
         .await
         .unwrap();
@@ -653,9 +75,10 @@ mod tests {
         assert_eq!((amount, fees), (expected_amount, expected_fees));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.00000000 BTC maximum_amount=0.01000000 BTC
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.00000000 BTC minimum_amount=0.00000000 BTC maximum_amount=0.01000000 BTC
- INFO swap: Received Bitcoin new_balance=0.00100000 BTC max_giveable=0.00090000 BTC
+            r" INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0 BTC maximum_amount=0.01 BTC
+ INFO swap::api::request: Deposit at least 0.00001 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.00001 BTC max_giveable=0 BTC minimum_amount=0 BTC maximum_amount=0.01 BTC
+ INFO swap::api::request: Received Bitcoin new_balance=0.001 BTC max_giveable=0.0009 BTC
 "
         );
     }
@@ -670,7 +93,7 @@ mod tests {
 
         let (amount, fees) = determine_btc_to_swap(
             true,
-            async { Ok(quote_with_max(0.01)) },
+            quote_with_max(0.01),
             get_dummy_address(),
             || async { Ok(Amount::from_btc(0.1001)?) },
             || async {
@@ -678,6 +101,7 @@ mod tests {
                 result.give()
             },
             || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
         )
         .await
         .unwrap();
@@ -688,15 +112,16 @@ mod tests {
         assert_eq!((amount, fees), (expected_amount, expected_fees));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.00000000 BTC maximum_amount=0.01000000 BTC
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.00000000 BTC minimum_amount=0.00000000 BTC maximum_amount=0.01000000 BTC
- INFO swap: Received Bitcoin new_balance=0.10010000 BTC max_giveable=0.10000000 BTC
+            r" INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0 BTC maximum_amount=0.01 BTC
+ INFO swap::api::request: Deposit at least 0.00001 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.00001 BTC max_giveable=0 BTC minimum_amount=0 BTC maximum_amount=0.01 BTC
+ INFO swap::api::request: Received Bitcoin new_balance=0.1001 BTC max_giveable=0.1 BTC
 "
         );
     }
 
     #[tokio::test]
-    async fn given_initial_balance_below_max_quantity_swaps_max_givable() {
+    async fn given_initial_balance_below_max_quantity_swaps_max_giveable() {
         let writer = capture_logs(LevelFilter::INFO);
         let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
             Amount::from_btc(0.0049).unwrap(),
@@ -705,7 +130,7 @@ mod tests {
 
         let (amount, fees) = determine_btc_to_swap(
             true,
-            async { Ok(quote_with_max(0.01)) },
+            quote_with_max(0.01),
             async { panic!("should not request new address when initial balance  is > 0") },
             || async { Ok(Amount::from_btc(0.005)?) },
             || async {
@@ -713,6 +138,7 @@ mod tests {
                 result.give()
             },
             || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
         )
         .await
         .unwrap();
@@ -723,8 +149,7 @@ mod tests {
         assert_eq!((amount, fees), (expected_amount, expected_fees));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.00000000 BTC maximum_amount=0.01000000 BTC
-"
+            " INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0 BTC maximum_amount=0.01 BTC\n"
         );
     }
 
@@ -738,7 +163,7 @@ mod tests {
 
         let (amount, fees) = determine_btc_to_swap(
             true,
-            async { Ok(quote_with_max(0.01)) },
+            quote_with_max(0.01),
             async { panic!("should not request new address when initial balance is > 0") },
             || async { Ok(Amount::from_btc(0.1001)?) },
             || async {
@@ -746,6 +171,7 @@ mod tests {
                 result.give()
             },
             || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
         )
         .await
         .unwrap();
@@ -756,8 +182,7 @@ mod tests {
         assert_eq!((amount, fees), (expected_amount, expected_fees));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.00000000 BTC maximum_amount=0.01000000 BTC
-"
+            " INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0 BTC maximum_amount=0.01 BTC\n"
         );
     }
 
@@ -771,7 +196,7 @@ mod tests {
 
         let (amount, fees) = determine_btc_to_swap(
             true,
-            async { Ok(quote_with_min(0.01)) },
+            quote_with_min(0.01),
             get_dummy_address(),
             || async { Ok(Amount::from_btc(0.0101)?) },
             || async {
@@ -779,6 +204,7 @@ mod tests {
                 result.give()
             },
             || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
         )
         .await
         .unwrap();
@@ -789,9 +215,10 @@ mod tests {
         assert_eq!((amount, fees), (expected_amount, expected_fees));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.01000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.00000000 BTC minimum_amount=0.01000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Received Bitcoin new_balance=0.01010000 BTC max_giveable=0.01000000 BTC
+            r" INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0.01 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Deposit at least 0.01001 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.01001 BTC max_giveable=0 BTC minimum_amount=0.01 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Received Bitcoin new_balance=0.0101 BTC max_giveable=0.01 BTC
 "
         );
     }
@@ -806,7 +233,7 @@ mod tests {
 
         let (amount, fees) = determine_btc_to_swap(
             true,
-            async { Ok(quote_with_min(0.01)) },
+            quote_with_min(0.01),
             get_dummy_address(),
             || async { Ok(Amount::from_btc(0.0101)?) },
             || async {
@@ -814,6 +241,7 @@ mod tests {
                 result.give()
             },
             || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
         )
         .await
         .unwrap();
@@ -824,9 +252,10 @@ mod tests {
         assert_eq!((amount, fees), (expected_amount, expected_fees));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.01000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.00010000 BTC minimum_amount=0.01000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Received Bitcoin new_balance=0.01010000 BTC max_giveable=0.01000000 BTC
+            r" INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0.01 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Deposit at least 0.00991 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.00991 BTC max_giveable=0.0001 BTC minimum_amount=0.01 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Received Bitcoin new_balance=0.0101 BTC max_giveable=0.01 BTC
 "
         );
     }
@@ -846,7 +275,7 @@ mod tests {
             Duration::from_secs(1),
             determine_btc_to_swap(
                 true,
-                async { Ok(quote_with_min(0.1)) },
+                quote_with_min(0.1),
                 get_dummy_address(),
                 || async { Ok(Amount::from_btc(0.0101)?) },
                 || async {
@@ -854,6 +283,7 @@ mod tests {
                     result.give()
                 },
                 || async { Ok(()) },
+                |_| async { Ok(Amount::from_sat(1000)) },
             ),
         )
         .await
@@ -862,11 +292,13 @@ mod tests {
         assert!(matches!(error, tokio::time::error::Elapsed { .. }));
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.10000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.00000000 BTC minimum_amount=0.10000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Received Bitcoin new_balance=0.01010000 BTC max_giveable=0.01000000 BTC
- INFO swap: Deposited amount is less than `min_quantity`
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.01000000 BTC minimum_amount=0.10000000 BTC maximum_amount=184467440737.09551615 BTC
+            r" INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0.1 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Deposit at least 0.10001 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.10001 BTC max_giveable=0 BTC minimum_amount=0.1 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Received Bitcoin new_balance=0.0101 BTC max_giveable=0.01 BTC
+ INFO swap::api::request: Deposited amount is less than `min_quantity`
+ INFO swap::api::request: Deposit at least 0.09001 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.09001 BTC max_giveable=0.01 BTC minimum_amount=0.1 BTC maximum_amount=184467440737.09551615 BTC
 "
         );
     }
@@ -891,7 +323,7 @@ mod tests {
             Duration::from_secs(10),
             determine_btc_to_swap(
                 true,
-                async { Ok(quote_with_min(0.1)) },
+                quote_with_min(0.1),
                 get_dummy_address(),
                 || async { Ok(Amount::from_btc(0.21)?) },
                 || async {
@@ -900,6 +332,7 @@ mod tests {
                     result.give()
                 },
                 || async { Ok(()) },
+                |_| async { Ok(Amount::from_sat(1000)) },
             ),
         )
         .await
@@ -908,13 +341,41 @@ mod tests {
 
         assert_eq!(
             writer.captured(),
-            r" INFO swap: Received quote price=0.00100000 BTC minimum_amount=0.10000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 max_giveable=0.00000000 BTC minimum_amount=0.10000000 BTC maximum_amount=184467440737.09551615 BTC
- INFO swap: Received Bitcoin new_balance=0.21000000 BTC max_giveable=0.20000000 BTC
+            r" INFO swap::api::request: Received quote price=0.001 BTC minimum_amount=0.1 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Deposit at least 0.10001 BTC to cover the min quantity with fee!
+ INFO swap::api::request: Waiting for Bitcoin deposit deposit_address=1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6 min_deposit=0.10001 BTC max_giveable=0 BTC minimum_amount=0.1 BTC maximum_amount=184467440737.09551615 BTC
+ INFO swap::api::request: Received Bitcoin new_balance=0.21 BTC max_giveable=0.2 BTC
 "
         );
     }
 
+    #[tokio::test]
+    async fn given_bid_quote_max_amount_0_return_error() {
+        let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
+            Amount::from_btc(0.0001).unwrap(),
+            Amount::from_btc(0.01).unwrap(),
+        ])));
+
+        let determination_error = determine_btc_to_swap(
+            true,
+            quote_with_max(0.00),
+            get_dummy_address(),
+            || async { Ok(Amount::from_btc(0.0101)?) },
+            || async {
+                let mut result = givable.lock().unwrap();
+                result.give()
+            },
+            || async { Ok(()) },
+            |_| async { Ok(Amount::from_sat(1000)) },
+        )
+        .await
+        .err()
+        .unwrap()
+        .to_string();
+
+        assert_eq!("Received quote of 0", determination_error);
+    }
+
     struct MaxGiveable {
         amounts: Vec<Amount>,
         call_counter: usize,

swap/src/bitcoin.rs

@@ -15,7 +15,8 @@ pub use crate::bitcoin::refund::TxRefund;
 pub use crate::bitcoin::timelocks::{BlockHeight, ExpiredTimelocks};
 pub use ::bitcoin::util::amount::Amount;
 pub use ::bitcoin::util::psbt::PartiallySignedTransaction;
-pub use ::bitcoin::{Address, Network, Transaction, Txid};
+pub use ::bitcoin::{Address, AddressType, Network, Transaction, Txid};
+use bitcoin::secp256k1::ecdsa;
 pub use ecdsa_fun::adaptor::EncryptedSignature;
 pub use ecdsa_fun::fun::Scalar;
 pub use ecdsa_fun::Signature;
@@ -25,9 +26,8 @@ pub use wallet::Wallet;
 pub use wallet::WalletBuilder;
 
 use crate::bitcoin::wallet::ScriptStatus;
-use ::bitcoin::hashes::hex::ToHex;
 use ::bitcoin::hashes::Hash;
-use ::bitcoin::{secp256k1, SigHash};
+use ::bitcoin::Sighash;
 use anyhow::{bail, Context, Result};
 use bdk::miniscript::descriptor::Wsh;
 use bdk::miniscript::{Descriptor, Segwitv0};
@@ -78,7 +78,7 @@ impl SecretKey {
         self.inner.to_bytes()
     }
 
-    pub fn sign(&self, digest: SigHash) -> Signature {
+    pub fn sign(&self, digest: Sighash) -> Signature {
         let ecdsa = ECDSA::<Deterministic<Sha256>>::default();
 
         ecdsa.sign(&self.inner, &digest.into_inner())
@@ -98,7 +98,7 @@ impl SecretKey {
     // alice now has s_a and s_b and can refund monero
 
     // self = a, Y = S_b, digest = tx_refund
-    pub fn encsign(&self, Y: PublicKey, digest: SigHash) -> EncryptedSignature {
+    pub fn encsign(&self, Y: PublicKey, digest: Sighash) -> EncryptedSignature {
         let adaptor = Adaptor::<
             HashTranscript<Sha256, rand_chacha::ChaCha20Rng>,
             Deterministic<Sha256>,
@@ -108,7 +108,7 @@ impl SecretKey {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct PublicKey(Point);
 
 impl PublicKey {
@@ -124,12 +124,12 @@ impl From<PublicKey> for Point {
     }
 }
 
-impl From<PublicKey> for ::bitcoin::PublicKey {
-    fn from(from: PublicKey) -> Self {
-        ::bitcoin::PublicKey {
-            compressed: true,
-            key: from.0.into(),
-        }
+impl TryFrom<PublicKey> for bitcoin::PublicKey {
+    type Error = bitcoin::util::key::Error;
+
+    fn try_from(pubkey: PublicKey) -> Result<Self, Self::Error> {
+        let bytes = pubkey.0.to_bytes();
+        bitcoin::PublicKey::from_slice(&bytes)
     }
 }
 
@@ -166,12 +166,12 @@ impl From<Scalar> for PublicKey {
 
 pub fn verify_sig(
     verification_key: &PublicKey,
-    transaction_sighash: &SigHash,
+    transaction_sighash: &Sighash,
     sig: &Signature,
 ) -> Result<()> {
     let ecdsa = ECDSA::verify_only();
 
-    if ecdsa.verify(&verification_key.0, &transaction_sighash.into_inner(), &sig) {
+    if ecdsa.verify(&verification_key.0, &transaction_sighash.into_inner(), sig) {
         Ok(())
     } else {
         bail!(InvalidSignature)
@@ -185,7 +185,7 @@ pub struct InvalidSignature;
 pub fn verify_encsig(
     verification_key: PublicKey,
     encryption_key: PublicKey,
-    digest: &SigHash,
+    digest: &Sighash,
     encsig: &EncryptedSignature,
 ) -> Result<()> {
     let adaptor = Adaptor::<HashTranscript<Sha256>, Deterministic<Sha256>>::default();
@@ -194,7 +194,7 @@ pub fn verify_encsig(
         &verification_key.0,
         &encryption_key.0,
         &digest.into_inner(),
-        &encsig,
+        encsig,
     ) {
         Ok(())
     } else {
@@ -206,20 +206,21 @@ pub fn verify_encsig(
 #[error("encrypted signature is invalid")]
 pub struct InvalidEncryptedSignature;
 
-pub fn build_shared_output_descriptor(A: Point, B: Point) -> Descriptor<bitcoin::PublicKey> {
+pub fn build_shared_output_descriptor(
+    A: Point,
+    B: Point,
+) -> Result<Descriptor<bitcoin::PublicKey>> {
     const MINISCRIPT_TEMPLATE: &str = "c:and_v(v:pk(A),pk_k(B))";
 
-    // NOTE: This shouldn't be a source of error, but maybe it is
-    let A = ToHex::to_hex(&secp256k1::PublicKey::from(A));
-    let B = ToHex::to_hex(&secp256k1::PublicKey::from(B));
-
-    let miniscript = MINISCRIPT_TEMPLATE.replace("A", &A).replace("B", &B);
+    let miniscript = MINISCRIPT_TEMPLATE
+        .replace('A', &A.to_string())
+        .replace('B', &B.to_string());
 
     let miniscript =
         bdk::miniscript::Miniscript::<bitcoin::PublicKey, Segwitv0>::from_str(&miniscript)
             .expect("a valid miniscript");
 
-    Descriptor::Wsh(Wsh::new(miniscript).expect("a valid descriptor"))
+    Ok(Descriptor::Wsh(Wsh::new(miniscript)?))
 }
 
 pub fn recover(S: PublicKey, sig: Signature, encsig: EncryptedSignature) -> Result<SecretKey> {
@@ -244,10 +245,72 @@ pub fn current_epoch(
     }
 
     if tx_lock_status.is_confirmed_with(cancel_timelock) {
-        return ExpiredTimelocks::Cancel;
+        return ExpiredTimelocks::Cancel {
+            blocks_left: tx_cancel_status.blocks_left_until(punish_timelock),
+        };
+    }
+
+    ExpiredTimelocks::None {
+        blocks_left: tx_lock_status.blocks_left_until(cancel_timelock),
+    }
+}
+
+pub mod bitcoin_address {
+    use anyhow::{bail, Result};
+    use serde::Serialize;
+    use std::str::FromStr;
+
+    #[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Serialize)]
+    #[error("Invalid Bitcoin address provided, expected address on network {expected:?}  but address provided is on {actual:?}")]
+    pub struct BitcoinAddressNetworkMismatch {
+        #[serde(with = "crate::bitcoin::network")]
+        expected: bitcoin::Network,
+        #[serde(with = "crate::bitcoin::network")]
+        actual: bitcoin::Network,
+    }
+
+    pub fn parse(addr_str: &str) -> Result<bitcoin::Address> {
+        let address = bitcoin::Address::from_str(addr_str)?;
+
+        if address.address_type() != Some(bitcoin::AddressType::P2wpkh) {
+            anyhow::bail!("Invalid Bitcoin address provided, only bech32 format is supported!")
+        }
+
+        Ok(address)
     }
 
-    ExpiredTimelocks::None
+    pub fn validate(
+        address: bitcoin::Address,
+        expected_network: bitcoin::Network,
+    ) -> Result<bitcoin::Address> {
+        if address.network != expected_network {
+            bail!(BitcoinAddressNetworkMismatch {
+                expected: expected_network,
+                actual: address.network
+            });
+        }
+
+        Ok(address)
+    }
+
+    pub fn validate_is_testnet(
+        address: bitcoin::Address,
+        is_testnet: bool,
+    ) -> Result<bitcoin::Address> {
+        let expected_network = if is_testnet {
+            bitcoin::Network::Testnet
+        } else {
+            bitcoin::Network::Bitcoin
+        };
+        validate(address, expected_network)
+    }
+}
+
+// Transform the ecdsa der signature bytes into a secp256kfun ecdsa signature type.
+pub fn extract_ecdsa_sig(sig: &[u8]) -> Result<Signature> {
+    let data = &sig[..sig.len() - 1];
+    let sig = ecdsa::Signature::from_der(data)?.serialize_compact();
+    Signature::from_bytes(sig).ok_or(anyhow::anyhow!("invalid signature"))
 }
 
 /// Bitcoin error codes: https://github.com/bitcoin/bitcoin/blob/97d3500601c1d28642347d014a6de1e38f53ae4e/src/rpc/protocol.h#L23
@@ -323,7 +386,10 @@ mod tests {
     use super::*;
     use crate::env::{GetConfig, Regtest};
     use crate::protocol::{alice, bob};
+    use bitcoin::secp256k1;
+    use ecdsa_fun::fun::marker::{NonZero, Public};
     use rand::rngs::OsRng;
+    use std::matches;
     use uuid::Uuid;
 
     #[test]
@@ -338,7 +404,7 @@ mod tests {
             tx_cancel_status,
         );
 
-        assert_eq!(expired_timelock, ExpiredTimelocks::None)
+        assert!(matches!(expired_timelock, ExpiredTimelocks::None { .. }));
     }
 
     #[test]
@@ -353,7 +419,7 @@ mod tests {
             tx_cancel_status,
         );
 
-        assert_eq!(expired_timelock, ExpiredTimelocks::Cancel)
+        assert!(matches!(expired_timelock, ExpiredTimelocks::Cancel { .. }));
     }
 
     #[test]
@@ -373,8 +439,8 @@ mod tests {
 
     #[tokio::test]
     async fn calculate_transaction_weights() {
-        let alice_wallet = WalletBuilder::new(Amount::ONE_BTC.as_sat()).build();
-        let bob_wallet = WalletBuilder::new(Amount::ONE_BTC.as_sat()).build();
+        let alice_wallet = WalletBuilder::new(Amount::ONE_BTC.to_sat()).build();
+        let bob_wallet = WalletBuilder::new(Amount::ONE_BTC.to_sat()).build();
         let spending_fee = Amount::from_sat(1_000);
         let btc_amount = Amount::from_sat(500_000);
         let xmr_amount = crate::monero::Amount::from_piconero(10000);
@@ -457,7 +523,7 @@ mod tests {
     // transactions have 2 signatures the weight can be up to 8 bytes less than
     // the static weight (4 bytes per signature).
     fn assert_weight(transaction: Transaction, expected_weight: usize, tx_name: &str) {
-        let is_weight = transaction.get_weight();
+        let is_weight = transaction.weight();
 
         assert!(
             expected_weight - is_weight <= 8,
@@ -468,4 +534,16 @@ mod tests {
             transaction
         )
     }
+
+    #[test]
+    fn compare_point_hex() {
+        // secp256kfun Point and secp256k1 PublicKey should have the same bytes and hex representation
+        let secp = secp256k1::Secp256k1::default();
+        let keypair = secp256k1::KeyPair::new(&secp, &mut OsRng);
+
+        let pubkey = keypair.public_key();
+        let point: Point<_, Public, NonZero> = Point::from_bytes(pubkey.serialize()).unwrap();
+
+        assert_eq!(pubkey.to_string(), point.to_string());
+    }
 }

swap/src/bitcoin/cancel.rs

@@ -3,10 +3,13 @@ use crate::bitcoin::wallet::Watchable;
 use crate::bitcoin::{
     build_shared_output_descriptor, Address, Amount, BlockHeight, PublicKey, Transaction, TxLock,
 };
-use ::bitcoin::util::bip143::SigHashCache;
-use ::bitcoin::{OutPoint, Script, SigHash, SigHashType, TxIn, TxOut, Txid};
+use ::bitcoin::util::sighash::SighashCache;
+use ::bitcoin::{
+    secp256k1, EcdsaSighashType, OutPoint, PackedLockTime, Script, Sequence, Sighash, TxIn, TxOut,
+    Txid,
+};
 use anyhow::Result;
-use bdk::miniscript::{Descriptor, DescriptorTrait};
+use bdk::miniscript::Descriptor;
 use ecdsa_fun::Signature;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
@@ -22,6 +25,12 @@ use std::ops::Add;
 #[serde(transparent)]
 pub struct CancelTimelock(u32);
 
+impl From<CancelTimelock> for u32 {
+    fn from(cancel_timelock: CancelTimelock) -> Self {
+        cancel_timelock.0
+    }
+}
+
 impl CancelTimelock {
     pub const fn new(number_of_blocks: u32) -> Self {
         Self(number_of_blocks)
@@ -62,6 +71,12 @@ impl fmt::Display for CancelTimelock {
 #[serde(transparent)]
 pub struct PunishTimelock(u32);
 
+impl From<PunishTimelock> for u32 {
+    fn from(punish_timelock: PunishTimelock) -> Self {
+        punish_timelock.0
+    }
+}
+
 impl PunishTimelock {
     pub const fn new(number_of_blocks: u32) -> Self {
         Self(number_of_blocks)
@@ -91,7 +106,7 @@ impl PartialEq<PunishTimelock> for u32 {
 #[derive(Debug)]
 pub struct TxCancel {
     inner: Transaction,
-    digest: SigHash,
+    digest: Sighash,
     pub(in crate::bitcoin) output_descriptor: Descriptor<::bitcoin::PublicKey>,
     lock_output_descriptor: Descriptor<::bitcoin::PublicKey>,
 }
@@ -103,48 +118,50 @@ impl TxCancel {
         A: PublicKey,
         B: PublicKey,
         spending_fee: Amount,
-    ) -> Self {
-        let cancel_output_descriptor = build_shared_output_descriptor(A.0, B.0);
+    ) -> Result<Self> {
+        let cancel_output_descriptor = build_shared_output_descriptor(A.0, B.0)?;
 
         let tx_in = TxIn {
             previous_output: tx_lock.as_outpoint(),
             script_sig: Default::default(),
-            sequence: cancel_timelock.0,
-            witness: Vec::new(),
+            sequence: Sequence(cancel_timelock.0),
+            witness: Default::default(),
         };
 
         let tx_out = TxOut {
-            value: tx_lock.lock_amount().as_sat() - spending_fee.as_sat(),
+            value: tx_lock.lock_amount().to_sat() - spending_fee.to_sat(),
             script_pubkey: cancel_output_descriptor.script_pubkey(),
         };
 
         let transaction = Transaction {
             version: 2,
-            lock_time: 0,
+            lock_time: PackedLockTime(0),
             input: vec![tx_in],
             output: vec![tx_out],
         };
 
-        let digest = SigHashCache::new(&transaction).signature_hash(
-            0, // Only one input: lock_input (lock transaction)
-            &tx_lock.output_descriptor.script_code(),
-            tx_lock.lock_amount().as_sat(),
-            SigHashType::All,
-        );
+        let digest = SighashCache::new(&transaction)
+            .segwit_signature_hash(
+                0, // Only one input: lock_input (lock transaction)
+                &tx_lock.output_descriptor.script_code().expect("scriptcode"),
+                tx_lock.lock_amount().to_sat(),
+                EcdsaSighashType::All,
+            )
+            .expect("sighash");
 
-        Self {
+        Ok(Self {
             inner: transaction,
             digest,
             output_descriptor: cancel_output_descriptor,
             lock_output_descriptor: tx_lock.output_descriptor.clone(),
-        }
+        })
     }
 
     pub fn txid(&self) -> Txid {
         self.inner.txid()
     }
 
-    pub fn digest(&self) -> SigHash {
+    pub fn digest(&self) -> Sighash {
         self.digest
     }
 
@@ -198,16 +215,30 @@ impl TxCancel {
 
             let A = ::bitcoin::PublicKey {
                 compressed: true,
-                key: A.0.into(),
+                inner: secp256k1::PublicKey::from_slice(&A.0.to_bytes())?,
             };
             let B = ::bitcoin::PublicKey {
                 compressed: true,
-                key: B.0.into(),
+                inner: secp256k1::PublicKey::from_slice(&B.0.to_bytes())?,
             };
 
             // The order in which these are inserted doesn't matter
-            satisfier.insert(A, (sig_a.into(), ::bitcoin::SigHashType::All));
-            satisfier.insert(B, (sig_b.into(), ::bitcoin::SigHashType::All));
+            let sig_a = secp256k1::ecdsa::Signature::from_compact(&sig_a.to_bytes())?;
+            let sig_b = secp256k1::ecdsa::Signature::from_compact(&sig_b.to_bytes())?;
+            satisfier.insert(
+                A,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_a,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
+            satisfier.insert(
+                B,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_b,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
 
             satisfier
         };
@@ -227,21 +258,22 @@ impl TxCancel {
     ) -> Transaction {
         let previous_output = self.as_outpoint();
 
+        let sequence = Sequence(sequence.map(|seq| seq.0).unwrap_or(0xFFFF_FFFF));
         let tx_in = TxIn {
             previous_output,
             script_sig: Default::default(),
-            sequence: sequence.map(|seq| seq.0).unwrap_or(0xFFFF_FFFF),
-            witness: Vec::new(),
+            sequence,
+            witness: Default::default(),
         };
 
         let tx_out = TxOut {
-            value: self.amount().as_sat() - spending_fee.as_sat(),
+            value: self.amount().to_sat() - spending_fee.to_sat(),
             script_pubkey: spend_address.script_pubkey(),
         };
 
         Transaction {
             version: 2,
-            lock_time: 0,
+            lock_time: PackedLockTime(0),
             input: vec![tx_in],
             output: vec![tx_out],
         }

swap/src/bitcoin/lock.rs

@@ -4,23 +4,25 @@ use crate::bitcoin::{
 };
 use ::bitcoin::util::psbt::PartiallySignedTransaction;
 use ::bitcoin::{OutPoint, TxIn, TxOut, Txid};
-use anyhow::{bail, Result};
+use anyhow::{bail, Context, Result};
 use bdk::database::BatchDatabase;
-use bdk::miniscript::{Descriptor, DescriptorTrait};
-use bitcoin::Script;
+use bdk::miniscript::Descriptor;
+use bdk::psbt::PsbtUtils;
+use bitcoin::{PackedLockTime, Script, Sequence};
 use serde::{Deserialize, Serialize};
 
 const SCRIPT_SIZE: usize = 34;
+const TX_LOCK_WEIGHT: usize = 485;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct TxLock {
     inner: PartiallySignedTransaction,
     pub(in crate::bitcoin) output_descriptor: Descriptor<::bitcoin::PublicKey>,
 }
 
 impl TxLock {
-    pub async fn new<B, D, C>(
-        wallet: &Wallet<B, D, C>,
+    pub async fn new<D, C>(
+        wallet: &Wallet<D, C>,
         amount: Amount,
         A: PublicKey,
         B: PublicKey,
@@ -30,7 +32,7 @@ impl TxLock {
         C: EstimateFeeRate,
         D: BatchDatabase,
     {
-        let lock_output_descriptor = build_shared_output_descriptor(A.0, B.0);
+        let lock_output_descriptor = build_shared_output_descriptor(A.0, B.0)?;
         let address = lock_output_descriptor
             .address(wallet.get_network())
             .expect("can derive address from descriptor");
@@ -56,15 +58,15 @@ impl TxLock {
         B: PublicKey,
         btc: Amount,
     ) -> Result<Self> {
-        let shared_output_candidate = match psbt.global.unsigned_tx.output.as_slice() {
-            [shared_output_candidate, _] if shared_output_candidate.value == btc.as_sat() => {
+        let shared_output_candidate = match psbt.unsigned_tx.output.as_slice() {
+            [shared_output_candidate, _] if shared_output_candidate.value == btc.to_sat() => {
                 shared_output_candidate
             }
-            [_, shared_output_candidate] if shared_output_candidate.value == btc.as_sat() => {
+            [_, shared_output_candidate] if shared_output_candidate.value == btc.to_sat() => {
                 shared_output_candidate
             }
             // A single output is possible if Bob funds without any change necessary
-            [shared_output_candidate] if shared_output_candidate.value == btc.as_sat() => {
+            [shared_output_candidate] if shared_output_candidate.value == btc.to_sat() => {
                 shared_output_candidate
             }
             [_, _] => {
@@ -82,7 +84,7 @@ impl TxLock {
             }
         };
 
-        let descriptor = build_shared_output_descriptor(A.0, B.0);
+        let descriptor = build_shared_output_descriptor(A.0, B.0)?;
         let legit_shared_output_script = descriptor.script_pubkey();
 
         if shared_output_candidate.script_pubkey != legit_shared_output_script {
@@ -99,6 +101,15 @@ impl TxLock {
         Amount::from_sat(self.inner.clone().extract_tx().output[self.lock_output_vout()].value)
     }
 
+    pub fn fee(&self) -> Result<Amount> {
+        Ok(Amount::from_sat(
+            self.inner
+                .clone()
+                .fee_amount()
+                .context("The PSBT is missing a TxOut for an input")?,
+        ))
+    }
+
     pub fn txid(&self) -> Txid {
         self.inner.clone().extract_tx().txid()
     }
@@ -139,14 +150,15 @@ impl TxLock {
     ) -> Transaction {
         let previous_output = self.as_outpoint();
 
+        let sequence = Sequence(sequence.unwrap_or(0xFFFF_FFFF));
         let tx_in = TxIn {
             previous_output,
             script_sig: Default::default(),
-            sequence: sequence.unwrap_or(0xFFFF_FFFF),
-            witness: Vec::new(),
+            sequence,
+            witness: Default::default(),
         };
 
-        let fee = spending_fee.as_sat();
+        let fee = spending_fee.to_sat();
         let tx_out = TxOut {
             value: self.inner.clone().extract_tx().output[self.lock_output_vout()].value - fee,
             script_pubkey: spend_address.script_pubkey(),
@@ -156,11 +168,15 @@ impl TxLock {
 
         Transaction {
             version: 2,
-            lock_time: 0,
+            lock_time: PackedLockTime(0),
             input: vec![tx_in],
             output: vec![tx_out],
         }
     }
+
+    pub fn weight() -> usize {
+        TX_LOCK_WEIGHT
+    }
 }
 
 impl From<TxLock> for PartiallySignedTransaction {
@@ -200,13 +216,14 @@ mod tests {
     #[tokio::test]
     async fn bob_can_fund_without_a_change_output() {
         let (A, B) = alice_and_bob();
-        let fees = 610;
+        let fees = 300;
         let agreed_amount = Amount::from_sat(10000);
-        let wallet = WalletBuilder::new(agreed_amount.as_sat() + fees).build();
+        let amount = agreed_amount.to_sat() + fees;
+        let wallet = WalletBuilder::new(amount).build();
 
         let psbt = bob_make_psbt(A, B, &wallet, agreed_amount).await;
         assert_eq!(
-            psbt.global.unsigned_tx.output.len(),
+            psbt.unsigned_tx.output.len(),
             1,
             "psbt should only have a single output"
         );
@@ -246,7 +263,7 @@ mod tests {
         fn estimated_tx_lock_script_size_never_changes(a in crate::proptest::ecdsa_fun::point(), b in crate::proptest::ecdsa_fun::point()) {
             proptest::prop_assume!(a != b);
 
-            let computed_size = build_shared_output_descriptor(a, b).script_pubkey().len();
+            let computed_size = build_shared_output_descriptor(a, b).unwrap().script_pubkey().len();
 
             assert_eq!(computed_size, SCRIPT_SIZE);
         }
@@ -258,11 +275,11 @@ mod tests {
     async fn bob_make_psbt(
         A: PublicKey,
         B: PublicKey,
-        wallet: &Wallet<(), bdk::database::MemoryDatabase, StaticFeeRate>,
+        wallet: &Wallet<bdk::database::MemoryDatabase, StaticFeeRate>,
         amount: Amount,
     ) -> PartiallySignedTransaction {
         let change = wallet.new_address().await.unwrap();
-        TxLock::new(&wallet, amount, A, B, change)
+        TxLock::new(wallet, amount, A, B, change)
             .await
             .unwrap()
             .into()

swap/src/bitcoin/punish.rs

@@ -1,16 +1,16 @@
 use crate::bitcoin::wallet::Watchable;
 use crate::bitcoin::{self, Address, Amount, PunishTimelock, Transaction, TxCancel, Txid};
-use ::bitcoin::util::bip143::SigHashCache;
-use ::bitcoin::{SigHash, SigHashType};
+use ::bitcoin::util::sighash::SighashCache;
+use ::bitcoin::{secp256k1, EcdsaSighashType, Sighash};
 use anyhow::{Context, Result};
 use bdk::bitcoin::Script;
-use bdk::miniscript::{Descriptor, DescriptorTrait};
+use bdk::miniscript::Descriptor;
 use std::collections::HashMap;
 
 #[derive(Debug)]
 pub struct TxPunish {
     inner: Transaction,
-    digest: SigHash,
+    digest: Sighash,
     cancel_output_descriptor: Descriptor<::bitcoin::PublicKey>,
     watch_script: Script,
 }
@@ -25,12 +25,17 @@ impl TxPunish {
         let tx_punish =
             tx_cancel.build_spend_transaction(punish_address, Some(punish_timelock), spending_fee);
 
-        let digest = SigHashCache::new(&tx_punish).signature_hash(
-            0, // Only one input: cancel transaction
-            &tx_cancel.output_descriptor.script_code(),
-            tx_cancel.amount().as_sat(),
-            SigHashType::All,
-        );
+        let digest = SighashCache::new(&tx_punish)
+            .segwit_signature_hash(
+                0, // Only one input: cancel transaction
+                &tx_cancel
+                    .output_descriptor
+                    .script_code()
+                    .expect("scriptcode"),
+                tx_cancel.amount().to_sat(),
+                EcdsaSighashType::All,
+            )
+            .expect("sighash");
 
         Self {
             inner: tx_punish,
@@ -40,7 +45,7 @@ impl TxPunish {
         }
     }
 
-    pub fn digest(&self) -> SigHash {
+    pub fn digest(&self) -> Sighash {
         self.digest
     }
 
@@ -56,12 +61,26 @@ impl TxPunish {
         let satisfier = {
             let mut satisfier = HashMap::with_capacity(2);
 
-            let A = a.public().into();
-            let B = B.into();
+            let A = a.public().try_into()?;
+            let B = B.try_into()?;
 
+            let sig_a = secp256k1::ecdsa::Signature::from_compact(&sig_a.to_bytes())?;
+            let sig_b = secp256k1::ecdsa::Signature::from_compact(&sig_b.to_bytes())?;
             // The order in which these are inserted doesn't matter
-            satisfier.insert(A, (sig_a.into(), ::bitcoin::SigHashType::All));
-            satisfier.insert(B, (sig_b.into(), ::bitcoin::SigHashType::All));
+            satisfier.insert(
+                A,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_a,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
+            satisfier.insert(
+                B,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_b,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
 
             satisfier
         };

swap/src/bitcoin/redeem.rs

@@ -3,11 +3,12 @@ use crate::bitcoin::{
     verify_encsig, verify_sig, Address, Amount, EmptyWitnessStack, EncryptedSignature, NoInputs,
     NotThreeWitnesses, PublicKey, SecretKey, TooManyInputs, Transaction, TxLock,
 };
-use ::bitcoin::util::bip143::SigHashCache;
-use ::bitcoin::{SigHash, SigHashType, Txid};
+use ::bitcoin::{Sighash, Txid};
 use anyhow::{bail, Context, Result};
-use bdk::miniscript::{Descriptor, DescriptorTrait};
-use bitcoin::Script;
+use bdk::miniscript::Descriptor;
+use bitcoin::secp256k1;
+use bitcoin::util::sighash::SighashCache;
+use bitcoin::{EcdsaSighashType, Script};
 use ecdsa_fun::adaptor::{Adaptor, HashTranscript};
 use ecdsa_fun::fun::Scalar;
 use ecdsa_fun::nonce::Deterministic;
@@ -15,10 +16,12 @@ use ecdsa_fun::Signature;
 use sha2::Sha256;
 use std::collections::HashMap;
 
+use super::extract_ecdsa_sig;
+
 #[derive(Clone, Debug)]
 pub struct TxRedeem {
     inner: Transaction,
-    digest: SigHash,
+    digest: Sighash,
     lock_output_descriptor: Descriptor<::bitcoin::PublicKey>,
     watch_script: Script,
 }
@@ -29,12 +32,14 @@ impl TxRedeem {
         // redeem transaction
         let tx_redeem = tx_lock.build_spend_transaction(redeem_address, None, spending_fee);
 
-        let digest = SigHashCache::new(&tx_redeem).signature_hash(
-            0, // Only one input: lock_input (lock transaction)
-            &tx_lock.output_descriptor.script_code(),
-            tx_lock.lock_amount().as_sat(),
-            SigHashType::All,
-        );
+        let digest = SighashCache::new(&tx_redeem)
+            .segwit_signature_hash(
+                0, // Only one input: lock_input (lock transaction)
+                &tx_lock.output_descriptor.script_code().expect("scriptcode"),
+                tx_lock.lock_amount().to_sat(),
+                EcdsaSighashType::All,
+            )
+            .expect("sighash");
 
         Self {
             inner: tx_redeem,
@@ -48,7 +53,7 @@ impl TxRedeem {
         self.inner.txid()
     }
 
-    pub fn digest(&self) -> SigHash {
+    pub fn digest(&self) -> Sighash {
         self.digest
     }
 
@@ -61,7 +66,7 @@ impl TxRedeem {
     ) -> Result<Transaction> {
         verify_encsig(
             B,
-            PublicKey::from(s_a.clone()),
+            PublicKey::from(s_a),
             &self.digest(),
             &encrypted_signature,
         )
@@ -76,16 +81,30 @@ impl TxRedeem {
 
             let A = ::bitcoin::PublicKey {
                 compressed: true,
-                key: a.public.into(),
+                inner: secp256k1::PublicKey::from_slice(&a.public.to_bytes())?,
             };
             let B = ::bitcoin::PublicKey {
                 compressed: true,
-                key: B.0.into(),
+                inner: secp256k1::PublicKey::from_slice(&B.0.to_bytes())?,
             };
 
+            let sig_a = secp256k1::ecdsa::Signature::from_compact(&sig_a.to_bytes())?;
+            let sig_b = secp256k1::ecdsa::Signature::from_compact(&sig_b.to_bytes())?;
             // The order in which these are inserted doesn't matter
-            satisfier.insert(A, (sig_a.into(), ::bitcoin::SigHashType::All));
-            satisfier.insert(B, (sig_b.into(), ::bitcoin::SigHashType::All));
+            satisfier.insert(
+                A,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_a,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
+            satisfier.insert(
+                B,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_b,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
 
             satisfier
         };
@@ -105,30 +124,21 @@ impl TxRedeem {
         let input = match candidate_transaction.input.as_slice() {
             [input] => input,
             [] => bail!(NoInputs),
-            [inputs @ ..] => bail!(TooManyInputs(inputs.len())),
+            inputs => bail!(TooManyInputs(inputs.len())),
         };
 
-        let sigs = match input
-            .witness
-            .iter()
-            .map(|vec| vec.as_slice())
-            .collect::<Vec<_>>()
-            .as_slice()
-        {
+        let sigs = match input.witness.to_vec().as_slice() {
             [sig_1, sig_2, _script] => [sig_1, sig_2]
-                .iter()
-                .map(|sig| {
-                    bitcoin::secp256k1::Signature::from_der(&sig[..sig.len() - 1])
-                        .map(Signature::from)
-                })
-                .collect::<std::result::Result<Vec<_>, _>>(),
+                .into_iter()
+                .map(|sig| extract_ecdsa_sig(sig))
+                .collect::<Result<Vec<_>, _>>(),
             [] => bail!(EmptyWitnessStack),
-            [witnesses @ ..] => bail!(NotThreeWitnesses(witnesses.len())),
+            witnesses => bail!(NotThreeWitnesses(witnesses.len())),
         }?;
 
         let sig = sigs
             .into_iter()
-            .find(|sig| verify_sig(&B, &self.digest(), &sig).is_ok())
+            .find(|sig| verify_sig(&B, &self.digest(), sig).is_ok())
             .context("Neither signature on witness stack verifies against B")?;
 
         Ok(sig)

swap/src/bitcoin/refund.rs

@@ -4,17 +4,20 @@ use crate::bitcoin::{
     TooManyInputs, Transaction, TxCancel,
 };
 use crate::{bitcoin, monero};
-use ::bitcoin::util::bip143::SigHashCache;
-use ::bitcoin::{Script, SigHash, SigHashType, Txid};
+use ::bitcoin::secp256k1;
+use ::bitcoin::util::sighash::SighashCache;
+use ::bitcoin::{EcdsaSighashType, Script, Sighash, Txid};
 use anyhow::{bail, Context, Result};
-use bdk::miniscript::{Descriptor, DescriptorTrait};
+use bdk::miniscript::Descriptor;
 use ecdsa_fun::Signature;
 use std::collections::HashMap;
 
+use super::extract_ecdsa_sig;
+
 #[derive(Debug)]
 pub struct TxRefund {
     inner: Transaction,
-    digest: SigHash,
+    digest: Sighash,
     cancel_output_descriptor: Descriptor<::bitcoin::PublicKey>,
     watch_script: Script,
 }
@@ -23,12 +26,17 @@ impl TxRefund {
     pub fn new(tx_cancel: &TxCancel, refund_address: &Address, spending_fee: Amount) -> Self {
         let tx_refund = tx_cancel.build_spend_transaction(refund_address, None, spending_fee);
 
-        let digest = SigHashCache::new(&tx_refund).signature_hash(
-            0, // Only one input: cancel transaction
-            &tx_cancel.output_descriptor.script_code(),
-            tx_cancel.amount().as_sat(),
-            SigHashType::All,
-        );
+        let digest = SighashCache::new(&tx_refund)
+            .segwit_signature_hash(
+                0, // Only one input: cancel transaction
+                &tx_cancel
+                    .output_descriptor
+                    .script_code()
+                    .expect("scriptcode"),
+                tx_cancel.amount().to_sat(),
+                EcdsaSighashType::All,
+            )
+            .expect("sighash");
 
         Self {
             inner: tx_refund,
@@ -42,7 +50,7 @@ impl TxRefund {
         self.inner.txid()
     }
 
-    pub fn digest(&self) -> SigHash {
+    pub fn digest(&self) -> Sighash {
         self.digest
     }
 
@@ -56,16 +64,30 @@ impl TxRefund {
 
             let A = ::bitcoin::PublicKey {
                 compressed: true,
-                key: A.0.into(),
+                inner: secp256k1::PublicKey::from_slice(&A.0.to_bytes())?,
             };
             let B = ::bitcoin::PublicKey {
                 compressed: true,
-                key: B.0.into(),
+                inner: secp256k1::PublicKey::from_slice(&B.0.to_bytes())?,
             };
 
+            let sig_a = secp256k1::ecdsa::Signature::from_compact(&sig_a.to_bytes())?;
+            let sig_b = secp256k1::ecdsa::Signature::from_compact(&sig_b.to_bytes())?;
             // The order in which these are inserted doesn't matter
-            satisfier.insert(A, (sig_a.into(), ::bitcoin::SigHashType::All));
-            satisfier.insert(B, (sig_b.into(), ::bitcoin::SigHashType::All));
+            satisfier.insert(
+                A,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_a,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
+            satisfier.insert(
+                B,
+                ::bitcoin::EcdsaSig {
+                    sig: sig_b,
+                    hash_ty: EcdsaSighashType::All,
+                },
+            );
 
             satisfier
         };
@@ -109,30 +131,21 @@ impl TxRefund {
         let input = match candidate_transaction.input.as_slice() {
             [input] => input,
             [] => bail!(NoInputs),
-            [inputs @ ..] => bail!(TooManyInputs(inputs.len())),
+            inputs => bail!(TooManyInputs(inputs.len())),
         };
 
-        let sigs = match input
-            .witness
-            .iter()
-            .map(|vec| vec.as_slice())
-            .collect::<Vec<_>>()
-            .as_slice()
-        {
+        let sigs = match input.witness.to_vec().as_slice() {
             [sig_1, sig_2, _script] => [sig_1, sig_2]
-                .iter()
-                .map(|sig| {
-                    bitcoin::secp256k1::Signature::from_der(&sig[..sig.len() - 1])
-                        .map(Signature::from)
-                })
-                .collect::<std::result::Result<Vec<_>, _>>(),
+                .into_iter()
+                .map(|sig| extract_ecdsa_sig(sig))
+                .collect::<Result<Vec<_>, _>>(),
             [] => bail!(EmptyWitnessStack),
-            [witnesses @ ..] => bail!(NotThreeWitnesses(witnesses.len())),
+            witnesses => bail!(NotThreeWitnesses(witnesses.len())),
         }?;
 
         let sig = sigs
             .into_iter()
-            .find(|sig| verify_sig(&B, &self.digest(), &sig).is_ok())
+            .find(|sig| verify_sig(&B, &self.digest(), sig).is_ok())
             .context("Neither signature on witness stack verifies against B")?;
 
         Ok(sig)

swap/src/bitcoin/timelocks.rs

@@ -37,9 +37,9 @@ impl Add<u32> for BlockHeight {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ExpiredTimelocks {
-    None,
-    Cancel,
+    None { blocks_left: u32 },
+    Cancel { blocks_left: u32 },
     Punish,
 }

swap/src/bitcoin/wallet.rs

@@ -4,14 +4,14 @@ use crate::env;
 use ::bitcoin::util::psbt::PartiallySignedTransaction;
 use ::bitcoin::Txid;
 use anyhow::{bail, Context, Result};
-use bdk::blockchain::{noop_progress, Blockchain, ElectrumBlockchain};
+use bdk::blockchain::{Blockchain, ElectrumBlockchain, GetTx};
 use bdk::database::BatchDatabase;
-use bdk::descriptor::Segwitv0;
 use bdk::electrum_client::{ElectrumApi, GetHistoryRes};
-use bdk::keys::DerivableKey;
-use bdk::wallet::export::WalletExport;
+use bdk::sled::Tree;
+use bdk::wallet::export::FullyNodedExport;
 use bdk::wallet::AddressIndex;
-use bdk::{FeeRate, KeychainKind, SignOptions};
+use bdk::{FeeRate, KeychainKind, SignOptions, SyncOptions};
+use bitcoin::util::bip32::ExtendedPrivKey;
 use bitcoin::{Network, Script};
 use reqwest::Url;
 use rust_decimal::prelude::*;
@@ -24,6 +24,7 @@ use std::path::Path;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::{watch, Mutex};
+use tracing::{debug_span, Instrument};
 
 const SLED_TREE_NAME: &str = "default_tree";
 
@@ -33,9 +34,12 @@ const MAX_RELATIVE_TX_FEE: Decimal = dec!(0.03);
 const MAX_ABSOLUTE_TX_FEE: Decimal = dec!(100_000);
 const DUST_AMOUNT: u64 = 546;
 
-pub struct Wallet<B = ElectrumBlockchain, D = bdk::sled::Tree, C = Client> {
+const WALLET: &str = "wallet";
+const WALLET_OLD: &str = "wallet-old";
+
+pub struct Wallet<D = Tree, C = Client> {
     client: Arc<Mutex<C>>,
-    wallet: Arc<Mutex<bdk::Wallet<B, D>>>,
+    wallet: Arc<Mutex<bdk::Wallet<D>>>,
     finality_confirmations: u32,
     network: Network,
     target_block: usize,
@@ -44,37 +48,33 @@ pub struct Wallet<B = ElectrumBlockchain, D = bdk::sled::Tree, C = Client> {
 impl Wallet {
     pub async fn new(
         electrum_rpc_url: Url,
-        wallet_dir: &Path,
-        key: impl DerivableKey<Segwitv0> + Clone,
+        data_dir: impl AsRef<Path>,
+        xprivkey: ExtendedPrivKey,
         env_config: env::Config,
         target_block: usize,
     ) -> Result<Self> {
-        let config = bdk::electrum_client::ConfigBuilder::default()
-            .retry(5)
-            .build();
-        let client = bdk::electrum_client::Client::from_config(electrum_rpc_url.as_str(), config)
-            .context("Failed to initialize Electrum RPC client")?;
-
-        let db = bdk::sled::open(wallet_dir)?.open_tree(SLED_TREE_NAME)?;
-
-        let wallet = bdk::Wallet::new(
-            bdk::template::Bip84(key.clone(), KeychainKind::External),
-            Some(bdk::template::Bip84(key, KeychainKind::Internal)),
-            env_config.bitcoin_network,
-            db,
-            ElectrumBlockchain::from(client),
-        )?;
+        let data_dir = data_dir.as_ref();
+        let wallet_dir = data_dir.join(WALLET);
+        let database = bdk::sled::open(wallet_dir)?.open_tree(SLED_TREE_NAME)?;
+        let network = env_config.bitcoin_network;
+
+        let wallet = match bdk::Wallet::new(
+            bdk::template::Bip84(xprivkey, KeychainKind::External),
+            Some(bdk::template::Bip84(xprivkey, KeychainKind::Internal)),
+            network,
+            database,
+        ) {
+            Ok(w) => w,
+            Err(bdk::Error::ChecksumMismatch) => Self::migrate(data_dir, xprivkey, network)?,
+            err => err?,
+        };
 
-        let electrum = bdk::electrum_client::Client::new(electrum_rpc_url.as_str())
-            .context("Failed to initialize Electrum RPC client")?;
+        let client = Client::new(electrum_rpc_url, env_config.bitcoin_sync_interval())?;
 
         let network = wallet.network();
 
         Ok(Self {
-            client: Arc::new(Mutex::new(Client::new(
-                electrum,
-                env_config.bitcoin_sync_interval(),
-            )?)),
+            client: Arc::new(Mutex::new(client)),
             wallet: Arc::new(Mutex::new(wallet)),
             finality_confirmations: env_config.bitcoin_finality_confirmations,
             network,
@@ -82,6 +82,32 @@ impl Wallet {
         })
     }
 
+    /// Create a new database for the wallet and rename the old one.
+    /// This is necessary when getting a ChecksumMismatch from a wallet
+    /// created with an older version of BDK. Only affected Testnet wallets.
+    // https://github.com/comit-network/xmr-btc-swap/issues/1182
+    fn migrate(
+        data_dir: &Path,
+        xprivkey: ExtendedPrivKey,
+        network: bitcoin::Network,
+    ) -> Result<bdk::Wallet<Tree>> {
+        let from = data_dir.join(WALLET);
+        let to = data_dir.join(WALLET_OLD);
+        std::fs::rename(from, to)?;
+
+        let wallet_dir = data_dir.join(WALLET);
+        let database = bdk::sled::open(wallet_dir)?.open_tree(SLED_TREE_NAME)?;
+
+        let wallet = bdk::Wallet::new(
+            bdk::template::Bip84(xprivkey, KeychainKind::External),
+            Some(bdk::template::Bip84(xprivkey, KeychainKind::Internal)),
+            network,
+            database,
+        )?;
+
+        Ok(wallet)
+    }
+
     /// Broadcast the given transaction to the network and emit a log statement
     /// if done so successfully.
     ///
@@ -99,13 +125,12 @@ impl Wallet {
             .subscribe_to((txid, transaction.output[0].script_pubkey.clone()))
             .await;
 
-        self.wallet
-            .lock()
-            .await
-            .broadcast(transaction)
-            .with_context(|| {
-                format!("Failed to broadcast Bitcoin {} transaction {}", kind, txid)
-            })?;
+        let client = self.client.lock().await;
+        let blockchain = client.blockchain();
+
+        blockchain.broadcast(&transaction).with_context(|| {
+            format!("Failed to broadcast Bitcoin {} transaction {}", kind, txid)
+        })?;
 
         tracing::info!(%txid, %kind, "Published Bitcoin transaction");
 
@@ -143,8 +168,6 @@ impl Wallet {
                     let mut last_status = None;
 
                     loop {
-                        tokio::time::sleep(Duration::from_secs(5)).await;
-
                         let new_status = match client.lock().await.status_of_script(&tx) {
                             Ok(new_status) => new_status,
                             Err(error) => {
@@ -152,21 +175,23 @@ impl Wallet {
                                 ScriptStatus::Retrying
                             }
                         };
-                        
+
                         if new_status != ScriptStatus::Retrying
                         {
                             last_status = Some(print_status_change(txid, last_status, new_status));
 
                             let all_receivers_gone = sender.send(new_status).is_err();
-    
+
                             if all_receivers_gone {
                                 tracing::debug!(%txid, "All receivers gone, removing subscription");
                                 client.lock().await.subscriptions.remove(&(txid, script));
                                 return;
                             }
                         }
+
+                        tokio::time::sleep(Duration::from_secs(5)).await;
                     }
-                });
+                }.instrument(debug_span!("BitcoinWalletSubscription")));
 
                 Subscription {
                     receiver,
@@ -179,9 +204,9 @@ impl Wallet {
         sub
     }
 
-    pub async fn wallet_export(&self, role: &str) -> Result<WalletExport> {
+    pub async fn wallet_export(&self, role: &str) -> Result<FullyNodedExport> {
         let wallet = self.wallet.lock().await;
-        match bdk::wallet::export::WalletExport::export_wallet(
+        match bdk::wallet::export::FullyNodedExport::export_wallet(
             &wallet,
             &format!("{}-{}", role, self.network),
             true,
@@ -248,7 +273,7 @@ impl Subscription {
 
     pub async fn wait_until_confirmed_with<T>(&self, target: T) -> Result<()>
     where
-        u32: PartialOrd<T>,
+        T: Into<u32>,
         T: Copy,
     {
         self.wait_until(|status| status.is_confirmed_with(target))
@@ -269,7 +294,7 @@ impl Subscription {
     }
 }
 
-impl<B, D, C> Wallet<B, D, C>
+impl<D, C> Wallet<D, C>
 where
     C: EstimateFeeRate,
     D: BatchDatabase,
@@ -293,6 +318,7 @@ where
         Ok(tx)
     }
 
+    /// Returns the total Bitcoin balance, which includes pending funds
     pub async fn balance(&self) -> Result<Amount> {
         let balance = self
             .wallet
@@ -301,7 +327,7 @@ where
             .get_balance()
             .context("Failed to calculate Bitcoin balance")?;
 
-        Ok(Amount::from_sat(balance))
+        Ok(Amount::from_sat(balance.get_total()))
     }
 
     pub async fn new_address(&self) -> Result<Address> {
@@ -357,16 +383,16 @@ where
         let script = address.script_pubkey();
 
         let mut tx_builder = wallet.build_tx();
-        tx_builder.add_recipient(script.clone(), amount.as_sat());
+        tx_builder.add_recipient(script.clone(), amount.to_sat());
         tx_builder.fee_rate(fee_rate);
         let (psbt, _details) = tx_builder.finish()?;
         let mut psbt: PartiallySignedTransaction = psbt;
 
-        match psbt.global.unsigned_tx.output.as_mut_slice() {
+        match psbt.unsigned_tx.output.as_mut_slice() {
             // our primary output is the 2nd one? reverse the vectors
             [_, second_txout] if second_txout.script_pubkey == script => {
                 psbt.outputs.reverse();
-                psbt.global.unsigned_tx.output.reverse();
+                psbt.unsigned_tx.output.reverse();
             }
             [first_txout, _] if first_txout.script_pubkey == script => {
                 // no need to do anything
@@ -378,7 +404,7 @@ where
         }
 
         if let ([_, change], [_, psbt_output], Some(change_override)) = (
-            &mut psbt.global.unsigned_tx.output.as_mut_slice(),
+            &mut psbt.unsigned_tx.output.as_mut_slice(),
             &mut psbt.outputs.as_mut_slice(),
             change_override,
         ) {
@@ -399,13 +425,13 @@ where
     pub async fn max_giveable(&self, locking_script_size: usize) -> Result<Amount> {
         let wallet = self.wallet.lock().await;
         let balance = wallet.get_balance()?;
-        if balance < DUST_AMOUNT {
+        if balance.get_total() < DUST_AMOUNT {
             return Ok(Amount::ZERO);
         }
         let client = self.client.lock().await;
-        let min_relay_fee = client.min_relay_fee()?.as_sat();
+        let min_relay_fee = client.min_relay_fee()?.to_sat();
 
-        if balance < min_relay_fee {
+        if balance.get_total() < min_relay_fee {
             return Ok(Amount::ZERO);
         }
 
@@ -454,18 +480,18 @@ fn estimate_fee(
     fee_rate: FeeRate,
     min_relay_fee: Amount,
 ) -> Result<Amount> {
-    if transfer_amount.as_sat() <= 546 {
+    if transfer_amount.to_sat() <= 546 {
         bail!("Amounts needs to be greater than Bitcoin dust amount.")
     }
-    let fee_rate_svb = fee_rate.as_sat_vb();
+    let fee_rate_svb = fee_rate.as_sat_per_vb();
     if fee_rate_svb <= 0.0 {
         bail!("Fee rate needs to be > 0")
     }
-    if fee_rate_svb > 100_000_000.0 || min_relay_fee.as_sat() > 100_000_000 {
+    if fee_rate_svb > 100_000_000.0 || min_relay_fee.to_sat() > 100_000_000 {
         bail!("A fee_rate or min_relay_fee of > 1BTC does not make sense")
     }
 
-    let min_relay_fee = if min_relay_fee.as_sat() == 0 {
+    let min_relay_fee = if min_relay_fee.to_sat() == 0 {
         // if min_relay_fee is 0 we don't fail, we just set it to 1 satoshi;
         Amount::ONE_SAT
     } else {
@@ -485,9 +511,9 @@ fn estimate_fee(
         "Estimated fee for transaction",
     );
 
-    let transfer_amount = Decimal::from(transfer_amount.as_sat());
+    let transfer_amount = Decimal::from(transfer_amount.to_sat());
     let max_allowed_fee = transfer_amount * MAX_RELATIVE_TX_FEE;
-    let min_relay_fee = Decimal::from(min_relay_fee.as_sat());
+    let min_relay_fee = Decimal::from(min_relay_fee.to_sat());
 
     let recommended_fee = if sats_per_vbyte < min_relay_fee {
         tracing::warn!(
@@ -518,29 +544,32 @@ fn estimate_fee(
     Ok(amount)
 }
 
-impl<B, D, C> Wallet<B, D, C>
+impl<D> Wallet<D>
 where
-    B: Blockchain,
     D: BatchDatabase,
 {
     pub async fn get_tx(&self, txid: Txid) -> Result<Option<Transaction>> {
-        let tx = self.wallet.lock().await.client().get_tx(&txid)?;
+        let client = self.client.lock().await;
+        let tx = client.get_tx(&txid)?;
 
         Ok(tx)
     }
 
     pub async fn sync(&self) -> Result<()> {
+        let client = self.client.lock().await;
+        let blockchain = client.blockchain();
+        let sync_opts = SyncOptions::default();
         self.wallet
             .lock()
             .await
-            .sync(noop_progress(), None)
+            .sync(blockchain, sync_opts)
             .context("Failed to sync balance of Bitcoin wallet")?;
 
         Ok(())
     }
 }
 
-impl<B, D, C> Wallet<B, D, C> {
+impl<D, C> Wallet<D, C> {
     // TODO: Get rid of this by changing bounds on bdk::Wallet
     pub fn get_network(&self) -> bitcoin::Network {
         self.network
@@ -570,6 +599,7 @@ impl EstimateFeeRate for StaticFeeRate {
 }
 
 #[cfg(test)]
+#[derive(Debug)]
 pub struct WalletBuilder {
     utxo_amount: u64,
     sats_per_vb: f32,
@@ -621,9 +651,9 @@ impl WalletBuilder {
         }
     }
 
-    pub fn build(self) -> Wallet<(), bdk::database::MemoryDatabase, StaticFeeRate> {
-        use bdk::database::MemoryDatabase;
-        use bdk::testutils;
+    pub fn build(self) -> Wallet<bdk::database::MemoryDatabase, StaticFeeRate> {
+        use bdk::database::{BatchOperations, MemoryDatabase, SyncTime};
+        use bdk::{testutils, BlockTime};
 
         let descriptors = testutils!(@descriptors (&format!("wpkh({}/*)", self.key)));
 
@@ -638,9 +668,14 @@ impl WalletBuilder {
                 Some(100)
             );
         }
+        let block_time = bdk::BlockTime {
+            height: 100,
+            timestamp: 0,
+        };
+        let sync_time = SyncTime { block_time };
+        database.set_sync_time(sync_time).unwrap();
 
-        let wallet =
-            bdk::Wallet::new_offline(&descriptors.0, None, Network::Regtest, database).unwrap();
+        let wallet = bdk::Wallet::new(&descriptors.0, None, Network::Regtest, database).unwrap();
 
         Wallet {
             client: Arc::new(Mutex::new(StaticFeeRate {
@@ -678,6 +713,7 @@ impl Watchable for (Txid, Script) {
 
 pub struct Client {
     electrum: bdk::electrum_client::Client,
+    blockchain: ElectrumBlockchain,
     latest_block_height: BlockHeight,
     last_sync: Instant,
     sync_interval: Duration,
@@ -686,26 +722,48 @@ pub struct Client {
 }
 
 impl Client {
-    fn new(electrum: bdk::electrum_client::Client, interval: Duration) -> Result<Self> {
+    fn new(electrum_rpc_url: Url, interval: Duration) -> Result<Self> {
+        let config = bdk::electrum_client::ConfigBuilder::default()
+            .retry(5)
+            .build();
+        let electrum = bdk::electrum_client::Client::from_config(electrum_rpc_url.as_str(), config)
+            .context("Failed to initialize Electrum RPC client")?;
         // Initially fetch the latest block for storing the height.
         // We do not act on this subscription after this call.
         let latest_block = electrum
             .block_headers_subscribe()
             .context("Failed to subscribe to header notifications")?;
 
+        let client = bdk::electrum_client::Client::new(electrum_rpc_url.as_str())
+            .context("Failed to initialize Electrum RPC client")?;
+        let blockchain = ElectrumBlockchain::from(client);
+        let last_sync = Instant::now()
+            .checked_sub(interval)
+            .expect("no underflow since block time is only 600 secs");
+
         Ok(Self {
             electrum,
+            blockchain,
             latest_block_height: BlockHeight::try_from(latest_block)?,
-            last_sync: Instant::now(),
+            last_sync,
             sync_interval: interval,
             script_history: Default::default(),
             subscriptions: Default::default(),
         })
     }
 
-    fn update_state(&mut self) -> Result<()> {
+    fn blockchain(&self) -> &ElectrumBlockchain {
+        &self.blockchain
+    }
+
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, bdk::Error> {
+        self.blockchain.get_tx(txid)
+    }
+
+    fn update_state(&mut self, force_sync: bool) -> Result<()> {
         let now = Instant::now();
-        if now < self.last_sync + self.sync_interval {
+
+        if !force_sync && now < self.last_sync + self.sync_interval {
             return Ok(());
         }
 
@@ -725,9 +783,14 @@ impl Client {
 
         if !self.script_history.contains_key(&script) {
             self.script_history.insert(script.clone(), vec![]);
-        }
 
-        self.update_state()?;
+            // When we first subscribe to a script we want to immediately fetch its status
+            // Otherwise we would have to wait for the next sync interval, which can take a minute
+            // This would result in potentially inaccurate status updates until that next sync interval is hit
+            self.update_state(true)?;
+        } else {
+            self.update_state(false)?;
+        }
 
         let history = self.script_history.entry(script).or_default();
 
@@ -821,7 +884,7 @@ impl EstimateFeeRate for Client {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum ScriptStatus {
     Unseen,
     InMempool,
@@ -838,7 +901,7 @@ impl ScriptStatus {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct Confirmed {
     /// The depth of this transaction within the blockchain.
     ///
@@ -869,9 +932,20 @@ impl Confirmed {
 
     pub fn meets_target<T>(&self, target: T) -> bool
     where
-        u32: PartialOrd<T>,
+        T: Into<u32>,
     {
-        self.confirmations() >= target
+        self.confirmations() >= target.into()
+    }
+
+    pub fn blocks_left_until<T>(&self, target: T) -> u32
+    where
+        T: Into<u32> + Copy,
+    {
+        if self.meets_target(target) {
+            0
+        } else {
+            target.into() - self.confirmations()
+        }
     }
 }
 
@@ -884,7 +958,7 @@ impl ScriptStatus {
     /// Check if the script has met the given confirmation target.
     pub fn is_confirmed_with<T>(&self, target: T) -> bool
     where
-        u32: PartialOrd<T>,
+        T: Into<u32>,
     {
         match self {
             ScriptStatus::Confirmed(inner) => inner.meets_target(target),
@@ -892,6 +966,17 @@ impl ScriptStatus {
         }
     }
 
+    // Calculate the number of blocks left until the target is met.
+    pub fn blocks_left_until<T>(&self, target: T) -> u32
+    where
+        T: Into<u32> + Copy,
+    {
+        match self {
+            ScriptStatus::Confirmed(inner) => inner.blocks_left_until(target),
+            _ => target.into(),
+        }
+    }
+
     pub fn has_been_seen(&self) -> bool {
         matches!(self, ScriptStatus::InMempool | ScriptStatus::Confirmed(_))
     }
@@ -915,6 +1000,7 @@ mod tests {
     use super::*;
     use crate::bitcoin::{PublicKey, TxLock};
     use crate::tracing_ext::capture_logs;
+    use bitcoin::hashes::Hash;
     use proptest::prelude::*;
     use tracing::level_filters::LevelFilter;
 
@@ -922,7 +1008,7 @@ mod tests {
     fn given_depth_0_should_meet_confirmation_target_one() {
         let script = ScriptStatus::Confirmed(Confirmed { depth: 0 });
 
-        let confirmed = script.is_confirmed_with(1);
+        let confirmed = script.is_confirmed_with(1_u32);
 
         assert!(confirmed)
     }
@@ -931,7 +1017,7 @@ mod tests {
     fn given_confirmations_1_should_meet_confirmation_target_one() {
         let script = ScriptStatus::from_confirmations(1);
 
-        let confirmed = script.is_confirmed_with(1);
+        let confirmed = script.is_confirmed_with(1_u32);
 
         assert!(confirmed)
     }
@@ -946,6 +1032,33 @@ mod tests {
         assert_eq!(confirmed.depth, 0)
     }
 
+    #[test]
+    fn given_depth_0_should_return_0_blocks_left_until_1() {
+        let script = ScriptStatus::Confirmed(Confirmed { depth: 0 });
+
+        let blocks_left = script.blocks_left_until(1_u32);
+
+        assert_eq!(blocks_left, 0)
+    }
+
+    #[test]
+    fn given_depth_1_should_return_0_blocks_left_until_1() {
+        let script = ScriptStatus::Confirmed(Confirmed { depth: 1 });
+
+        let blocks_left = script.blocks_left_until(1_u32);
+
+        assert_eq!(blocks_left, 0)
+    }
+
+    #[test]
+    fn given_depth_0_should_return_1_blocks_left_until_2() {
+        let script = ScriptStatus::Confirmed(Confirmed { depth: 0 });
+
+        let blocks_left = script.blocks_left_until(2_u32);
+
+        assert_eq!(blocks_left, 1)
+    }
+
     #[test]
     fn given_one_BTC_and_100k_sats_per_vb_fees_should_not_hit_max() {
         // 400 weight = 100 vbyte
@@ -1014,7 +1127,7 @@ mod tests {
 
         // weight / 4.0 *  sat_per_vb would be greater than 3% hence we take total
         // max allowed fee.
-        assert_eq!(is_fee.as_sat(), MAX_ABSOLUTE_TX_FEE.to_u64().unwrap());
+        assert_eq!(is_fee.to_sat(), MAX_ABSOLUTE_TX_FEE.to_u64().unwrap());
     }
 
     proptest! {
@@ -1050,7 +1163,7 @@ mod tests {
             let is_fee = estimate_fee(weight, amount, fee_rate, relay_fee).unwrap();
 
             // weight / 4 * 1_000 is always lower than MAX_ABSOLUTE_TX_FEE
-            assert!(is_fee.as_sat() < MAX_ABSOLUTE_TX_FEE.to_u64().unwrap());
+            assert!(is_fee.to_sat() < MAX_ABSOLUTE_TX_FEE.to_u64().unwrap());
         }
     }
 
@@ -1069,7 +1182,7 @@ mod tests {
             let is_fee = estimate_fee(weight, amount, fee_rate, relay_fee).unwrap();
 
             // weight / 4 * 1_000  is always higher than MAX_ABSOLUTE_TX_FEE
-            assert!(is_fee.as_sat() >= MAX_ABSOLUTE_TX_FEE.to_u64().unwrap());
+            assert!(is_fee.to_sat() >= MAX_ABSOLUTE_TX_FEE.to_u64().unwrap());
         }
     }
 
@@ -1125,7 +1238,7 @@ mod tests {
         let wallet = WalletBuilder::new(10_000).build();
         let amount = wallet.max_giveable(TxLock::script_size()).await.unwrap();
 
-        assert!(amount.as_sat() > 0);
+        assert!(amount.to_sat() > 0);
     }
 
     /// This test ensures that the relevant script output of the transaction
@@ -1195,7 +1308,8 @@ mod tests {
     fn printing_status_change_doesnt_spam_on_same_status() {
         let writer = capture_logs(LevelFilter::DEBUG);
 
-        let tx = Txid::default();
+        let inner = bitcoin::hashes::sha256d::Hash::all_zeros();
+        let tx = Txid::from_hash(inner);
         let mut old = None;
         old = Some(print_status_change(tx, old, ScriptStatus::Unseen));
         old = Some(print_status_change(tx, old, ScriptStatus::InMempool));

swap/src/cli.rs

@@ -1,22 +1,21 @@
 mod behaviour;
-pub mod cancel;
+pub mod cancel_and_refund;
 pub mod command;
 mod event_loop;
 mod list_sellers;
-pub mod refund;
 pub mod tracing;
 pub mod transport;
 
 pub use behaviour::{Behaviour, OutEvent};
-pub use cancel::cancel;
+pub use cancel_and_refund::{cancel, cancel_and_refund, refund};
 pub use event_loop::{EventLoop, EventLoopHandle};
 pub use list_sellers::{list_sellers, Seller, Status as SellerStatus};
-pub use refund::refund;
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::asb;
+    use crate::asb::rendezvous::RendezvousNode;
     use crate::cli::list_sellers::{Seller, Status};
     use crate::network::quote;
     use crate::network::quote::BidQuote;
@@ -35,10 +34,8 @@ mod tests {
     async fn list_sellers_should_report_all_registered_asbs_with_a_quote() {
         let namespace = XmrBtcNamespace::Mainnet;
         let (rendezvous_address, rendezvous_peer_id) = setup_rendezvous_point().await;
-        let expected_seller_1 =
-            setup_asb(rendezvous_peer_id, rendezvous_address.clone(), namespace).await;
-        let expected_seller_2 =
-            setup_asb(rendezvous_peer_id, rendezvous_address.clone(), namespace).await;
+        let expected_seller_1 = setup_asb(rendezvous_peer_id, &rendezvous_address, namespace).await;
+        let expected_seller_2 = setup_asb(rendezvous_peer_id, &rendezvous_address, namespace).await;
 
         let list_sellers = list_sellers(
             rendezvous_peer_id,
@@ -74,7 +71,7 @@ mod tests {
 
     async fn setup_asb(
         rendezvous_peer_id: PeerId,
-        rendezvous_address: Multiaddr,
+        rendezvous_address: &Multiaddr,
         namespace: XmrBtcNamespace,
     ) -> Seller {
         let static_quote = BidQuote {
@@ -83,18 +80,18 @@ mod tests {
             max_quantity: bitcoin::Amount::from_sat(9001),
         };
 
-        let mut asb = new_swarm(|_, identity| StaticQuoteAsbBehaviour {
-            rendezvous: asb::rendezous::Behaviour::new(
-                identity,
-                rendezvous_peer_id,
-                rendezvous_address,
-                namespace,
-                None,
-            ),
-            ping: Default::default(),
-            quote: quote::asb(),
-            static_quote,
-            registered: false,
+        let mut asb = new_swarm(|_, identity| {
+            let rendezvous_node =
+                RendezvousNode::new(rendezvous_address, rendezvous_peer_id, namespace, None);
+            let rendezvous = asb::rendezvous::Behaviour::new(identity, vec![rendezvous_node]);
+
+            StaticQuoteAsbBehaviour {
+                rendezvous,
+                ping: Default::default(),
+                quote: quote::asb(),
+                static_quote,
+                registered: false,
+            }
         });
 
         let asb_address = asb.listen_on_tcp_localhost().await;
@@ -123,7 +120,7 @@ mod tests {
     #[derive(libp2p::NetworkBehaviour)]
     #[behaviour(event_process = true)]
     struct StaticQuoteAsbBehaviour {
-        rendezvous: asb::rendezous::Behaviour,
+        rendezvous: asb::rendezvous::Behaviour,
         // Support `Ping` as a workaround until https://github.com/libp2p/rust-libp2p/issues/2109 is fixed.
         ping: libp2p::ping::Ping,
         quote: quote::Behaviour,

swap/src/cli/behaviour.rs

@@ -1,13 +1,15 @@
 use crate::network::quote::BidQuote;
+use crate::network::rendezvous::XmrBtcNamespace;
 use crate::network::swap_setup::bob;
 use crate::network::{encrypted_signature, quote, redial, transfer_proof};
 use crate::protocol::bob::State2;
 use crate::{bitcoin, env};
 use anyhow::{anyhow, Error, Result};
 use libp2p::core::Multiaddr;
+use libp2p::identify::{Identify, IdentifyConfig, IdentifyEvent};
 use libp2p::ping::{Ping, PingConfig, PingEvent};
 use libp2p::request_response::{RequestId, ResponseChannel};
-use libp2p::{NetworkBehaviour, PeerId};
+use libp2p::{identity, NetworkBehaviour, PeerId};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -64,6 +66,7 @@ pub struct Behaviour {
     pub transfer_proof: transfer_proof::Behaviour,
     pub encrypted_signature: encrypted_signature::Behaviour,
     pub redial: redial::Behaviour,
+    pub identify: Identify,
 
     /// Ping behaviour that ensures that the underlying network connection is
     /// still alive. If the ping fails a connection close event will be
@@ -76,7 +79,13 @@ impl Behaviour {
         alice: PeerId,
         env_config: env::Config,
         bitcoin_wallet: Arc<bitcoin::Wallet>,
+        identify_params: (identity::Keypair, XmrBtcNamespace),
     ) -> Self {
+        let agentVersion = format!("cli/{} ({})", env!("CARGO_PKG_VERSION"), identify_params.1);
+        let protocolVersion = "/comit/xmr/btc/1.0.0".to_string();
+        let identifyConfig = IdentifyConfig::new(protocolVersion, identify_params.0.public())
+            .with_agent_version(agentVersion);
+
         Self {
             quote: quote::cli(),
             swap_setup: bob::Behaviour::new(env_config, bitcoin_wallet),
@@ -84,6 +93,7 @@ impl Behaviour {
             encrypted_signature: encrypted_signature::bob(),
             redial: redial::Behaviour::new(alice, Duration::from_secs(2)),
             ping: Ping::new(PingConfig::new().with_keep_alive(true)),
+            identify: Identify::new(identifyConfig),
         }
     }
 
@@ -100,3 +110,9 @@ impl From<PingEvent> for OutEvent {
         OutEvent::Other
     }
 }
+
+impl From<IdentifyEvent> for OutEvent {
+    fn from(_: IdentifyEvent) -> Self {
+        OutEvent::Other
+    }
+}

swap/src/cli/cancel.rs

@@ -1,56 +0,0 @@
-use crate::bitcoin::{parse_rpc_error_code, RpcErrorCode, Txid, Wallet};
-use crate::protocol::bob::BobState;
-use crate::protocol::Database;
-use anyhow::{bail, Result};
-use std::convert::TryInto;
-use std::sync::Arc;
-use uuid::Uuid;
-
-pub async fn cancel(
-    swap_id: Uuid,
-    bitcoin_wallet: Arc<Wallet>,
-    db: Arc<dyn Database>,
-) -> Result<(Txid, BobState)> {
-    let state = db.get_state(swap_id).await?.try_into()?;
-
-    let state6 = match state {
-        BobState::BtcLocked { state3, .. } => state3.cancel(),
-        BobState::XmrLockProofReceived { state, .. } => state.cancel(),
-        BobState::XmrLocked(state4) => state4.cancel(),
-        BobState::EncSigSent(state4) => state4.cancel(),
-        BobState::CancelTimelockExpired(state6) => state6,
-        BobState::BtcRefunded(state6) => state6,
-        BobState::BtcCancelled(state6) => state6,
-
-        BobState::Started { .. }
-        | BobState::SwapSetupCompleted(_)
-        | BobState::BtcRedeemed(_)
-        | BobState::XmrRedeemed { .. }
-        | BobState::BtcPunished { .. }
-        | BobState::SafelyAborted => bail!(
-            "Cannot cancel swap {} because it is in state {} which is not refundable.",
-            swap_id,
-            state
-        ),
-    };
-
-    tracing::info!(%swap_id, "Manually cancelling swap");
-
-    let txid = match state6.submit_tx_cancel(bitcoin_wallet.as_ref()).await {
-        Ok(txid) => txid,
-        Err(err) => {
-            if let Ok(code) = parse_rpc_error_code(&err) {
-                if code == i64::from(RpcErrorCode::RpcVerifyAlreadyInChain) {
-                    tracing::info!("Cancel transaction has already been confirmed on chain")
-                }
-            }
-            bail!(err);
-        }
-    };
-
-    let state = BobState::BtcCancelled(state6);
-    db.insert_latest_state(swap_id, state.clone().into())
-        .await?;
-
-    Ok((txid, state))
-}

swap/src/cli/cancel_and_refund.rs

@@ -0,0 +1,115 @@
+use crate::bitcoin::wallet::Subscription;
+use crate::bitcoin::{parse_rpc_error_code, RpcErrorCode, Wallet};
+use crate::protocol::bob::BobState;
+use crate::protocol::Database;
+use anyhow::{bail, Result};
+use bitcoin::Txid;
+use std::sync::Arc;
+use uuid::Uuid;
+
+pub async fn cancel_and_refund(
+    swap_id: Uuid,
+    bitcoin_wallet: Arc<Wallet>,
+    db: Arc<dyn Database + Send + Sync>,
+) -> Result<BobState> {
+    if let Err(err) = cancel(swap_id, bitcoin_wallet.clone(), db.clone()).await {
+        tracing::info!(%err, "Could not submit cancel transaction");
+    };
+
+    let state = match refund(swap_id, bitcoin_wallet, db).await {
+        Ok(s) => s,
+        Err(e) => bail!(e),
+    };
+
+    tracing::info!("Refund transaction submitted");
+    Ok(state)
+}
+
+pub async fn cancel(
+    swap_id: Uuid,
+    bitcoin_wallet: Arc<Wallet>,
+    db: Arc<dyn Database + Send + Sync>,
+) -> Result<(Txid, Subscription, BobState)> {
+    let state = db.get_state(swap_id).await?.try_into()?;
+
+    let state6 = match state {
+        BobState::BtcLocked { state3, .. } => state3.cancel(),
+        BobState::XmrLockProofReceived { state, .. } => state.cancel(),
+        BobState::XmrLocked(state4) => state4.cancel(),
+        BobState::EncSigSent(state4) => state4.cancel(),
+        BobState::CancelTimelockExpired(state6) => state6,
+        BobState::BtcRefunded(state6) => state6,
+        BobState::BtcCancelled(state6) => state6,
+
+        BobState::Started { .. }
+        | BobState::SwapSetupCompleted(_)
+        | BobState::BtcRedeemed(_)
+        | BobState::XmrRedeemed { .. }
+        | BobState::BtcPunished { .. }
+        | BobState::SafelyAborted => bail!(
+            "Cannot cancel swap {} because it is in state {} which is not refundable.",
+            swap_id,
+            state
+        ),
+    };
+
+    tracing::info!(%swap_id, "Manually cancelling swap");
+
+    let (txid, subscription) = match state6.submit_tx_cancel(bitcoin_wallet.as_ref()).await {
+        Ok(txid) => txid,
+        Err(err) => {
+            if let Ok(error_code) = parse_rpc_error_code(&err) {
+                tracing::debug!(%error_code, "parse rpc error");
+                if error_code == i64::from(RpcErrorCode::RpcVerifyAlreadyInChain) {
+                    tracing::info!("Cancel transaction has already been confirmed on chain");
+                } else if error_code == i64::from(RpcErrorCode::RpcVerifyError) {
+                    tracing::info!("General error trying to submit cancel transaction");
+                }
+            }
+            bail!(err);
+        }
+    };
+
+    let state = BobState::BtcCancelled(state6);
+    db.insert_latest_state(swap_id, state.clone().into())
+        .await?;
+
+    Ok((txid, subscription, state))
+}
+
+pub async fn refund(
+    swap_id: Uuid,
+    bitcoin_wallet: Arc<Wallet>,
+    db: Arc<dyn Database + Send + Sync>,
+) -> Result<BobState> {
+    let state = db.get_state(swap_id).await?.try_into()?;
+
+    let state6 = match state {
+        BobState::BtcLocked { state3, .. } => state3.cancel(),
+        BobState::XmrLockProofReceived { state, .. } => state.cancel(),
+        BobState::XmrLocked(state4) => state4.cancel(),
+        BobState::EncSigSent(state4) => state4.cancel(),
+        BobState::CancelTimelockExpired(state6) => state6,
+        BobState::BtcCancelled(state6) => state6,
+        BobState::Started { .. }
+        | BobState::SwapSetupCompleted(_)
+        | BobState::BtcRedeemed(_)
+        | BobState::BtcRefunded(_)
+        | BobState::XmrRedeemed { .. }
+        | BobState::BtcPunished { .. }
+        | BobState::SafelyAborted => bail!(
+            "Cannot refund swap {} because it is in state {} which is not refundable.",
+            swap_id,
+            state
+        ),
+    };
+
+    tracing::info!(%swap_id, "Manually refunding swap");
+    state6.publish_refund_btc(bitcoin_wallet.as_ref()).await?;
+
+    let state = BobState::BtcRefunded(state6);
+    db.insert_latest_state(swap_id, state.clone().into())
+        .await?;
+
+    Ok(state)
+}

swap/src/cli/event_loop.rs

@@ -1,14 +1,15 @@
 use crate::bitcoin::EncryptedSignature;
 use crate::cli::behaviour::{Behaviour, OutEvent};
+use crate::monero;
 use crate::network::encrypted_signature;
 use crate::network::quote::BidQuote;
 use crate::network::swap_setup::bob::NewSwap;
 use crate::protocol::bob::State2;
-use crate::{env, monero};
 use anyhow::{Context, Result};
 use futures::future::{BoxFuture, OptionFuture};
 use futures::{FutureExt, StreamExt};
 use libp2p::request_response::{RequestId, ResponseChannel};
+use libp2p::swarm::dial_opts::DialOpts;
 use libp2p::swarm::SwarmEvent;
 use libp2p::{PeerId, Swarm};
 use std::collections::HashMap;
@@ -50,7 +51,6 @@ impl EventLoop {
         swap_id: Uuid,
         swarm: Swarm<Behaviour>,
         alice_peer_id: PeerId,
-        env_config: env::Config,
     ) -> Result<(Self, EventLoopHandle)> {
         let execution_setup = bmrng::channel_with_timeout(1, Duration::from_secs(60));
         let transfer_proof = bmrng::channel_with_timeout(1, Duration::from_secs(60));
@@ -76,14 +76,13 @@ impl EventLoop {
             transfer_proof: transfer_proof.1,
             encrypted_signature: encrypted_signature.0,
             quote: quote.0,
-            env_config,
         };
 
         Ok((event_loop, handle))
     }
 
     pub async fn run(mut self) {
-        match self.swarm.dial(&self.alice_peer_id) {
+        match self.swarm.dial(DialOpts::from(self.alice_peer_id)) {
             Ok(()) => {}
             Err(e) => {
                 tracing::error!("Failed to initiate dial to Alice: {}", e);
@@ -152,29 +151,30 @@ impl EventLoop {
                             return;
                         }
                         SwarmEvent::Behaviour(OutEvent::Failure { peer, error }) => {
-                            tracing::warn!(%peer, "Communication error: {:#}", error);
+                            tracing::warn!(%peer, err = %error, "Communication error");
                             return;
                         }
                         SwarmEvent::ConnectionEstablished { peer_id, endpoint, .. } if peer_id == self.alice_peer_id => {
-                            tracing::info!("Connected to Alice at {}", endpoint.get_remote_address());
+                            tracing::info!(peer_id = %endpoint.get_remote_address(), "Connected to Alice");
                         }
                         SwarmEvent::Dialing(peer_id) if peer_id == self.alice_peer_id => {
-                            tracing::debug!("Dialling Alice at {}", peer_id);
+                            tracing::debug!(%peer_id, "Dialling Alice");
                         }
                         SwarmEvent::ConnectionClosed { peer_id, endpoint, num_established, cause: Some(error) } if peer_id == self.alice_peer_id && num_established == 0 => {
-                            tracing::warn!("Lost connection to Alice at {}, cause: {}", endpoint.get_remote_address(), error);
+                            tracing::warn!(peer_id = %endpoint.get_remote_address(), cause = %error, "Lost connection to Alice");
                         }
                         SwarmEvent::ConnectionClosed { peer_id, num_established, cause: None, .. } if peer_id == self.alice_peer_id && num_established == 0 => {
                             // no error means the disconnection was requested
                             tracing::info!("Successfully closed connection to Alice");
                             return;
                         }
-                        SwarmEvent::UnreachableAddr { peer_id, address, attempts_remaining, error } if peer_id == self.alice_peer_id && attempts_remaining == 0 => {
-                            tracing::warn!(%address, "Failed to dial Alice: {}", error);
+                        SwarmEvent::OutgoingConnectionError { peer_id: Some(alice_peer_id),  error } if alice_peer_id == self.alice_peer_id => {
+                            tracing::warn!(%error, "Failed to dial Alice");
 
                             if let Some(duration) = self.swarm.behaviour_mut().redial.until_next_redial() {
-                                tracing::info!("Next redial attempt in {}s", duration.as_secs());
+                                tracing::info!(seconds_until_next_redial = %duration.as_secs(), "Waiting for next redial attempt");
                             }
+
                         }
                         _ => {}
                     }
@@ -220,7 +220,6 @@ pub struct EventLoopHandle {
     transfer_proof: bmrng::RequestReceiver<monero::TransferProof, ()>,
     encrypted_signature: bmrng::RequestSender<EncryptedSignature, ()>,
     quote: bmrng::RequestSender<(), BidQuote>,
-    env_config: env::Config,
 }
 
 impl EventLoopHandle {
@@ -242,6 +241,7 @@ impl EventLoopHandle {
     }
 
     pub async fn request_quote(&mut self) -> Result<BidQuote> {
+        tracing::debug!("Requesting quote");
         Ok(self.quote.send_receive(()).await?)
     }
 
@@ -249,9 +249,8 @@ impl EventLoopHandle {
         &mut self,
         tx_redeem_encsig: EncryptedSignature,
     ) -> Result<(), bmrng::error::RequestError<EncryptedSignature>> {
-        Ok(self
-            .encrypted_signature
+        self.encrypted_signature
             .send_receive(tx_redeem_encsig)
-            .await?)
+            .await
     }
 }

swap/src/cli/list_sellers.rs

@@ -6,6 +6,7 @@ use futures::StreamExt;
 use libp2p::multiaddr::Protocol;
 use libp2p::ping::{Ping, PingConfig, PingEvent};
 use libp2p::request_response::{RequestResponseEvent, RequestResponseMessage};
+use libp2p::swarm::dial_opts::DialOpts;
 use libp2p::swarm::SwarmEvent;
 use libp2p::{identity, rendezvous, Multiaddr, PeerId, Swarm};
 use serde::Serialize;
@@ -42,8 +43,9 @@ pub async fn list_sellers(
         .behaviour_mut()
         .quote
         .add_address(&rendezvous_node_peer_id, rendezvous_node_addr.clone());
+
     swarm
-        .dial(&rendezvous_node_peer_id)
+        .dial(DialOpts::from(rendezvous_node_peer_id))
         .context("Failed to dial rendezvous node")?;
 
     let event_loop = EventLoop::new(
@@ -147,7 +149,7 @@ impl EventLoop {
                 swarm_event = self.swarm.select_next_some() => {
                     match swarm_event {
                         SwarmEvent::ConnectionEstablished { peer_id, endpoint, .. } => {
-                            if peer_id == self.rendezvous_peer_id{
+                            if peer_id == self.rendezvous_peer_id {
                                 tracing::info!(
                                     "Connected to rendezvous point, discovering nodes in '{}' namespace ...",
                                     self.namespace
@@ -161,35 +163,41 @@ impl EventLoop {
                                 );
                             } else {
                                 let address = endpoint.get_remote_address();
+                                tracing::debug!(%peer_id, %address, "Connection established to peer");
                                 self.reachable_asb_address.insert(peer_id, address.clone());
                             }
                         }
-                        SwarmEvent::UnreachableAddr { peer_id, error, address, .. } => {
-                            if address == self.rendezvous_addr {
-                                tracing::error!(
-                                    "Failed to connect to rendezvous point at {}: {}",
-                                    address,
-                                    error
-                                );
-
-                                // if the rendezvous node is unreachable we just stop
-                                return Vec::new();
-                            } else {
-                                tracing::debug!(
-                                    "Failed to connect to peer at {}: {}",
-                                    address,
-                                    error
-                                );
-                                self.unreachable_asb_address.insert(peer_id, address.clone());
-
-                                match self.asb_quote_status.entry(peer_id) {
-                                    Entry::Occupied(mut entry) => {
-                                        entry.insert(QuoteStatus::Received(Status::Unreachable));
-                                    },
-                                    _ => {
-                                        tracing::debug!(%peer_id, %error, "Connection error with unexpected peer")
+                        SwarmEvent::OutgoingConnectionError { peer_id, error } => {
+                            if let Some(peer_id) = peer_id {
+                                if peer_id == self.rendezvous_peer_id {
+                                    tracing::error!(
+                                        %peer_id,
+                                        %self.rendezvous_addr,
+                                        "Failed to connect to rendezvous point: {}",
+                                        error
+                                    );
+
+                                    // if the rendezvous node is unreachable we just stop
+                                    return Vec::new();
+                                } else {
+                                    tracing::error!(
+                                        %peer_id,
+                                        "Failed to connect to peer: {}",
+                                        error
+                                    );
+                                    self.unreachable_asb_address.insert(peer_id, Multiaddr::empty());
+
+                                    match self.asb_quote_status.entry(peer_id) {
+                                        Entry::Occupied(mut entry) => {
+                                            entry.insert(QuoteStatus::Received(Status::Unreachable));
+                                        },
+                                        _ => {
+                                            tracing::debug!(%peer_id, %error, "Connection error with unexpected peer");
+                                        }
                                     }
                                 }
+                            } else {
+                                tracing::debug!("Failed to connect (no peer id): {}", error);
                             }
                         }
                         SwarmEvent::Behaviour(OutEvent::Rendezvous(
@@ -271,7 +279,7 @@ impl EventLoop {
                             QuoteStatus::Received(Status::Online(quote)) => {
                                 let address = self
                                     .reachable_asb_address
-                                    .get(&peer_id)
+                                    .get(peer_id)
                                     .expect("if we got a quote we must have stored an address");
 
                                 Ok(Seller {
@@ -282,7 +290,7 @@ impl EventLoop {
                             QuoteStatus::Received(Status::Unreachable) => {
                                 let address = self
                                     .unreachable_asb_address
-                                    .get(&peer_id)
+                                    .get(peer_id)
                                     .expect("if we got a quote we must have stored an address");
 
                                 Ok(Seller {
@@ -342,23 +350,26 @@ mod tests {
 
         list.sort();
 
-        assert_eq!(list, vec![
-            Seller {
-                multiaddr: "/ip4/127.0.0.1/tcp/5678".parse().unwrap(),
-                status: Status::Online(BidQuote {
-                    price: Default::default(),
-                    min_quantity: Default::default(),
-                    max_quantity: Default::default(),
-                })
-            },
-            Seller {
-                multiaddr: Multiaddr::empty(),
-                status: Status::Unreachable
-            },
-            Seller {
-                multiaddr: "/ip4/127.0.0.1/tcp/1234".parse().unwrap(),
-                status: Status::Unreachable
-            },
-        ])
+        assert_eq!(
+            list,
+            vec![
+                Seller {
+                    multiaddr: "/ip4/127.0.0.1/tcp/5678".parse().unwrap(),
+                    status: Status::Online(BidQuote {
+                        price: Default::default(),
+                        min_quantity: Default::default(),
+                        max_quantity: Default::default(),
+                    })
+                },
+                Seller {
+                    multiaddr: Multiaddr::empty(),
+                    status: Status::Unreachable
+                },
+                Seller {
+                    multiaddr: "/ip4/127.0.0.1/tcp/1234".parse().unwrap(),
+                    status: Status::Unreachable
+                },
+            ]
+        )
     }
 }

swap/src/cli/refund.rs

@@ -1,43 +0,0 @@
-use crate::bitcoin::Wallet;
-use crate::protocol::bob::BobState;
-use crate::protocol::Database;
-use anyhow::{bail, Result};
-use std::convert::TryInto;
-use std::sync::Arc;
-use uuid::Uuid;
-
-pub async fn refund(
-    swap_id: Uuid,
-    bitcoin_wallet: Arc<Wallet>,
-    db: Arc<dyn Database>,
-) -> Result<BobState> {
-    let state = db.get_state(swap_id).await?.try_into()?;
-
-    let state6 = match state {
-        BobState::BtcLocked { state3, .. } => state3.cancel(),
-        BobState::XmrLockProofReceived { state, .. } => state.cancel(),
-        BobState::XmrLocked(state4) => state4.cancel(),
-        BobState::EncSigSent(state4) => state4.cancel(),
-        BobState::CancelTimelockExpired(state6) => state6,
-        BobState::BtcCancelled(state6) => state6,
-        BobState::Started { .. }
-        | BobState::SwapSetupCompleted(_)
-        | BobState::BtcRedeemed(_)
-        | BobState::BtcRefunded(_)
-        | BobState::XmrRedeemed { .. }
-        | BobState::BtcPunished { .. }
-        | BobState::SafelyAborted => bail!(
-            "Cannot refund swap {} because it is in state {} which is not refundable.",
-            swap_id,
-            state
-        ),
-    };
-
-    state6.publish_refund_btc(bitcoin_wallet.as_ref()).await?;
-
-    let state = BobState::BtcRefunded(state6);
-    db.insert_latest_state(swap_id, state.clone().into())
-        .await?;
-
-    Ok(state)
-}

swap/src/cli/tracing.rs

@@ -1,69 +1,39 @@
 use anyhow::Result;
-use std::option::Option::Some;
 use std::path::Path;
 use time::format_description::well_known::Rfc3339;
 use tracing::subscriber::set_global_default;
 use tracing::{Event, Level, Subscriber};
 use tracing_subscriber::fmt::format::{DefaultFields, Format, JsonFields};
-use tracing_subscriber::fmt::time::LocalTime;
+use tracing_subscriber::fmt::time::UtcTime;
 use tracing_subscriber::layer::{Context, SubscriberExt};
-use tracing_subscriber::{fmt, EnvFilter, FmtSubscriber, Layer, Registry};
-use uuid::Uuid;
+use tracing_subscriber::{fmt, EnvFilter, Layer, Registry};
 
-pub fn init(debug: bool, json: bool, dir: impl AsRef<Path>, swap_id: Option<Uuid>) -> Result<()> {
-    if let Some(swap_id) = swap_id {
-        let level_filter = EnvFilter::try_new("swap=debug")?;
+pub fn init(debug: bool, json: bool, dir: impl AsRef<Path>) -> Result<()> {
+    let level_filter = EnvFilter::try_new("swap=debug")?;
+    let registry = Registry::default().with(level_filter);
 
-        let registry = Registry::default().with(level_filter);
+    let appender = tracing_appender::rolling::never(dir.as_ref(), "swap-all.log");
 
-        let appender = tracing_appender::rolling::never(dir, format!("swap-{}.log", swap_id));
-        let (appender, guard) = tracing_appender::non_blocking(appender);
-
-        std::mem::forget(guard);
-
-        let file_logger = fmt::layer()
+    let file_logger = registry.with(
+        fmt::layer()
             .with_ansi(false)
             .with_target(false)
-            .with_writer(appender);
-
-        if json && debug {
-            set_global_default(
-                registry
-                    .with(file_logger.json())
-                    .with(debug_json_terminal_printer()),
-            )?;
-        } else if json && !debug {
-            set_global_default(
-                registry
-                    .with(file_logger.json())
-                    .with(info_json_terminal_printer()),
-            )?;
-        } else if !json && debug {
-            set_global_default(registry.with(file_logger).with(debug_terminal_printer()))?;
-        } else {
-            set_global_default(registry.with(file_logger).with(info_terminal_printer()))?;
-        }
-
-        Ok(())
+            .json()
+            .with_writer(appender),
+    );
+
+    if json && debug {
+        set_global_default(file_logger.with(debug_json_terminal_printer()))?;
+    } else if json && !debug {
+        set_global_default(file_logger.with(info_json_terminal_printer()))?;
+    } else if !json && debug {
+        set_global_default(file_logger.with(debug_terminal_printer()))?;
     } else {
-        let level = if debug { Level::DEBUG } else { Level::INFO };
-        let is_terminal = atty::is(atty::Stream::Stderr);
-
-        let builder = FmtSubscriber::builder()
-            .with_env_filter(format!("swap={}", level))
-            .with_writer(std::io::stderr)
-            .with_ansi(is_terminal)
-            .with_timer(LocalTime::new(Rfc3339))
-            .with_target(false);
-
-        if json {
-            builder.json().init();
-        } else {
-            builder.init();
-        }
-
-        Ok(())
+        set_global_default(file_logger.with(info_terminal_printer()))?;
     }
+
+    tracing::info!("Logging initialized to {}", dir.as_ref().display());
+    Ok(())
 }
 
 pub struct StdErrPrinter<L> {
@@ -71,39 +41,31 @@ pub struct StdErrPrinter<L> {
     level: Level,
 }
 
-type StdErrLayer<S, T> = tracing_subscriber::fmt::Layer<
-    S,
-    DefaultFields,
-    Format<tracing_subscriber::fmt::format::Full, T>,
-    fn() -> std::io::Stderr,
->;
+type StdErrLayer<S, T> =
+    fmt::Layer<S, DefaultFields, Format<fmt::format::Full, T>, fn() -> std::io::Stderr>;
 
-type StdErrJsonLayer<S, T> = tracing_subscriber::fmt::Layer<
-    S,
-    JsonFields,
-    Format<tracing_subscriber::fmt::format::Json, T>,
-    fn() -> std::io::Stderr,
->;
+type StdErrJsonLayer<S, T> =
+    fmt::Layer<S, JsonFields, Format<fmt::format::Json, T>, fn() -> std::io::Stderr>;
 
-fn debug_terminal_printer<S>() -> StdErrPrinter<StdErrLayer<S, LocalTime<Rfc3339>>> {
+fn debug_terminal_printer<S>() -> StdErrPrinter<StdErrLayer<S, UtcTime<Rfc3339>>> {
     let is_terminal = atty::is(atty::Stream::Stderr);
     StdErrPrinter {
         inner: fmt::layer()
             .with_ansi(is_terminal)
             .with_target(false)
-            .with_timer(LocalTime::new(Rfc3339))
+            .with_timer(UtcTime::rfc_3339())
             .with_writer(std::io::stderr),
         level: Level::DEBUG,
     }
 }
 
-fn debug_json_terminal_printer<S>() -> StdErrPrinter<StdErrJsonLayer<S, LocalTime<Rfc3339>>> {
+fn debug_json_terminal_printer<S>() -> StdErrPrinter<StdErrJsonLayer<S, UtcTime<Rfc3339>>> {
     let is_terminal = atty::is(atty::Stream::Stderr);
     StdErrPrinter {
         inner: fmt::layer()
             .with_ansi(is_terminal)
             .with_target(false)
-            .with_timer(LocalTime::new(Rfc3339))
+            .with_timer(UtcTime::rfc_3339())
             .json()
             .with_writer(std::io::stderr),
         level: Level::DEBUG,

swap/src/common.rs

@@ -0,0 +1,56 @@
+use anyhow::anyhow;
+
+const LATEST_RELEASE_URL: &str = "https://github.com/comit-network/xmr-btc-swap/releases/latest";
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Version {
+    Current,
+    Available,
+}
+
+/// Check the latest release from GitHub API.
+pub async fn check_latest_version(current_version: &str) -> anyhow::Result<Version> {
+    let response = reqwest::get(LATEST_RELEASE_URL).await?;
+    let e = "Failed to get latest release.";
+    let download_url = response.url();
+    let segments = download_url.path_segments().ok_or_else(|| anyhow!(e))?;
+    let latest_version = segments.last().ok_or_else(|| anyhow!(e))?;
+
+    let result = if is_latest_version(current_version, latest_version) {
+        Version::Current
+    } else {
+        tracing::warn!(%current_version, %latest_version, %download_url,
+            "You are not on the latest version",
+        );
+        Version::Available
+    };
+
+    Ok(result)
+}
+
+// todo: naive implementation can be improved using semver
+fn is_latest_version(current: &str, latest: &str) -> bool {
+    current == latest
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn it_compares_versions() {
+        assert!(is_latest_version("0.10.2", "0.10.2"));
+        assert!(!is_latest_version("0.10.2", "0.10.3"));
+        assert!(!is_latest_version("0.10.2", "0.11.0"));
+    }
+
+    #[tokio::test]
+    #[ignore = "For local testing, makes http requests to github."]
+    async fn it_compares_with_github() {
+        let result = check_latest_version("0.11.0").await.unwrap();
+        assert_eq!(result, Version::Available);
+
+        let result = check_latest_version("0.11.1").await.unwrap();
+        assert_eq!(result, Version::Current);
+    }
+}

swap/src/database/alice.rs

@@ -70,7 +70,7 @@ pub enum Alice {
     Done(AliceEndState),
 }
 
-#[derive(Copy, Clone, strum::Display, Debug, Deserialize, Serialize, PartialEq)]
+#[derive(Copy, Clone, strum::Display, Debug, Deserialize, Serialize, PartialEq, Eq)]
 pub enum AliceEndState {
     SafelyAborted,
     BtcRedeemed,

swap/src/database/sqlite.rs

@@ -1,11 +1,12 @@
 use crate::database::Swap;
 use crate::monero::Address;
 use crate::protocol::{Database, State};
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
 use libp2p::{Multiaddr, PeerId};
 use sqlx::sqlite::Sqlite;
 use sqlx::{Pool, SqlitePool};
+use std::collections::HashMap;
 use std::path::Path;
 use std::str::FromStr;
 use time::OffsetDateTime;
@@ -149,7 +150,7 @@ impl Database for SqliteDatabase {
 
         let rows = sqlx::query!(
             r#"
-        SELECT address
+        SELECT DISTINCT address
         FROM peer_addresses
         WHERE peer_id = ?
         "#,
@@ -169,6 +170,25 @@ impl Database for SqliteDatabase {
         addresses
     }
 
+    async fn get_swap_start_date(&self, swap_id: Uuid) -> Result<String> {
+        let mut conn = self.pool.acquire().await?;
+        let swap_id = swap_id.to_string();
+
+        let row = sqlx::query!(
+            r#"
+                SELECT min(entered_at) as start_date
+                FROM swap_states
+                WHERE swap_id = ?
+                "#,
+            swap_id
+        )
+        .fetch_one(&mut conn)
+        .await?;
+
+        row.start_date
+            .ok_or_else(|| anyhow!("Could not get swap start date"))
+    }
+
     async fn insert_latest_state(&self, swap_id: Uuid, state: State) -> Result<()> {
         let mut conn = self.pool.acquire().await?;
         let entered_at = OffsetDateTime::now_utc();
@@ -249,6 +269,69 @@ impl Database for SqliteDatabase {
 
         result
     }
+
+    async fn get_states(&self, swap_id: Uuid) -> Result<Vec<State>> {
+        let mut conn = self.pool.acquire().await?;
+        let swap_id = swap_id.to_string();
+
+        // TODO: We should use query! instead of query here to allow for at-compile-time validation
+        // I didn't manage to generate the mappings for the query! macro because of problems with sqlx-cli
+        let rows = sqlx::query!(
+            r#"
+           SELECT state
+           FROM swap_states
+           WHERE swap_id = ?
+        "#,
+            swap_id
+        )
+        .fetch_all(&mut conn)
+        .await?;
+
+        let result = rows
+            .iter()
+            .map(|row| {
+                let state_str: &str = &row.state;
+
+                let state = match serde_json::from_str::<Swap>(state_str) {
+                    Ok(a) => Ok(State::from(a)),
+                    Err(e) => Err(e),
+                }?;
+                Ok(state)
+            })
+            .collect::<Result<Vec<State>>>();
+
+        result
+    }
+
+    async fn raw_all(&self) -> Result<HashMap<Uuid, Vec<serde_json::Value>>> {
+        let mut conn = self.pool.acquire().await?;
+        let rows = sqlx::query!(
+            r#"
+                SELECT swap_id, state
+                FROM swap_states
+                "#
+        )
+        .fetch_all(&mut conn)
+        .await?;
+
+        let mut swaps: HashMap<Uuid, Vec<serde_json::Value>> = HashMap::new();
+
+        for row in &rows {
+            let swap_id = Uuid::from_str(&row.swap_id)?;
+            let state = serde_json::from_str(&row.state)?;
+
+            if let std::collections::hash_map::Entry::Vacant(e) = swaps.entry(swap_id) {
+                e.insert(vec![state]);
+            } else {
+                swaps
+                    .get_mut(&swap_id)
+                    .ok_or_else(|| anyhow!("Error while retrieving the swap"))?
+                    .push(state);
+            }
+        }
+
+        Ok(swaps)
+    }
 }
 
 #[cfg(test)]

swap/src/env.rs

@@ -5,7 +5,7 @@ use std::cmp::max;
 use std::time::Duration;
 use time::ext::NumericalStdDuration;
 
-#[derive(Debug, Copy, Clone, PartialEq, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize)]
 pub struct Config {
     pub bitcoin_lock_mempool_timeout: Duration,
     pub bitcoin_lock_confirmed_timeout: Duration,
@@ -46,9 +46,9 @@ pub struct Regtest;
 impl GetConfig for Mainnet {
     fn get_config() -> Config {
         Config {
-            bitcoin_lock_mempool_timeout: 3.std_minutes(),
+            bitcoin_lock_mempool_timeout: 10.std_minutes(),
             bitcoin_lock_confirmed_timeout: 2.std_hours(),
-            bitcoin_finality_confirmations: 2,
+            bitcoin_finality_confirmations: 1,
             bitcoin_avg_block_time: 10.std_minutes(),
             bitcoin_cancel_timelock: CancelTimelock::new(72),
             bitcoin_punish_timelock: PunishTimelock::new(72),
@@ -63,9 +63,9 @@ impl GetConfig for Mainnet {
 impl GetConfig for Testnet {
     fn get_config() -> Config {
         Config {
-            bitcoin_lock_mempool_timeout: 3.std_minutes(),
+            bitcoin_lock_mempool_timeout: 10.std_minutes(),
             bitcoin_lock_confirmed_timeout: 1.std_hours(),
-            bitcoin_finality_confirmations: 2,
+            bitcoin_finality_confirmations: 1,
             bitcoin_avg_block_time: 10.std_minutes(),
             bitcoin_cancel_timelock: CancelTimelock::new(12),
             bitcoin_punish_timelock: PunishTimelock::new(6),
@@ -138,7 +138,7 @@ mod monero_network {
             Network::Stagenet => "stagenet",
             Network::Testnet => "testnet",
         };
-        s.serialize_str(&str)
+        s.serialize_str(str)
     }
 }
 

swap/src/kraken.rs

@@ -45,7 +45,7 @@ pub fn connect(price_ticker_ws_url: Url) -> Result<PriceUpdates> {
                         }
                     }
 
-                    Err(backoff::Error::Transient(anyhow!("stream ended")))
+                    Err(backoff::Error::transient(anyhow!("stream ended")))
                 }
             },
             |error, next: Duration| {
@@ -108,8 +108,8 @@ fn to_backoff(e: connection::Error) -> backoff::Error<anyhow::Error> {
 
     match e {
         // Connection closures and websocket errors will be retried
-        connection::Error::ConnectionClosed => Transient(anyhow::Error::from(e)),
-        connection::Error::WebSocket(_) => Transient(anyhow::Error::from(e)),
+        connection::Error::ConnectionClosed => backoff::Error::transient(anyhow::Error::from(e)),
+        connection::Error::WebSocket(_) => backoff::Error::transient(anyhow::Error::from(e)),
 
         // Failures while parsing a message are permanent because they most likely present a
         // programmer error
@@ -230,7 +230,7 @@ mod wire {
     use bitcoin::util::amount::ParseAmountError;
     use serde_json::Value;
 
-    #[derive(Debug, Deserialize, PartialEq)]
+    #[derive(Debug, Deserialize, PartialEq, Eq)]
     #[serde(tag = "event")]
     pub enum Event {
         #[serde(rename = "systemStatus")]
@@ -275,8 +275,6 @@ mod wire {
     pub struct TickerData {
         #[serde(rename = "a")]
         ask: Vec<RateElement>,
-        #[serde(rename = "b")]
-        bid: Vec<RateElement>,
     }
 
     #[derive(Debug, Deserialize)]

swap/src/lib.rs

@@ -16,9 +16,11 @@
     missing_copy_implementations
 )]
 
+pub mod api;
 pub mod asb;
 pub mod bitcoin;
 pub mod cli;
+pub mod common;
 pub mod database;
 pub mod env;
 pub mod fs;
@@ -27,6 +29,7 @@ pub mod libp2p_ext;
 pub mod monero;
 pub mod network;
 pub mod protocol;
+pub mod rpc;
 pub mod seed;
 pub mod tor;
 pub mod tracing_ext;

swap/src/monero.rs

@@ -39,9 +39,16 @@ pub fn private_key_from_secp256k1_scalar(scalar: bitcoin::Scalar) -> PrivateKey
     PrivateKey::from_scalar(Scalar::from_bytes_mod_order(bytes))
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct PrivateViewKey(#[serde(with = "monero_private_key")] PrivateKey);
 
+impl fmt::Display for PrivateViewKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Delegate to the Display implementation of PrivateKey
+        write!(f, "{}", self.0)
+    }
+}
+
 impl PrivateViewKey {
     pub fn new_random<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
         let scalar = Scalar::random(rng);
@@ -78,11 +85,11 @@ impl From<PublicViewKey> for PublicKey {
 #[derive(Clone, Copy, Debug)]
 pub struct PublicViewKey(PublicKey);
 
-#[derive(Debug, Copy, Clone, Deserialize, Serialize, PartialEq, PartialOrd)]
+#[derive(Debug, Copy, Clone, Deserialize, Serialize, PartialEq, Eq, PartialOrd)]
 pub struct Amount(u64);
 
-// Median tx fees on Monero as found here: https://www.monero.how/monero-transaction-fees, XMR 0.000_015 * 2 (to be on the safe side)
-pub const MONERO_FEE: Amount = Amount::from_piconero(30000000);
+// Median tx fees on Monero as found here: https://www.monero.how/monero-transaction-fees, XMR 0.000_008 * 2 (to be on the safe side)
+pub const MONERO_FEE: Amount = Amount::from_piconero(16_000_000);
 
 impl Amount {
     pub const ZERO: Self = Self(0);
@@ -95,10 +102,32 @@ impl Amount {
         Amount(amount)
     }
 
+    /// Return Monero Amount as Piconero.
     pub fn as_piconero(&self) -> u64 {
         self.0
     }
 
+    /// Calculate the maximum amount of Bitcoin that can be bought at a given
+    /// asking price for this amount of Monero including the median fee.
+    pub fn max_bitcoin_for_price(&self, ask_price: bitcoin::Amount) -> Option<bitcoin::Amount> {
+        let pico_minus_fee = self.as_piconero().saturating_sub(MONERO_FEE.as_piconero());
+
+        if pico_minus_fee == 0 {
+            return Some(bitcoin::Amount::ZERO);
+        }
+
+        // safely convert the BTC/XMR rate to sat/pico
+        let ask_sats = Decimal::from(ask_price.to_sat());
+        let pico_per_xmr = Decimal::from(PICONERO_OFFSET);
+        let ask_sats_per_pico = ask_sats / pico_per_xmr;
+
+        let pico = Decimal::from(pico_minus_fee);
+        let max_sats = pico.checked_mul(ask_sats_per_pico)?;
+        let satoshi = max_sats.to_u64()?;
+
+        Some(bitcoin::Amount::from_sat(satoshi))
+    }
+
     pub fn from_monero(amount: f64) -> Result<Self> {
         let decimal = Decimal::try_from(amount)?;
         Self::from_decimal(decimal)
@@ -163,7 +192,7 @@ impl fmt::Display for Amount {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct TransferProof {
     tx_hash: TxHash,
     #[serde(with = "monero_private_key")]
@@ -183,7 +212,7 @@ impl TransferProof {
 }
 
 // TODO: add constructor/ change String to fixed length byte array
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct TxHash(pub String);
 
 impl From<TxHash> for String {
@@ -205,7 +234,7 @@ pub struct InsufficientFunds {
     pub actual: Amount,
 }
 
-#[derive(thiserror::Error, Debug, Clone, PartialEq)]
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
 #[error("Overflow, cannot convert {0} to u64")]
 pub struct OverflowError(pub String);
 
@@ -298,6 +327,52 @@ pub mod monero_amount {
     }
 }
 
+pub mod monero_address {
+    use anyhow::{bail, Context, Result};
+    use std::str::FromStr;
+
+    #[derive(thiserror::Error, Debug, Clone, Copy, PartialEq)]
+    #[error("Invalid monero address provided, expected address on network {expected:?} but address provided is on {actual:?}")]
+    pub struct MoneroAddressNetworkMismatch {
+        pub expected: monero::Network,
+        pub actual: monero::Network,
+    }
+
+    pub fn parse(s: &str) -> Result<monero::Address> {
+        monero::Address::from_str(s).with_context(|| {
+            format!(
+                "Failed to parse {} as a monero address, please make sure it is a valid address",
+                s
+            )
+        })
+    }
+
+    pub fn validate(
+        address: monero::Address,
+        expected_network: monero::Network,
+    ) -> Result<monero::Address> {
+        if address.network != expected_network {
+            bail!(MoneroAddressNetworkMismatch {
+                expected: expected_network,
+                actual: address.network,
+            });
+        }
+        Ok(address)
+    }
+
+    pub fn validate_is_testnet(
+        address: monero::Address,
+        is_testnet: bool,
+    ) -> Result<monero::Address> {
+        let expected_network = if is_testnet {
+            monero::Network::Stagenet
+        } else {
+            monero::Network::Mainnet
+        };
+        validate(address, expected_network)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -360,13 +435,98 @@ mod tests {
         );
     }
 
+    #[test]
+    fn max_bitcoin_to_trade() {
+        // sanity check: if the asking price is 1 BTC / 1 XMR
+        // and we have μ XMR + fee
+        // then max BTC we can buy is μ
+        let ask = bitcoin::Amount::from_btc(1.0).unwrap();
+
+        let xmr = Amount::parse_monero("1.0").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(1.0).unwrap());
+
+        let xmr = Amount::parse_monero("0.5").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(0.5).unwrap());
+
+        let xmr = Amount::parse_monero("2.5").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(2.5).unwrap());
+
+        let xmr = Amount::parse_monero("420").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(420.0).unwrap());
+
+        let xmr = Amount::parse_monero("0.00001").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(0.00001).unwrap());
+
+        // other ask prices
+
+        let ask = bitcoin::Amount::from_btc(0.5).unwrap();
+        let xmr = Amount::parse_monero("2").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(1.0).unwrap());
+
+        let ask = bitcoin::Amount::from_btc(2.0).unwrap();
+        let xmr = Amount::parse_monero("1").unwrap() + MONERO_FEE;
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_btc(2.0).unwrap());
+
+        let ask = bitcoin::Amount::from_sat(382_900);
+        let xmr = Amount::parse_monero("10").unwrap();
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_sat(3_828_993));
+
+        // example from https://github.com/comit-network/xmr-btc-swap/issues/1084
+        // with rate from kraken at that time
+        let ask = bitcoin::Amount::from_sat(685_800);
+        let xmr = Amount::parse_monero("0.826286435921").unwrap();
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(btc, bitcoin::Amount::from_sat(566_656));
+    }
+
+    #[test]
+    fn max_bitcoin_to_trade_overflow() {
+        let xmr = Amount::from_monero(30.0).unwrap();
+        let ask = bitcoin::Amount::from_sat(728_688);
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(bitcoin::Amount::from_sat(21_860_628), btc);
+
+        let xmr = Amount::from_piconero(u64::MAX);
+        let ask = bitcoin::Amount::from_sat(u64::MAX);
+        let btc = xmr.max_bitcoin_for_price(ask);
+
+        assert!(btc.is_none());
+    }
+
+    #[test]
+    fn geting_max_bitcoin_to_trade_with_balance_smaller_than_locking_fee() {
+        let ask = bitcoin::Amount::from_sat(382_900);
+        let xmr = Amount::parse_monero("0.00001").unwrap();
+        let btc = xmr.max_bitcoin_for_price(ask).unwrap();
+
+        assert_eq!(bitcoin::Amount::ZERO, btc);
+    }
+
     use rand::rngs::OsRng;
     use serde::{Deserialize, Serialize};
 
-    #[derive(Debug, Serialize, Deserialize, PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
     pub struct MoneroPrivateKey(#[serde(with = "monero_private_key")] crate::monero::PrivateKey);
 
-    #[derive(Debug, Serialize, Deserialize, PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
     pub struct MoneroAmount(#[serde(with = "monero_amount")] crate::monero::Amount);
 
     #[test]

swap/src/monero/wallet.rs

@@ -26,15 +26,16 @@ impl Wallet {
     pub async fn open_or_create(url: Url, name: String, env_config: Config) -> Result<Self> {
         let client = wallet::Client::new(url)?;
 
-        let open_wallet_response = client.open_wallet(name.clone()).await;
-        if open_wallet_response.is_err() {
-            client.create_wallet(name.clone(), "English".to_owned()).await.context(
-                "Unable to create Monero wallet, please ensure that the monero-wallet-rpc is available",
-            )?;
-
-            tracing::debug!(monero_wallet_name = %name, "Created Monero wallet");
-        } else {
-            tracing::debug!(monero_wallet_name = %name, "Opened Monero wallet");
+        match client.open_wallet(name.clone()).await {
+            Err(error) => {
+                tracing::debug!(%error, "Open wallet response error");
+                client.create_wallet(name.clone(), "English".to_owned()).await.context(
+                    "Unable to create Monero wallet, please ensure that the monero-wallet-rpc is available",
+                )?;
+
+                tracing::debug!(monero_wallet_name = %name, "Created Monero wallet");
+            }
+            Ok(_) => tracing::debug!(monero_wallet_name = %name, "Opened Monero wallet"),
         }
 
         Self::connect(client, name, env_config).await
@@ -173,11 +174,6 @@ impl Wallet {
     pub async fn transfer(&self, request: TransferRequest) -> Result<TransferProof> {
         let inner = self.inner.lock().await;
 
-        inner
-            .open_wallet(self.name.clone())
-            .await
-            .with_context(|| format!("Failed to open wallet {}", self.name))?;
-
         let TransferRequest {
             public_spend_key,
             public_view_key,
@@ -253,10 +249,8 @@ impl Wallet {
     }
 
     /// Get the balance of the primary account.
-    pub async fn get_balance(&self) -> Result<Amount> {
-        let amount = self.inner.lock().await.get_balance(0).await?.balance;
-
-        Ok(Amount::from_piconero(amount))
+    pub async fn get_balance(&self) -> Result<wallet::GetBalance> {
+        Ok(self.inner.lock().await.get_balance(0).await?)
     }
 
     pub async fn block_height(&self) -> Result<BlockHeight> {
@@ -314,8 +308,13 @@ async fn wait_for_confirmations<C: monero_rpc::wallet::MoneroWalletRpc<reqwest::
             .await
         {
             Ok(proof) => proof,
-            Err(jsonrpc::Error::JsonRpc(jsonrpc::JsonRpcError { code: -1, .. })) => {
-                tracing::warn!(%txid, "`monero-wallet-rpc` failed to fetch transaction, may need to be restarted");
+            Err(jsonrpc::Error::JsonRpc(jsonrpc::JsonRpcError {
+                code: -1,
+                message,
+                data,
+            })) => {
+                tracing::debug!(message, ?data);
+                tracing::warn!(%txid, message, "`monero-wallet-rpc` failed to fetch transaction, may need to be restarted");
                 continue;
             }
             // TODO: Implement this using a generic proxy for each function call once https://github.com/thomaseizinger/rust-jsonrpc-client/issues/47 is fixed.

swap/src/monero/wallet_rpc.rs

@@ -1,34 +1,75 @@
 use ::monero::Network;
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Error, Result};
 use big_bytes::BigByte;
+use data_encoding::HEXLOWER;
 use futures::{StreamExt, TryStreamExt};
 use monero_rpc::wallet::{Client, MoneroWalletRpc as _};
 use reqwest::header::CONTENT_LENGTH;
 use reqwest::Url;
+use serde::Deserialize;
+use sha2::{Digest, Sha256};
+use std::fmt;
+use std::fmt::{Debug, Display, Formatter};
 use std::io::ErrorKind;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
+use std::time::Duration;
 use tokio::fs::{remove_file, OpenOptions};
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, Command};
 use tokio_util::codec::{BytesCodec, FramedRead};
 use tokio_util::io::StreamReader;
 
+// See: https://www.moneroworld.com/#nodes, https://monero.fail
+// We don't need any testnet nodes because we don't support testnet at all
+const MONERO_DAEMONS: [MoneroDaemon; 17] = [
+    MoneroDaemon::new("xmr-node.cakewallet.com", 18081, Network::Mainnet),
+    MoneroDaemon::new("nodex.monerujo.io", 18081, Network::Mainnet),
+    MoneroDaemon::new("node.moneroworld.com", 18089, Network::Mainnet),
+    MoneroDaemon::new("nodes.hashvault.pro", 18081, Network::Mainnet),
+    MoneroDaemon::new("p2pmd.xmrvsbeast.com", 18081, Network::Mainnet),
+    MoneroDaemon::new("node.monerodevs.org", 18089, Network::Mainnet),
+    MoneroDaemon::new("xmr-node-usa-east.cakewallet.com", 18081, Network::Mainnet),
+    MoneroDaemon::new("xmr-node-uk.cakewallet.com", 18081, Network::Mainnet),
+    MoneroDaemon::new("node.community.rino.io", 18081, Network::Mainnet),
+    MoneroDaemon::new("testingjohnross.com", 20031, Network::Mainnet),
+    MoneroDaemon::new("xmr.litepay.ch", 18081, Network::Mainnet),
+    MoneroDaemon::new("node.trocador.app", 18089, Network::Mainnet),
+    MoneroDaemon::new("stagenet.xmr-tw.org", 38081, Network::Stagenet),
+    MoneroDaemon::new("node.monerodevs.org", 38089, Network::Stagenet),
+    MoneroDaemon::new("singapore.node.xmr.pm", 38081, Network::Stagenet),
+    MoneroDaemon::new("xmr-lux.boldsuck.org", 38081, Network::Stagenet),
+    MoneroDaemon::new("stagenet.community.rino.io", 38081, Network::Stagenet),
+];
+
 #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
 compile_error!("unsupported operating system");
 
-#[cfg(target_os = "macos")]
-const DOWNLOAD_URL: &str = "http://downloads.getmonero.org/cli/monero-mac-x64-v0.17.2.0.tar.bz2";
+#[cfg(all(target_os = "macos", target_arch = "x86_64"))]
+const DOWNLOAD_URL: &str = "https://downloads.getmonero.org/cli/monero-mac-x64-v0.18.3.1.tar.bz2";
+#[cfg(all(target_os = "macos", target_arch = "x86_64"))]
+const DOWNLOAD_HASH: &str = "7f8bd9364ef16482b418aa802a65be0e4cc660c794bb5d77b2d17bc84427883a";
+
+#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+const DOWNLOAD_URL: &str = "https://downloads.getmonero.org/cli/monero-mac-armv8-v0.18.3.1.tar.bz2";
+#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+const DOWNLOAD_HASH: &str = "915288b023cb5811e626e10052adc6ac5323dd283c5a25b91059b0fb86a21fb6";
 
 #[cfg(all(target_os = "linux", target_arch = "x86_64"))]
-const DOWNLOAD_URL: &str = "https://downloads.getmonero.org/cli/monero-linux-x64-v0.17.2.0.tar.bz2";
+const DOWNLOAD_URL: &str = "https://downloads.getmonero.org/cli/monero-linux-x64-v0.18.3.1.tar.bz2";
+#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
+const DOWNLOAD_HASH: &str = "23af572fdfe3459b9ab97e2e9aa7e3c11021c955d6064b801a27d7e8c21ae09d";
 
 #[cfg(all(target_os = "linux", target_arch = "arm"))]
 const DOWNLOAD_URL: &str =
-    "https://downloads.getmonero.org/cli/monero-linux-armv7-v0.17.2.0.tar.bz2";
+    "https://downloads.getmonero.org/cli/monero-linux-armv7-v0.18.3.1.tar.bz2";
+#[cfg(all(target_os = "linux", target_arch = "arm"))]
+const DOWNLOAD_HASH: &str = "2ea2c8898cbab88f49423f4f6c15f2a94046cb4bbe827493dd061edc0fd5f1ca";
 
 #[cfg(target_os = "windows")]
-const DOWNLOAD_URL: &str = "https://downloads.getmonero.org/cli/monero-win-x64-v0.17.2.0.zip";
+const DOWNLOAD_URL: &str = "https://downloads.getmonero.org/cli/monero-win-x64-v0.18.3.1.zip";
+#[cfg(target_os = "windows")]
+const DOWNLOAD_HASH: &str = "35dcc4bee4caad3442659d37837e0119e4649a77f2e3b5e80dd6d9b8fc4fb6ad";
 
 #[cfg(any(target_os = "macos", target_os = "linux"))]
 const PACKED_FILE: &str = "monero-wallet-rpc";
@@ -36,6 +77,8 @@ const PACKED_FILE: &str = "monero-wallet-rpc";
 #[cfg(target_os = "windows")]
 const PACKED_FILE: &str = "monero-wallet-rpc.exe";
 
+const WALLET_RPC_VERSION: &str = "v0.18.3.1";
+
 #[derive(Debug, Clone, Copy, thiserror::Error)]
 #[error("monero wallet rpc executable not found in downloaded archive")]
 pub struct ExecutableNotFoundInArchive;
@@ -45,6 +88,91 @@ pub struct WalletRpcProcess {
     port: u16,
 }
 
+struct MoneroDaemon {
+    address: &'static str,
+    port: u16,
+    network: Network,
+}
+
+impl MoneroDaemon {
+    const fn new(address: &'static str, port: u16, network: Network) -> Self {
+        Self {
+            address,
+            port,
+            network,
+        }
+    }
+
+    /// Checks if the Monero daemon is available by sending a request to its `get_info` endpoint.
+    async fn is_available(&self, client: &reqwest::Client) -> Result<bool, Error> {
+        let url = format!("http://{}:{}/get_info", self.address, self.port);
+        let res = client
+            .get(url)
+            .send()
+            .await
+            .context("Failed to send request to get_info endpoint")?;
+
+        let json: MoneroDaemonGetInfoResponse = res
+            .json()
+            .await
+            .context("Failed to deserialize daemon get_info response")?;
+
+        let is_status_ok = json.status == "OK";
+        let is_synchronized = json.synchronized;
+        let is_correct_network = match self.network {
+            Network::Mainnet => json.mainnet,
+            Network::Stagenet => json.stagenet,
+            Network::Testnet => json.testnet,
+        };
+
+        Ok(is_status_ok && is_synchronized && is_correct_network)
+    }
+}
+
+impl Display for MoneroDaemon {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}", self.address, self.port)
+    }
+}
+
+#[derive(Deserialize)]
+struct MoneroDaemonGetInfoResponse {
+    status: String,
+    synchronized: bool,
+    mainnet: bool,
+    stagenet: bool,
+    testnet: bool,
+}
+
+/// Chooses an available Monero daemon based on the specified network.
+async fn choose_monero_daemon(network: Network) -> Result<&'static MoneroDaemon, Error> {
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(30))
+        .https_only(false)
+        .build()?;
+
+    // We only want to check for daemons that match the specified network
+    let network_matching_daemons = MONERO_DAEMONS
+        .iter()
+        .filter(|daemon| daemon.network == network);
+
+    for daemon in network_matching_daemons {
+        match daemon.is_available(&client).await {
+            Ok(true) => {
+                tracing::debug!(%daemon, "Found available Monero daemon");
+                return Ok(daemon);
+            }
+            Err(err) => {
+                tracing::debug!(%err, %daemon, "Failed to connect to Monero daemon");
+                continue;
+            }
+            Ok(false) => continue,
+        }
+    }
+
+    bail!("No Monero daemon could be found. Please specify one manually or try again later.")
+}
+
 impl WalletRpcProcess {
     pub fn endpoint(&self) -> Url {
         Url::parse(&format!("http://127.0.0.1:{}/json_rpc", self.port))
@@ -72,6 +200,22 @@ impl WalletRpc {
             remove_file(monero_wallet_rpc.archive_path()).await?;
         }
 
+        // check the monero-wallet-rpc version
+        let exec_path = monero_wallet_rpc.exec_path();
+        tracing::debug!("RPC exec path: {}", exec_path.display());
+
+        if exec_path.exists() {
+            let output = Command::new(&exec_path).arg("--version").output().await?;
+            let version = String::from_utf8_lossy(&output.stdout);
+            tracing::debug!("RPC version output: {}", version);
+
+            if !version.contains(WALLET_RPC_VERSION) {
+                tracing::info!("Removing old version of monero-wallet-rpc");
+                tokio::fs::remove_file(exec_path).await?;
+            }
+        }
+
+        // if monero-wallet-rpc doesn't exist then download it
         if !monero_wallet_rpc.exec_path().exists() {
             let mut options = OpenOptions::new();
             let mut file = options
@@ -89,13 +233,20 @@ impl WalletRpc {
                 .parse::<u64>()?;
 
             tracing::info!(
-                "Downloading monero-wallet-rpc ({}) from {}",
-                content_length.big_byte(2),
-                DOWNLOAD_URL
+                progress="0%",
+                size=%content_length.big_byte(2),
+                download_url=DOWNLOAD_URL,
+                "Downloading monero-wallet-rpc",
             );
 
+            let mut hasher = Sha256::new();
+
             let byte_stream = response
                 .bytes_stream()
+                .map_ok(|bytes| {
+                    hasher.update(&bytes);
+                    bytes
+                })
                 .map_err(|err| std::io::Error::new(ErrorKind::Other, err));
 
             #[cfg(not(target_os = "windows"))]
@@ -109,24 +260,70 @@ impl WalletRpc {
             let mut stream = FramedRead::new(StreamReader::new(byte_stream), BytesCodec::new())
                 .map_ok(|bytes| bytes.freeze());
 
+            let (mut received, mut notified) = (0, 0);
             while let Some(chunk) = stream.next().await {
-                file.write(&chunk?).await?;
+                let bytes = chunk?;
+                received += bytes.len();
+                // the stream is decompressed as it is downloaded
+                // file is compressed approx 3:1 in bz format
+                let total = 3 * content_length;
+                let percent = 100 * received as u64 / total;
+                if percent != notified && percent % 10 == 0 {
+                    tracing::info!(
+                        progress=format!("{}%", percent),
+                        size=%content_length.big_byte(2),
+                        download_url=DOWNLOAD_URL,
+                        "Downloading monero-wallet-rpc",
+                    );
+                    notified = percent;
+                }
+                file.write_all(&bytes).await?;
+            }
+
+            tracing::info!(
+                progress="100%",
+                size=%content_length.big_byte(2),
+                download_url=DOWNLOAD_URL,
+                "Downloading monero-wallet-rpc",
+            );
+
+            let result = hasher.finalize();
+            let result_hash = HEXLOWER.encode(result.as_ref());
+            if result_hash != DOWNLOAD_HASH {
+                bail!(
+                    "SHA256 of download ({}) does not match expected ({})!",
+                    result_hash,
+                    DOWNLOAD_HASH
+                );
+            } else {
+                tracing::debug!("Hashes match");
             }
 
             file.flush().await?;
 
+            tracing::debug!("Extracting archive");
             Self::extract_archive(&monero_wallet_rpc).await?;
         }
         Ok(monero_wallet_rpc)
     }
 
-    pub async fn run(&self, network: Network, daemon_address: &str) -> Result<WalletRpcProcess> {
+    pub async fn run(
+        &self,
+        network: Network,
+        daemon_address: Option<String>,
+    ) -> Result<WalletRpcProcess> {
         let port = tokio::net::TcpListener::bind("127.0.0.1:0")
             .await?
             .local_addr()?
             .port();
 
+        let daemon_address = match daemon_address {
+            Some(daemon_address) => daemon_address,
+            None => choose_monero_daemon(network).await?.to_string(),
+        };
+
         tracing::debug!(
+            %daemon_address,
             %port,
             "Starting monero-wallet-rpc"
         );
@@ -172,7 +369,7 @@ impl WalletRpc {
         }
 
         // If we do not hear from the monero_wallet_rpc process for 3 seconds we assume
-        // it is is ready
+        // it is ready
         #[cfg(target_os = "windows")]
         while let Ok(line) =
             tokio::time::timeout(std::time::Duration::from_secs(3), reader.next_line()).await
@@ -199,7 +396,6 @@ impl WalletRpc {
 
     #[cfg(not(target_os = "windows"))]
     async fn extract_archive(monero_wallet_rpc: &Self) -> Result<()> {
-        use anyhow::bail;
         use tokio_tar::Archive;
 
         let mut options = OpenOptions::new();
@@ -264,3 +460,123 @@ impl WalletRpc {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn extract_host_and_port(address: String) -> (&'static str, u16) {
+        let parts: Vec<&str> = address.split(':').collect();
+
+        if parts.len() == 2 {
+            let host = parts[0].to_string();
+            let port = parts[1].parse::<u16>().unwrap();
+            let static_str_host: &'static str = Box::leak(host.into_boxed_str());
+            return (static_str_host, port);
+        }
+        panic!("Could not extract host and port from address: {}", address)
+    }
+
+    #[tokio::test]
+    async fn test_is_daemon_available_success() {
+        let mut server = mockito::Server::new();
+
+        let _ = server
+            .mock("GET", "/get_info")
+            .with_status(200)
+            .with_body(
+                r#"
+                {
+                    "status": "OK",
+                    "synchronized": true,
+                    "mainnet": true,
+                    "stagenet": false,
+                    "testnet": false
+                }
+                "#,
+            )
+            .create();
+
+        let (host, port) = extract_host_and_port(server.host_with_port());
+
+        let client = reqwest::Client::new();
+        let result = MoneroDaemon::new(host, port, Network::Mainnet)
+            .is_available(&client)
+            .await;
+
+        assert!(result.is_ok());
+        assert!(result.unwrap());
+    }
+
+    #[tokio::test]
+    async fn test_is_daemon_available_wrong_network_failure() {
+        let mut server = mockito::Server::new();
+
+        let _ = server
+            .mock("GET", "/get_info")
+            .with_status(200)
+            .with_body(
+                r#"
+                {
+                    "status": "OK",
+                    "synchronized": true,
+                    "mainnet": true,
+                    "stagenet": false,
+                    "testnet": false
+                }
+                "#,
+            )
+            .create();
+
+        let (host, port) = extract_host_and_port(server.host_with_port());
+
+        let client = reqwest::Client::new();
+        let result = MoneroDaemon::new(host, port, Network::Stagenet)
+            .is_available(&client)
+            .await;
+
+        assert!(result.is_ok());
+        assert!(!result.unwrap());
+    }
+
+    #[tokio::test]
+    async fn test_is_daemon_available_not_synced_failure() {
+        let mut server = mockito::Server::new();
+
+        let _ = server
+            .mock("GET", "/get_info")
+            .with_status(200)
+            .with_body(
+                r#"
+                {
+                    "status": "OK",
+                    "synchronized": false,
+                    "mainnet": true,
+                    "stagenet": false,
+                    "testnet": false
+                }
+                "#,
+            )
+            .create();
+
+        let (host, port) = extract_host_and_port(server.host_with_port());
+
+        let client = reqwest::Client::new();
+        let result = MoneroDaemon::new(host, port, Network::Mainnet)
+            .is_available(&client)
+            .await;
+
+        assert!(result.is_ok());
+        assert!(!result.unwrap());
+    }
+
+    #[tokio::test]
+    async fn test_is_daemon_available_network_error_failure() {
+        let client = reqwest::Client::new();
+        let result = MoneroDaemon::new("does.not.exist.com", 18081, Network::Mainnet)
+            .is_available(&client)
+            .await;
+
+        assert!(result.is_err());
+    }
+}

swap/src/monero_ext.rs

@@ -1,5 +1,5 @@
 use crate::bitcoin::Scalar;
-use ecdsa_fun::fun::marker::{Mark, NonZero, Secret};
+use ecdsa_fun::fun::marker::{NonZero, Secret};
 
 pub trait ScalarExt {
     fn to_secpfun_scalar(&self) -> ecdsa_fun::fun::Scalar;
@@ -14,7 +14,7 @@ impl ScalarExt for crate::monero::Scalar {
 
         ecdsa_fun::fun::Scalar::from_bytes(big_endian_bytes)
             .expect("valid scalar")
-            .mark::<NonZero>()
+            .non_zero()
             .expect("non-zero scalar")
     }
 }

swap/src/network/cbor_request_response.rs

@@ -19,7 +19,7 @@ pub struct CborCodec<P, Req, Res> {
 impl<P, Req, Res> Default for CborCodec<P, Req, Res> {
     fn default() -> Self {
         Self {
-            phantom: PhantomData::default(),
+            phantom: PhantomData,
         }
     }
 }

swap/src/network/json_pull_codec.rs

@@ -25,7 +25,7 @@ pub struct JsonPullCodec<P, Res> {
 impl<P, Res> Default for JsonPullCodec<P, Res> {
     fn default() -> Self {
         Self {
-            phantom: PhantomData::default(),
+            phantom: PhantomData,
         }
     }
 }

swap/src/network/quote.rs

@@ -37,6 +37,10 @@ pub struct BidQuote {
     pub max_quantity: bitcoin::Amount,
 }
 
+#[derive(Clone, Copy, Debug, thiserror::Error)]
+#[error("Received quote of 0")]
+pub struct ZeroQuoteReceived;
+
 /// Constructs a new instance of the `quote` behaviour to be used by the ASB.
 ///
 /// The ASB is always listening and only supports inbound connections, i.e.

swap/src/network/redial.rs

@@ -4,8 +4,9 @@ use backoff::ExponentialBackoff;
 use futures::future::FutureExt;
 use libp2p::core::connection::ConnectionId;
 use libp2p::core::Multiaddr;
+use libp2p::swarm::dial_opts::{DialOpts, PeerCondition};
 use libp2p::swarm::protocols_handler::DummyProtocolsHandler;
-use libp2p::swarm::{DialPeerCondition, NetworkBehaviour, NetworkBehaviourAction, PollParameters};
+use libp2p::swarm::{NetworkBehaviour, NetworkBehaviourAction, PollParameters};
 use libp2p::PeerId;
 use std::pin::Pin;
 use std::task::{Context, Poll};
@@ -112,9 +113,10 @@ impl NetworkBehaviour for Behaviour {
 
         self.sleep = Some(Box::pin(tokio::time::sleep(next_dial_in)));
 
-        Poll::Ready(NetworkBehaviourAction::DialPeer {
-            peer_id: self.peer,
-            condition: DialPeerCondition::Disconnected,
+        Poll::Ready(NetworkBehaviourAction::Dial {
+            opts: DialOpts::peer_id(self.peer)
+                .condition(PeerCondition::Disconnected)
+                .build(),
             handler: Self::ProtocolsHandler::default(),
         })
     }

swap/src/network/rendezvous.rs

@@ -1,7 +1,7 @@
 use libp2p::rendezvous::Namespace;
 use std::fmt;
 
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum XmrBtcNamespace {
     Mainnet,
     Testnet,
@@ -27,3 +27,13 @@ impl From<XmrBtcNamespace> for Namespace {
         }
     }
 }
+
+impl XmrBtcNamespace {
+    pub fn from_is_testnet(testnet: bool) -> XmrBtcNamespace {
+        if testnet {
+            XmrBtcNamespace::Testnet
+        } else {
+            XmrBtcNamespace::Mainnet
+        }
+    }
+}

swap/src/network/swap_setup.rs

@@ -37,7 +37,7 @@ pub mod protocol {
     >;
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct BlockchainNetwork {
     #[serde(with = "crate::bitcoin::network")]
     pub bitcoin: bitcoin::Network,

swap/src/network/swap_setup/alice.rs

@@ -1,4 +1,5 @@
 use crate::asb::LatestRate;
+use crate::monero::Amount;
 use crate::network::swap_setup;
 use crate::network::swap_setup::{
     protocol, BlockchainNetwork, SpotPriceError, SpotPriceRequest, SpotPriceResponse,
@@ -42,7 +43,7 @@ pub enum OutEvent {
 
 #[derive(Debug)]
 pub struct WalletSnapshot {
-    balance: monero::Amount,
+    balance: monero_rpc::wallet::GetBalance,
     lock_fee: monero::Amount,
 
     // TODO: Consider using the same address for punish and redeem (they are mutually exclusive, so
@@ -58,11 +59,17 @@ impl WalletSnapshot {
     pub async fn capture(
         bitcoin_wallet: &bitcoin::Wallet,
         monero_wallet: &monero::Wallet,
+        external_redeem_address: &Option<bitcoin::Address>,
         transfer_amount: bitcoin::Amount,
     ) -> Result<Self> {
         let balance = monero_wallet.get_balance().await?;
-        let redeem_address = bitcoin_wallet.new_address().await?;
-        let punish_address = bitcoin_wallet.new_address().await?;
+        let redeem_address = external_redeem_address
+            .clone()
+            .unwrap_or(bitcoin_wallet.new_address().await?);
+        let punish_address = external_redeem_address
+            .clone()
+            .unwrap_or(bitcoin_wallet.new_address().await?);
+
         let redeem_fee = bitcoin_wallet
             .estimate_fee(bitcoin::TxRedeem::weight(), transfer_amount)
             .await?;
@@ -323,7 +330,8 @@ where
                     .sell_quote(btc)
                     .map_err(Error::SellQuoteCalculationFailed)?;
 
-                if wallet_snapshot.balance < xmr + wallet_snapshot.lock_fee {
+                let unlocked = Amount::from_piconero(wallet_snapshot.balance.unlocked_balance);
+                if unlocked < xmr + wallet_snapshot.lock_fee {
                     return Err(Error::BalanceTooLow {
                         balance: wallet_snapshot.balance,
                         buy: btc,
@@ -479,9 +487,9 @@ pub enum Error {
         max: bitcoin::Amount,
         buy: bitcoin::Amount,
     },
-    #[error("Balance {balance} too low to fulfill swapping {buy}")]
+    #[error("Unlocked balance ({balance}) too low to fulfill swapping {buy}")]
     BalanceTooLow {
-        balance: monero::Amount,
+        balance: monero_rpc::wallet::GetBalance,
         buy: bitcoin::Amount,
     },
     #[error("Failed to fetch latest rate")]

swap/src/network/swap_setup/bob.rs

@@ -155,13 +155,16 @@ impl ProtocolsHandler for Handler {
         let env_config = self.env_config;
 
         let protocol = tokio::time::timeout(self.timeout, async move {
-            write_cbor_message(&mut substream, SpotPriceRequest {
-                btc: info.btc,
-                blockchain_network: BlockchainNetwork {
-                    bitcoin: env_config.bitcoin_network,
-                    monero: env_config.monero_network,
+            write_cbor_message(
+                &mut substream,
+                SpotPriceRequest {
+                    btc: info.btc,
+                    blockchain_network: BlockchainNetwork {
+                        bitcoin: env_config.bitcoin_network,
+                        monero: env_config.monero_network,
+                    },
                 },
-            })
+            )
             .await?;
 
             let xmr = Result::from(read_cbor_message::<SpotPriceResponse>(&mut substream).await?)?;
@@ -258,7 +261,7 @@ impl From<SpotPriceResponse> for Result<monero::Amount, Error> {
     }
 }
 
-#[derive(Clone, Debug, thiserror::Error, PartialEq)]
+#[derive(Clone, Debug, thiserror::Error, PartialEq, Eq)]
 pub enum Error {
     #[error("Seller currently does not accept incoming swap requests, please try again later")]
     NoSwapsAccepted,

swap/src/network/swarm.rs

@@ -1,9 +1,9 @@
-use crate::asb::LatestRate;
+use crate::asb::{LatestRate, RendezvousNode};
 use crate::libp2p_ext::MultiAddrExt;
 use crate::network::rendezvous::XmrBtcNamespace;
 use crate::seed::Seed;
 use crate::{asb, bitcoin, cli, env, tor};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use libp2p::swarm::{NetworkBehaviour, SwarmBuilder};
 use libp2p::{identity, Multiaddr, Swarm};
 use std::fmt::Debug;
@@ -16,22 +16,24 @@ pub fn asb<LR>(
     latest_rate: LR,
     resume_only: bool,
     env_config: env::Config,
-    rendezvous_params: Option<(Multiaddr, XmrBtcNamespace)>,
+    namespace: XmrBtcNamespace,
+    rendezvous_addrs: &[Multiaddr],
 ) -> Result<Swarm<asb::Behaviour<LR>>>
 where
     LR: LatestRate + Send + 'static + Debug + Clone,
 {
     let identity = seed.derive_libp2p_identity();
 
-    let rendezvous_params = if let Some((address, namespace)) = rendezvous_params {
-        let peer_id = address
-            .extract_peer_id()
-            .context("Rendezvous node address must contain peer ID")?;
+    let rendezvous_nodes = rendezvous_addrs
+        .iter()
+        .map(|addr| {
+            let peer_id = addr
+                .extract_peer_id()
+                .expect("Rendezvous node address must contain peer ID");
 
-        Some((identity.clone(), peer_id, address, namespace))
-    } else {
-        None
-    };
+            RendezvousNode::new(addr, peer_id, namespace, None)
+        })
+        .collect();
 
     let behaviour = asb::Behaviour::new(
         min_buy,
@@ -39,7 +41,8 @@ where
         latest_rate,
         resume_only,
         env_config,
-        rendezvous_params,
+        (identity.clone(), namespace),
+        rendezvous_nodes,
     );
 
     let transport = asb::transport::new(&identity)?;

swap/src/network/test.rs

@@ -21,7 +21,7 @@ struct GlobalSpawnTokioExecutor;
 
 impl Executor for GlobalSpawnTokioExecutor {
     fn exec(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
-        let _ = tokio::spawn(future);
+        tokio::spawn(future);
     }
 }
 
@@ -40,7 +40,7 @@ where
         .expect("failed to create dh_keys");
     let noise = NoiseConfig::xx(dh_keys).into_authenticated();
 
-    let transport = MemoryTransport::default()
+    let transport = MemoryTransport
         .or_transport(TokioTcpConfig::new())
         .upgrade(Version::V1)
         .authenticate(noise)
@@ -129,8 +129,9 @@ where
         <T as NetworkBehaviour>::OutEvent: Debug,
     {
         let addr_to_dial = other.external_addresses().next().unwrap().addr.clone();
+        let local_peer_id = *other.local_peer_id();
 
-        self.dial_addr(addr_to_dial.clone()).unwrap();
+        self.dial(addr_to_dial).unwrap();
 
         let mut dialer_done = false;
         let mut listener_done = false;
@@ -144,8 +145,8 @@ where
                         SwarmEvent::ConnectionEstablished { .. } => {
                             dialer_done = true;
                         }
-                        SwarmEvent::UnknownPeerUnreachableAddr { address, error } if address == addr_to_dial => {
-                            panic!("Failed to dial address {}: {}", addr_to_dial, error)
+                        SwarmEvent::OutgoingConnectionError { peer_id, error } if matches!(peer_id, Some(alice_peer_id) if alice_peer_id == local_peer_id) => {
+                                panic!("Failed to dial address {}: {}", peer_id.unwrap(), error)
                         }
                         other => {
                             tracing::debug!("Ignoring {:?}", other);

swap/src/network/tor_transport.rs

@@ -60,6 +60,28 @@ impl Transport for TorDialOnlyTransport {
     fn address_translation(&self, _: &Multiaddr, _: &Multiaddr) -> Option<Multiaddr> {
         None
     }
+    fn dial_as_listener(self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
+        let address = TorCompatibleAddress::from_multiaddr(Cow::Borrowed(&addr))?;
+
+        if address.is_certainly_not_reachable_via_tor_daemon() {
+            return Err(TransportError::MultiaddrNotSupported(addr));
+        }
+
+        let dial_future = async move {
+            tracing::debug!(address = %addr, "Establishing connection through Tor proxy");
+
+            let stream =
+                Socks5Stream::connect((Ipv4Addr::LOCALHOST, self.socks_port), address.to_string())
+                    .await
+                    .map_err(|e| io::Error::new(io::ErrorKind::ConnectionRefused, e))?;
+
+            tracing::debug!("Connection through Tor established");
+
+            Ok(TcpStream(stream.into_inner()))
+        };
+
+        Ok(dial_future.boxed())
+    }
 }
 
 /// Represents an address that is _compatible_ with Tor, i.e. can be resolved by

swap/src/proptest.rs

@@ -2,16 +2,15 @@ use proptest::prelude::*;
 
 pub mod ecdsa_fun {
     use super::*;
-    use ::ecdsa_fun::fun::marker::{Mark, NonZero, Normal};
     use ::ecdsa_fun::fun::{Point, Scalar, G};
 
     pub fn point() -> impl Strategy<Value = Point> {
-        scalar().prop_map(|mut scalar| Point::from_scalar_mul(&G, &mut scalar).mark::<Normal>())
+        scalar().prop_map(|mut scalar| Point::even_y_from_scalar_mul(G, &mut scalar).normalize())
     }
 
     pub fn scalar() -> impl Strategy<Value = Scalar> {
         prop::array::uniform32(0..255u8).prop_filter_map("generated the 0 element", |bytes| {
-            Scalar::from_bytes_mod_order(bytes).mark::<NonZero>()
+            Scalar::from_bytes_mod_order(bytes).non_zero()
         })
     }
 }

swap/src/protocol.rs

@@ -6,12 +6,12 @@ use crate::{bitcoin, monero};
 use anyhow::Result;
 use async_trait::async_trait;
 use conquer_once::Lazy;
-use ecdsa_fun::fun::marker::Mark;
 use libp2p::{Multiaddr, PeerId};
 use serde::{Deserialize, Serialize};
 use sha2::Sha256;
 use sigma_fun::ext::dl_secp256k1_ed25519_eq::{CrossCurveDLEQ, CrossCurveDLEQProof};
 use sigma_fun::HashTranscript;
+use std::collections::HashMap;
 use std::convert::TryInto;
 use uuid::Uuid;
 
@@ -22,7 +22,7 @@ pub static CROSS_CURVE_PROOF_SYSTEM: Lazy<
     CrossCurveDLEQ<HashTranscript<Sha256, rand_chacha::ChaCha20Rng>>,
 > = Lazy::new(|| {
     CrossCurveDLEQ::<HashTranscript<Sha256, rand_chacha::ChaCha20Rng>>::new(
-        (*ecdsa_fun::fun::G).mark::<ecdsa_fun::fun::marker::Normal>(),
+        (*ecdsa_fun::fun::G).normalize(),
         curve25519_dalek::constants::ED25519_BASEPOINT_POINT,
     )
 });
@@ -102,11 +102,11 @@ impl From<BobState> for State {
     }
 }
 
-#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq)]
+#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq)]
 #[error("Not in the role of Alice")]
 pub struct NotAlice;
 
-#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq)]
+#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq)]
 #[error("Not in the role of Bob")]
 pub struct NotBob;
 
@@ -140,7 +140,10 @@ pub trait Database {
     async fn get_monero_address(&self, swap_id: Uuid) -> Result<monero::Address>;
     async fn insert_address(&self, peer_id: PeerId, address: Multiaddr) -> Result<()>;
     async fn get_addresses(&self, peer_id: PeerId) -> Result<Vec<Multiaddr>>;
+    async fn get_swap_start_date(&self, swap_id: Uuid) -> Result<String>;
     async fn insert_latest_state(&self, swap_id: Uuid, state: State) -> Result<()>;
     async fn get_state(&self, swap_id: Uuid) -> Result<State>;
+    async fn get_states(&self, swap_id: Uuid) -> Result<Vec<State>>;
     async fn all(&self) -> Result<Vec<(Uuid, State)>>;
+    async fn raw_all(&self) -> Result<HashMap<Uuid, Vec<serde_json::Value>>>;
 }

swap/src/protocol/alice/state.rs

@@ -184,29 +184,32 @@ impl State0 {
 
         let v = self.v_a + msg.v_b;
 
-        Ok((msg.swap_id, State1 {
-            a: self.a,
-            B: msg.B,
-            s_a: self.s_a,
-            S_a_monero: self.S_a_monero,
-            S_a_bitcoin: self.S_a_bitcoin,
-            S_b_monero: msg.S_b_monero,
-            S_b_bitcoin: msg.S_b_bitcoin,
-            v,
-            v_a: self.v_a,
-            dleq_proof_s_a: self.dleq_proof_s_a,
-            btc: self.btc,
-            xmr: self.xmr,
-            cancel_timelock: self.cancel_timelock,
-            punish_timelock: self.punish_timelock,
-            refund_address: msg.refund_address,
-            redeem_address: self.redeem_address,
-            punish_address: self.punish_address,
-            tx_redeem_fee: self.tx_redeem_fee,
-            tx_punish_fee: self.tx_punish_fee,
-            tx_refund_fee: msg.tx_refund_fee,
-            tx_cancel_fee: msg.tx_cancel_fee,
-        }))
+        Ok((
+            msg.swap_id,
+            State1 {
+                a: self.a,
+                B: msg.B,
+                s_a: self.s_a,
+                S_a_monero: self.S_a_monero,
+                S_a_bitcoin: self.S_a_bitcoin,
+                S_b_monero: msg.S_b_monero,
+                S_b_bitcoin: msg.S_b_bitcoin,
+                v,
+                v_a: self.v_a,
+                dleq_proof_s_a: self.dleq_proof_s_a,
+                btc: self.btc,
+                xmr: self.xmr,
+                cancel_timelock: self.cancel_timelock,
+                punish_timelock: self.punish_timelock,
+                refund_address: msg.refund_address,
+                redeem_address: self.redeem_address,
+                punish_address: self.punish_address,
+                tx_redeem_fee: self.tx_redeem_fee,
+                tx_punish_fee: self.tx_punish_fee,
+                tx_refund_fee: msg.tx_refund_fee,
+                tx_cancel_fee: msg.tx_cancel_fee,
+            },
+        ))
     }
 }
 
@@ -307,7 +310,8 @@ impl State2 {
             self.a.public(),
             self.B,
             self.tx_cancel_fee,
-        );
+        )
+        .expect("valid cancel tx");
 
         let tx_refund =
             bitcoin::TxRefund::new(&tx_cancel, &self.refund_address, self.tx_refund_fee);
@@ -332,7 +336,7 @@ impl State2 {
             self.a.public(),
             self.B,
             self.tx_cancel_fee,
-        );
+        )?;
         bitcoin::verify_sig(&self.B, &tx_cancel.digest(), &msg.tx_cancel_sig)
             .context("Failed to verify cancel transaction")?;
         let tx_punish = bitcoin::TxPunish::new(
@@ -455,6 +459,7 @@ impl State3 {
             self.B,
             self.tx_cancel_fee,
         )
+        .expect("valid cancel tx")
     }
 
     pub fn tx_refund(&self) -> TxRefund {

swap/src/protocol/alice/swap.rs

@@ -112,7 +112,7 @@ where
         }
         AliceState::BtcLocked { state3 } => {
             match state3.expired_timelocks(bitcoin_wallet).await? {
-                ExpiredTimelocks::None => {
+                ExpiredTimelocks::None { .. } => {
                     // Record the current monero wallet block height so we don't have to scan from
                     // block 0 for scenarios where we create a refund wallet.
                     let monero_wallet_restore_blockheight = monero_wallet.block_height().await?;
@@ -135,7 +135,7 @@ where
             transfer_proof,
             state3,
         } => match state3.expired_timelocks(bitcoin_wallet).await? {
-            ExpiredTimelocks::None => {
+            ExpiredTimelocks::None { .. } => {
                 monero_wallet
                     .watch_for_transfer(state3.lock_xmr_watch_request(transfer_proof.clone(), 1))
                     .await
@@ -176,7 +176,7 @@ where
                    }
                 },
                 result = tx_lock_status.wait_until_confirmed_with(state3.cancel_timelock) => {
-                    let _ = result?;
+                    result?;
                     AliceState::CancelTimelockExpired {
                         monero_wallet_restore_blockheight,
                         transfer_proof,
@@ -196,7 +196,7 @@ where
                 biased; // make sure the cancel timelock expiry future is polled first
 
                 result = tx_lock_status.wait_until_confirmed_with(state3.cancel_timelock) => {
-                    let _ = result?;
+                    result?;
                     AliceState::CancelTimelockExpired {
                         monero_wallet_restore_blockheight,
                         transfer_proof,
@@ -221,7 +221,7 @@ where
             encrypted_signature,
             state3,
         } => match state3.expired_timelocks(bitcoin_wallet).await? {
-            ExpiredTimelocks::None => {
+            ExpiredTimelocks::None { .. } => {
                 let tx_lock_status = bitcoin_wallet.subscribe_to(state3.tx_lock.clone()).await;
                 match state3.signed_redeem_transaction(*encrypted_signature) {
                     Ok(tx) => match bitcoin_wallet.broadcast(tx, "redeem").await {
@@ -326,7 +326,7 @@ where
                     }
                 }
                 result = tx_cancel_status.wait_until_confirmed_with(state3.punish_timelock) => {
-                    let _ = result?;
+                    result?;
 
                     AliceState::BtcPunishable {
                         monero_wallet_restore_blockheight,

swap/src/protocol/bob/state.rs

@@ -1,4 +1,4 @@
-use crate::bitcoin::wallet::EstimateFeeRate;
+use crate::bitcoin::wallet::{EstimateFeeRate, Subscription};
 use crate::bitcoin::{
     self, current_epoch, CancelTimelock, ExpiredTimelocks, PunishTimelock, Transaction, TxCancel,
     TxLock, Txid,
@@ -21,9 +21,10 @@ use sigma_fun::ext::dl_secp256k1_ed25519_eq::CrossCurveDLEQProof;
 use std::fmt;
 use uuid::Uuid;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize)]
 pub enum BobState {
     Started {
+        #[serde(with = "::bitcoin::util::amount::serde::as_sat")]
         btc_amount: bitcoin::Amount,
         change_address: bitcoin::Address,
     },
@@ -149,9 +150,9 @@ impl State0 {
         }
     }
 
-    pub async fn receive<B, D, C>(
+    pub async fn receive<D, C>(
         self,
-        wallet: &bitcoin::Wallet<B, D, C>,
+        wallet: &bitcoin::Wallet<D, C>,
         msg: Message1,
     ) -> Result<State1>
     where
@@ -242,7 +243,7 @@ impl State1 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )?;
         let tx_refund =
             bitcoin::TxRefund::new(&tx_cancel, &self.refund_address, self.tx_refund_fee);
 
@@ -287,13 +288,13 @@ pub struct State2 {
     S_a_monero: monero::PublicKey,
     S_a_bitcoin: bitcoin::PublicKey,
     v: monero::PrivateViewKey,
-    xmr: monero::Amount,
-    cancel_timelock: CancelTimelock,
-    punish_timelock: PunishTimelock,
-    refund_address: bitcoin::Address,
+    pub xmr: monero::Amount,
+    pub cancel_timelock: CancelTimelock,
+    pub punish_timelock: PunishTimelock,
+    pub refund_address: bitcoin::Address,
     redeem_address: bitcoin::Address,
     punish_address: bitcoin::Address,
-    tx_lock: bitcoin::TxLock,
+    pub tx_lock: bitcoin::TxLock,
     tx_cancel_sig_a: Signature,
     tx_refund_encsig: bitcoin::EncryptedSignature,
     min_monero_confirmations: u64,
@@ -302,9 +303,9 @@ pub struct State2 {
     #[serde(with = "::bitcoin::util::amount::serde::as_sat")]
     tx_punish_fee: bitcoin::Amount,
     #[serde(with = "::bitcoin::util::amount::serde::as_sat")]
-    tx_refund_fee: bitcoin::Amount,
+    pub tx_refund_fee: bitcoin::Amount,
     #[serde(with = "::bitcoin::util::amount::serde::as_sat")]
-    tx_cancel_fee: bitcoin::Amount,
+    pub tx_cancel_fee: bitcoin::Amount,
 }
 
 impl State2 {
@@ -315,7 +316,8 @@ impl State2 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )
+        .expect("valid cancel tx");
         let tx_cancel_sig = self.b.sign(tx_cancel.digest());
         let tx_punish = bitcoin::TxPunish::new(
             &tx_cancel,
@@ -439,7 +441,7 @@ impl State3 {
         self.tx_lock.txid()
     }
 
-    pub async fn current_epoch(
+    pub async fn expired_timelock(
         &self,
         bitcoin_wallet: &bitcoin::Wallet,
     ) -> Result<ExpiredTimelocks> {
@@ -449,7 +451,7 @@ impl State3 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )?;
 
         let tx_lock_status = bitcoin_wallet.status_of_script(&self.tx_lock).await?;
         let tx_cancel_status = bitcoin_wallet.status_of_script(&tx_cancel).await?;
@@ -487,6 +489,27 @@ pub struct State4 {
 }
 
 impl State4 {
+    pub async fn check_for_tx_redeem(&self, bitcoin_wallet: &bitcoin::Wallet) -> Result<State5> {
+        let tx_redeem =
+            bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address, self.tx_redeem_fee);
+        let tx_redeem_encsig = self.b.encsign(self.S_a_bitcoin, tx_redeem.digest());
+
+        let tx_redeem_candidate = bitcoin_wallet.get_raw_transaction(tx_redeem.txid()).await?;
+
+        let tx_redeem_sig =
+            tx_redeem.extract_signature_by_key(tx_redeem_candidate, self.b.public())?;
+        let s_a = bitcoin::recover(self.S_a_bitcoin, tx_redeem_sig, tx_redeem_encsig)?;
+        let s_a = monero::private_key_from_secp256k1_scalar(s_a.into());
+
+        Ok(State5 {
+            s_a,
+            s_b: self.s_b,
+            v: self.v,
+            tx_lock: self.tx_lock.clone(),
+            monero_wallet_restore_blockheight: self.monero_wallet_restore_blockheight,
+        })
+    }
+
     pub fn tx_redeem_encsig(&self) -> bitcoin::EncryptedSignature {
         let tx_redeem =
             bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address, self.tx_redeem_fee);
@@ -530,7 +553,7 @@ impl State4 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )?;
 
         let tx_lock_status = bitcoin_wallet.status_of_script(&self.tx_lock).await?;
         let tx_cancel_status = bitcoin_wallet.status_of_script(&tx_cancel).await?;
@@ -560,7 +583,7 @@ impl State4 {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct State5 {
     #[serde(with = "monero_private_key")]
     s_a: monero::PrivateKey,
@@ -611,7 +634,7 @@ impl State6 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )?;
 
         let tx_lock_status = bitcoin_wallet.status_of_script(&self.tx_lock).await?;
         let tx_cancel_status = bitcoin_wallet.status_of_script(&tx_cancel).await?;
@@ -634,33 +657,35 @@ impl State6 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )?;
 
         let tx = bitcoin_wallet.get_raw_transaction(tx_cancel.txid()).await?;
 
         Ok(tx)
     }
 
-    pub async fn submit_tx_cancel(&self, bitcoin_wallet: &bitcoin::Wallet) -> Result<Txid> {
+    pub async fn submit_tx_cancel(
+        &self,
+        bitcoin_wallet: &bitcoin::Wallet,
+    ) -> Result<(Txid, Subscription)> {
         let transaction = bitcoin::TxCancel::new(
             &self.tx_lock,
             self.cancel_timelock,
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        )
+        )?
         .complete_as_bob(self.A, self.b.clone(), self.tx_cancel_sig_a.clone())
         .context("Failed to complete Bitcoin cancel transaction")?;
 
-        let (tx_id, _) = bitcoin_wallet.broadcast(transaction, "cancel").await?;
+        let (tx_id, subscription) = bitcoin_wallet.broadcast(transaction, "cancel").await?;
 
-        Ok(tx_id)
+        Ok((tx_id, subscription))
     }
 
     pub async fn publish_refund_btc(&self, bitcoin_wallet: &bitcoin::Wallet) -> Result<()> {
         let signed_tx_refund = self.signed_refund_transaction()?;
-        let (_, subscription) = bitcoin_wallet.broadcast(signed_tx_refund, "refund").await?;
-        subscription.wait_until_final().await?;
+        bitcoin_wallet.broadcast(signed_tx_refund, "refund").await?;
 
         Ok(())
     }
@@ -672,7 +697,7 @@ impl State6 {
             self.A,
             self.b.public(),
             self.tx_cancel_fee,
-        );
+        )?;
         let tx_refund =
             bitcoin::TxRefund::new(&tx_cancel, &self.refund_address, self.tx_refund_fee);
 

swap/src/protocol/bob/swap.rs

@@ -117,7 +117,7 @@ async fn next_state(
         } => {
             let tx_lock_status = bitcoin_wallet.subscribe_to(state3.tx_lock.clone()).await;
 
-            if let ExpiredTimelocks::None = state3.current_epoch(bitcoin_wallet).await? {
+            if let ExpiredTimelocks::None { .. } = state3.expired_timelock(bitcoin_wallet).await? {
                 let transfer_proof_watcher = event_loop_handle.recv_transfer_proof();
                 let cancel_timelock_expires =
                     tx_lock_status.wait_until_confirmed_with(state3.cancel_timelock);
@@ -137,7 +137,7 @@ async fn next_state(
                         }
                     },
                     result = cancel_timelock_expires => {
-                        let _ = result?;
+                        result?;
                         tracing::info!("Alice took too long to lock Monero, cancelling the swap");
 
                         let state4 = state3.cancel();
@@ -156,7 +156,7 @@ async fn next_state(
         } => {
             let tx_lock_status = bitcoin_wallet.subscribe_to(state.tx_lock.clone()).await;
 
-            if let ExpiredTimelocks::None = state.current_epoch(bitcoin_wallet).await? {
+            if let ExpiredTimelocks::None { .. } = state.expired_timelock(bitcoin_wallet).await? {
                 let watch_request = state.lock_xmr_watch_request(lock_transfer_proof);
 
                 select! {
@@ -174,7 +174,7 @@ async fn next_state(
                         }
                     }
                     result = tx_lock_status.wait_until_confirmed_with(state.cancel_timelock) => {
-                        let _ = result?;
+                        result?;
                         BobState::CancelTimelockExpired(state.cancel())
                     }
                 }
@@ -183,9 +183,16 @@ async fn next_state(
             }
         }
         BobState::XmrLocked(state) => {
+            // In case we send the encrypted signature to Alice, but she doesn't give us a confirmation
+            // We need to check if she still published the Bitcoin redeem transaction
+            // Otherwise we risk staying stuck in "XmrLocked"
+            if let Ok(state5) = state.check_for_tx_redeem(bitcoin_wallet).await {
+                return Ok(BobState::BtcRedeemed(state5));
+            }
+
             let tx_lock_status = bitcoin_wallet.subscribe_to(state.tx_lock.clone()).await;
 
-            if let ExpiredTimelocks::None = state.expired_timelock(bitcoin_wallet).await? {
+            if let ExpiredTimelocks::None { .. } = state.expired_timelock(bitcoin_wallet).await? {
                 // Alice has locked Xmr
                 // Bob sends Alice his key
 
@@ -198,7 +205,7 @@ async fn next_state(
                         }
                     },
                     result = tx_lock_status.wait_until_confirmed_with(state.cancel_timelock) => {
-                        let _ = result?;
+                        result?;
                         BobState::CancelTimelockExpired(state.cancel())
                     }
                 }
@@ -207,15 +214,22 @@ async fn next_state(
             }
         }
         BobState::EncSigSent(state) => {
+            // We need to make sure that Alice did not publish the redeem transaction while we were offline
+            // Even if the cancel timelock expired, if Alice published the redeem transaction while we were away we cannot miss it
+            // If we do we cannot refund and will never be able to leave the "CancelTimelockExpired" state
+            if let Ok(state5) = state.check_for_tx_redeem(bitcoin_wallet).await {
+                return Ok(BobState::BtcRedeemed(state5));
+            }
+
             let tx_lock_status = bitcoin_wallet.subscribe_to(state.tx_lock.clone()).await;
 
-            if let ExpiredTimelocks::None = state.expired_timelock(bitcoin_wallet).await? {
+            if let ExpiredTimelocks::None { .. } = state.expired_timelock(bitcoin_wallet).await? {
                 select! {
                     state5 = state.watch_for_redeem_btc(bitcoin_wallet) => {
                         BobState::BtcRedeemed(state5?)
                     },
                     result = tx_lock_status.wait_until_confirmed_with(state.cancel_timelock) => {
-                        let _ = result?;
+                        result?;
                         BobState::CancelTimelockExpired(state.cancel())
                     }
                 }
@@ -227,6 +241,9 @@ async fn next_state(
             let (spend_key, view_key) = state.xmr_keys();
 
             let wallet_file_name = swap_id.to_string();
+
+            tracing::info!(%wallet_file_name, "Generating and opening Monero wallet from the extracted keys to redeem the Monero");
+
             if let Err(e) = monero_wallet
                 .create_from_and_load(
                     wallet_file_name.clone(),
@@ -241,7 +258,7 @@ async fn next_state(
                 // might not be able to ever transfer the Monero.
                 tracing::warn!("Failed to generate monero wallet from keys: {:#}", e);
                 tracing::info!(%wallet_file_name,
-                    "Falling back to trying to open the the wallet if it already exists",
+                    "Falling back to trying to open the wallet if it already exists",
                 );
                 monero_wallet.open(wallet_file_name).await?;
             }
@@ -269,18 +286,21 @@ async fn next_state(
         BobState::BtcCancelled(state) => {
             // Bob has cancelled the swap
             match state.expired_timelock(bitcoin_wallet).await? {
-                ExpiredTimelocks::None => {
+                ExpiredTimelocks::None { .. } => {
                     bail!(
                         "Internal error: canceled state reached before cancel timelock was expired"
                     );
                 }
-                ExpiredTimelocks::Cancel => {
+                ExpiredTimelocks::Cancel { .. } => {
                     state.publish_refund_btc(bitcoin_wallet).await?;
                     BobState::BtcRefunded(state)
                 }
-                ExpiredTimelocks::Punish => BobState::BtcPunished {
-                    tx_lock_id: state.tx_lock_id(),
-                },
+                ExpiredTimelocks::Punish => {
+                    tracing::info!("You have been punished for not refunding in time");
+                    BobState::BtcPunished {
+                        tx_lock_id: state.tx_lock_id(),
+                    }
+                }
             }
         }
         BobState::BtcRefunded(state4) => BobState::BtcRefunded(state4),

swap/src/rpc.rs

@@ -0,0 +1,31 @@
+use crate::api::Context;
+use jsonrpsee::server::{RpcModule, ServerBuilder, ServerHandle};
+use std::net::SocketAddr;
+use std::sync::Arc;
+use thiserror::Error;
+
+pub mod methods;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Could not parse key value from params")]
+    ParseError,
+}
+
+pub async fn run_server(
+    server_address: SocketAddr,
+    context: Arc<Context>,
+) -> anyhow::Result<(SocketAddr, ServerHandle)> {
+    let server = ServerBuilder::default().build(server_address).await?;
+    let mut modules = RpcModule::new(());
+    {
+        modules
+            .merge(methods::register_modules(Arc::clone(&context))?)
+            .expect("Could not register RPC modules")
+    }
+
+    let addr = server.local_addr()?;
+    let server_handle = server.start(modules)?;
+
+    Ok((addr, server_handle))
+}

swap/src/rpc/methods.rs

@@ -0,0 +1,236 @@
+use crate::api::request::{Method, Request};
+use crate::api::Context;
+use crate::bitcoin::bitcoin_address;
+use crate::monero::monero_address;
+use crate::{bitcoin, monero};
+use anyhow::Result;
+use jsonrpsee::server::RpcModule;
+use jsonrpsee::types::Params;
+use libp2p::core::Multiaddr;
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::sync::Arc;
+use uuid::Uuid;
+
+pub fn register_modules(context: Arc<Context>) -> Result<RpcModule<Arc<Context>>> {
+    let mut module = RpcModule::new(context);
+
+    module.register_async_method("suspend_current_swap", |params, context| async move {
+        execute_request(params, Method::SuspendCurrentSwap, &context).await
+    })?;
+
+    module.register_async_method("get_swap_info", |params_raw, context| async move {
+        let params: HashMap<String, serde_json::Value> = params_raw.parse()?;
+
+        let swap_id = params
+            .get("swap_id")
+            .ok_or_else(|| jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string()))?;
+
+        let swap_id = as_uuid(swap_id)
+            .ok_or_else(|| jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string()))?;
+
+        execute_request(params_raw, Method::GetSwapInfo { swap_id }, &context).await
+    })?;
+
+    module.register_async_method("get_bitcoin_balance", |params_raw, context| async move {
+        let params: HashMap<String, serde_json::Value> = params_raw.parse()?;
+
+        let force_refresh = params
+            .get("force_refresh")
+            .ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Does not contain force_refresh".to_string())
+            })?
+            .as_bool()
+            .ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("force_refesh is not a boolean".to_string())
+            })?;
+
+        execute_request(params_raw, Method::Balance { force_refresh }, &context).await
+    })?;
+
+    module.register_async_method("get_history", |params, context| async move {
+        execute_request(params, Method::History, &context).await
+    })?;
+
+    module.register_async_method("get_raw_states", |params, context| async move {
+        execute_request(params, Method::GetRawStates, &context).await
+    })?;
+
+    module.register_async_method("resume_swap", |params_raw, context| async move {
+        let params: HashMap<String, serde_json::Value> = params_raw.parse()?;
+
+        let swap_id = params
+            .get("swap_id")
+            .ok_or_else(|| jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string()))?;
+
+        let swap_id = as_uuid(swap_id)
+            .ok_or_else(|| jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string()))?;
+
+        execute_request(params_raw, Method::Resume { swap_id }, &context).await
+    })?;
+
+    module.register_async_method("cancel_refund_swap", |params_raw, context| async move {
+        let params: HashMap<String, serde_json::Value> = params_raw.parse()?;
+
+        let swap_id = params
+            .get("swap_id")
+            .ok_or_else(|| jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string()))?;
+
+        let swap_id = as_uuid(swap_id)
+            .ok_or_else(|| jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string()))?;
+
+        execute_request(params_raw, Method::CancelAndRefund { swap_id }, &context).await
+    })?;
+
+    module.register_async_method(
+        "get_monero_recovery_info",
+        |params_raw, context| async move {
+            let params: HashMap<String, serde_json::Value> = params_raw.parse()?;
+
+            let swap_id = params.get("swap_id").ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string())
+            })?;
+
+            let swap_id = as_uuid(swap_id).ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string())
+            })?;
+
+            execute_request(params_raw, Method::MoneroRecovery { swap_id }, &context).await
+        },
+    )?;
+
+    module.register_async_method("withdraw_btc", |params_raw, context| async move {
+        let params: HashMap<String, String> = params_raw.parse()?;
+
+        let amount = if let Some(amount_str) = params.get("amount") {
+            Some(
+                ::bitcoin::Amount::from_str_in(amount_str, ::bitcoin::Denomination::Bitcoin)
+                    .map_err(|_| {
+                        jsonrpsee_core::Error::Custom("Unable to parse amount".to_string())
+                    })?,
+            )
+        } else {
+            None
+        };
+
+        let withdraw_address =
+            bitcoin::Address::from_str(params.get("address").ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Does not contain address".to_string())
+            })?)
+            .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
+        let withdraw_address =
+            bitcoin_address::validate(withdraw_address, context.config.env_config.bitcoin_network)?;
+
+        execute_request(
+            params_raw,
+            Method::WithdrawBtc {
+                amount,
+                address: withdraw_address,
+            },
+            &context,
+        )
+        .await
+    })?;
+
+    module.register_async_method("buy_xmr", |params_raw, context| async move {
+        let params: HashMap<String, String> = params_raw.parse()?;
+
+        let bitcoin_change_address =
+            bitcoin::Address::from_str(params.get("bitcoin_change_address").ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Does not contain bitcoin_change_address".to_string())
+            })?)
+            .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
+
+        let bitcoin_change_address = bitcoin_address::validate(
+            bitcoin_change_address,
+            context.config.env_config.bitcoin_network,
+        )?;
+
+        let monero_receive_address =
+            monero::Address::from_str(params.get("monero_receive_address").ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Does not contain monero_receiveaddress".to_string())
+            })?)
+            .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
+
+        let monero_receive_address = monero_address::validate(
+            monero_receive_address,
+            context.config.env_config.monero_network,
+        )?;
+
+        let seller =
+            Multiaddr::from_str(params.get("seller").ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Does not contain seller".to_string())
+            })?)
+            .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
+
+        execute_request(
+            params_raw,
+            Method::BuyXmr {
+                bitcoin_change_address,
+                monero_receive_address,
+                seller,
+                swap_id: Uuid::new_v4(),
+            },
+            &context,
+        )
+        .await
+    })?;
+
+    module.register_async_method("list_sellers", |params_raw, context| async move {
+        let params: HashMap<String, serde_json::Value> = params_raw.parse()?;
+
+        let rendezvous_point = params.get("rendezvous_point").ok_or_else(|| {
+            jsonrpsee_core::Error::Custom("Does not contain rendezvous_point".to_string())
+        })?;
+
+        let rendezvous_point = rendezvous_point
+            .as_str()
+            .and_then(|addr_str| Multiaddr::from_str(addr_str).ok())
+            .ok_or_else(|| {
+                jsonrpsee_core::Error::Custom("Could not parse valid multiaddr".to_string())
+            })?;
+
+        execute_request(
+            params_raw,
+            Method::ListSellers {
+                rendezvous_point: rendezvous_point.clone(),
+            },
+            &context,
+        )
+        .await
+    })?;
+
+    module.register_async_method("get_current_swap", |params, context| async move {
+        execute_request(params, Method::GetCurrentSwap, &context).await
+    })?;
+
+    Ok(module)
+}
+
+fn as_uuid(json_value: &serde_json::Value) -> Option<Uuid> {
+    if let Some(uuid_str) = json_value.as_str() {
+        Uuid::parse_str(uuid_str).ok()
+    } else {
+        None
+    }
+}
+
+async fn execute_request(
+    params: Params<'static>,
+    cmd: Method,
+    context: &Arc<Context>,
+) -> Result<serde_json::Value, jsonrpsee_core::Error> {
+    // If we fail to parse the params as a String HashMap, it's most likely because its an empty object
+    // In that case, we want to make sure not to fail the request, so we set the log_reference_id to None
+    // and swallow the error
+    let reference_id = params
+        .parse::<HashMap<String, serde_json::Value>>()
+        .ok()
+        .and_then(|params_parsed| params_parsed.get("log_reference_id").cloned());
+
+    let request = Request::with_id(cmd, reference_id.map(|log_ref| log_ref.to_string()));
+    request
+        .call(Arc::clone(context))
+        .await
+        .map_err(|err| jsonrpsee_core::Error::Custom(format!("{:#}", err)))
+}

swap/src/seed.rs

@@ -16,7 +16,7 @@ use torut::onion::TorSecretKeyV3;
 
 pub const SEED_LENGTH: usize = 32;
 
-#[derive(Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq)]
 pub struct Seed([u8; SEED_LENGTH]);
 
 impl Seed {
@@ -61,7 +61,7 @@ impl Seed {
         let file_path = Path::new(&file_path_buf);
 
         if file_path.exists() {
-            return Self::from_file(&file_path);
+            return Self::from_file(file_path);
         }
 
         tracing::debug!("No seed file found, creating at {}", file_path.display());
@@ -106,11 +106,12 @@ impl Seed {
     }
 
     fn from_pem(pem: pem::Pem) -> Result<Self, Error> {
-        if pem.contents.len() != SEED_LENGTH {
-            Err(Error::IncorrectLength(pem.contents.len()))
+        let contents = pem.contents();
+        if contents.len() != SEED_LENGTH {
+            Err(Error::IncorrectLength(contents.len()))
         } else {
             let mut array = [0; SEED_LENGTH];
-            for (i, b) in pem.contents.iter().enumerate() {
+            for (i, b) in contents.iter().enumerate() {
                 array[i] = *b;
             }
 
@@ -122,10 +123,7 @@ impl Seed {
         ensure_directory_exists(&seed_file)?;
 
         let data = self.bytes();
-        let pem = Pem {
-            tag: String::from("SEED"),
-            contents: data.to_vec(),
-        };
+        let pem = Pem::new("SEED", data);
 
         let pem_string = encode(&pem);
 
@@ -187,6 +185,9 @@ mod tests {
 
     #[test]
     fn seed_from_pem_works() {
+        use base64::engine::general_purpose;
+        use base64::Engine;
+
         let payload: &str = "syl9wSYaruvgxg9P5Q1qkZaq5YkM6GvXkxe+VYrL/XM=";
 
         // 32 bytes base64 encoded.
@@ -195,7 +196,7 @@ syl9wSYaruvgxg9P5Q1qkZaq5YkM6GvXkxe+VYrL/XM=
 -----END SEED-----
 ";
 
-        let want = base64::decode(payload).unwrap();
+        let want = general_purpose::STANDARD.decode(payload).unwrap();
         let pem = pem::parse(pem_string).unwrap();
         let got = Seed::from_pem(pem).unwrap();
 
@@ -221,19 +222,20 @@ VnZUNFZ4dlY=
     }
 
     #[test]
-    #[should_panic]
     fn seed_from_pem_fails_for_long_seed() {
         let long = "-----BEGIN SEED-----
-mbKANv2qKGmNVg1qtquj6Hx1pFPelpqOfE2JaJJAMEg1FlFhNRNlFlE=
-mbKANv2qKGmNVg1qtquj6Hx1pFPelpqOfE2JaJJAMEg1FlFhNRNlFlE=
+MIIBPQIBAAJBAOsfi5AGYhdRs/x6q5H7kScxA0Kzzqe6WI6gf6+tc6IvKQJo5rQc
+dWWSQ0nRGt2hOPDO+35NKhQEjBQxPh/v7n0CAwEAAQJBAOGaBAyuw0ICyENy5NsO
 -----END SEED-----
 ";
         let pem = pem::parse(long).unwrap();
+        assert_eq!(pem.contents().len(), 96);
+
         match Seed::from_pem(pem) {
             Ok(_) => panic!("should fail for long payload"),
             Err(e) => {
                 match e {
-                    Error::IncorrectLength(_) => {} // pass
+                    Error::IncorrectLength(len) => assert_eq!(len, 96), // pass
                     _ => panic!("should fail with IncorrectLength error"),
                 }
             }

swap/src/tracing_ext.rs

@@ -41,7 +41,7 @@ impl MakeCapturingWriter {
     }
 }
 
-impl MakeWriter<'_> for MakeCapturingWriter {
+impl<'a> MakeWriter<'a> for MakeCapturingWriter {
     type Writer = CapturingWriter;
 
     fn make_writer(&self) -> Self::Writer {

swap/tests/alice_and_bob_refund_using_cancel_and_refund_command.rs

@@ -50,7 +50,7 @@ async fn given_alice_and_bob_manually_refund_after_funds_locked_both_refund() {
 
         // Bob manually cancels
         bob_join_handle.abort();
-        let (_, state) = cli::cancel(bob_swap.id, bob_swap.bitcoin_wallet, bob_swap.db).await?;
+        let (_, _, state) = cli::cancel(bob_swap.id, bob_swap.bitcoin_wallet, bob_swap.db).await?;
         assert!(matches!(state, BobState::BtcCancelled { .. }));
 
         let (bob_swap, bob_join_handle) = ctx
@@ -64,7 +64,7 @@ async fn given_alice_and_bob_manually_refund_after_funds_locked_both_refund() {
 
         ctx.assert_bob_refunded(bob_state).await;
 
-        // manually refund ALice's swap
+        // manually refund Alice's swap
         ctx.restart_alice().await;
         let alice_swap = ctx.alice_next_swap().await;
         let alice_state = asb::refund(

swap/tests/alice_and_bob_refund_using_cancel_then_refund_command.rs

@@ -0,0 +1,74 @@
+pub mod harness;
+
+use harness::alice_run_until::is_xmr_lock_transaction_sent;
+use harness::bob_run_until::is_btc_locked;
+use harness::FastCancelConfig;
+use swap::asb::FixedRate;
+use swap::protocol::alice::AliceState;
+use swap::protocol::bob::BobState;
+use swap::protocol::{alice, bob};
+use swap::{asb, cli};
+
+#[tokio::test]
+async fn given_alice_and_bob_manually_cancel_and_refund_after_funds_locked_both_refund() {
+    harness::setup_test(FastCancelConfig, |mut ctx| async move {
+        let (bob_swap, bob_join_handle) = ctx.bob_swap().await;
+        let bob_swap_id = bob_swap.id;
+        let bob_swap = tokio::spawn(bob::run_until(bob_swap, is_btc_locked));
+
+        let alice_swap = ctx.alice_next_swap().await;
+        let alice_swap = tokio::spawn(alice::run_until(
+            alice_swap,
+            is_xmr_lock_transaction_sent,
+            FixedRate::default(),
+        ));
+
+        let bob_state = bob_swap.await??;
+        assert!(matches!(bob_state, BobState::BtcLocked { .. }));
+
+        let alice_state = alice_swap.await??;
+        assert!(matches!(
+            alice_state,
+            AliceState::XmrLockTransactionSent { .. }
+        ));
+
+        let (bob_swap, bob_join_handle) = ctx
+            .stop_and_resume_bob_from_db(bob_join_handle, bob_swap_id)
+            .await;
+
+        // Ensure cancel timelock is expired
+        if let BobState::BtcLocked { state3, .. } = bob_swap.state.clone() {
+            bob_swap
+                .bitcoin_wallet
+                .subscribe_to(state3.tx_lock)
+                .await
+                .wait_until_confirmed_with(state3.cancel_timelock)
+                .await?;
+        } else {
+            panic!("Bob in unexpected state {}", bob_swap.state);
+        }
+
+        // Bob manually cancels and refunds
+        bob_join_handle.abort();
+        let bob_state =
+            cli::cancel_and_refund(bob_swap.id, bob_swap.bitcoin_wallet, bob_swap.db).await?;
+
+        ctx.assert_bob_refunded(bob_state).await;
+
+        // manually refund Alice's swap
+        ctx.restart_alice().await;
+        let alice_swap = ctx.alice_next_swap().await;
+        let alice_state = asb::refund(
+            alice_swap.swap_id,
+            alice_swap.bitcoin_wallet,
+            alice_swap.monero_wallet,
+            alice_swap.db,
+        )
+        .await?;
+
+        ctx.assert_alice_refunded(alice_state).await;
+
+        Ok(())
+    })
+    .await
+}

swap/tests/bdk.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -euxo pipefail
+
+VERSION=0.11.1
+
+mkdir bdk
+stat ./target/debug/swap || exit 1
+cp ./target/debug/swap bdk/swap-current
+pushd bdk
+
+echo "download swap $VERSION"
+curl -L "https://github.com/comit-network/xmr-btc-swap/releases/download/${VERSION}/swap_${VERSION}_Linux_x86_64.tar" | tar xv
+
+echo "create testnet wallet with $VERSION"
+./swap --testnet --data-base-dir . --debug balance || exit 1
+echo "check testnet wallet with this version"
+./swap-current --testnet --data-base-dir . --debug balance || exit 1
+
+echo "create mainnet wallet with $VERSION"
+./swap --version || exit 1
+./swap --data-base-dir . --debug balance || exit 1
+echo "check mainnet wallet with this version"
+./swap-current --version || exit 1
+./swap-current --data-base-dir . --debug balance || exit 1
+
+exit 0

swap/tests/ensure_same_swap_id.rs

@@ -8,7 +8,7 @@ async fn ensure_same_swap_id_for_alice_and_bob() {
     harness::setup_test(SlowCancelConfig, |mut ctx| async move {
         let (bob_swap, _) = ctx.bob_swap().await;
         let bob_swap_id = bob_swap.id;
-        let _ = tokio::spawn(bob::run(bob_swap));
+        tokio::spawn(bob::run(bob_swap));
 
         // once Bob's swap is spawned we can retrieve Alice's swap and assert on the
         // swap ID

swap/tests/happy_path_bob_offline_while_alice_redeems_btc.rs

@@ -0,0 +1,44 @@
+pub mod harness;
+
+use crate::harness::bob_run_until::is_encsig_sent;
+use swap::asb::FixedRate;
+use swap::protocol::bob::BobState;
+use swap::protocol::{alice, bob};
+use tokio::join;
+
+#[tokio::test]
+async fn given_bob_restarts_while_alice_redeems_btc() {
+    harness::setup_test(harness::SlowCancelConfig, |mut ctx| async move {
+        let (bob_swap, bob_handle) = ctx.bob_swap().await;
+        let swap_id = bob_swap.id;
+
+        let bob_swap = tokio::spawn(bob::run_until(bob_swap, is_encsig_sent));
+
+        let alice_swap = ctx.alice_next_swap().await;
+        let alice_swap = tokio::spawn(alice::run(alice_swap, FixedRate::default()));
+
+        let (bob_state, alice_state) = join!(bob_swap, alice_swap);
+        ctx.assert_alice_redeemed(alice_state??).await;
+        assert!(matches!(bob_state??, BobState::EncSigSent { .. }));
+
+        let (bob_swap, _) = ctx.stop_and_resume_bob_from_db(bob_handle, swap_id).await;
+
+        if let BobState::EncSigSent(state4) = bob_swap.state.clone() {
+            bob_swap
+                .bitcoin_wallet
+                .subscribe_to(state4.tx_lock)
+                .await
+                .wait_until_confirmed_with(state4.cancel_timelock)
+                .await?;
+        } else {
+            panic!("Bob in unexpected state {}", bob_swap.state);
+        }
+
+        // Restart Bob
+        let bob_state = bob::run(bob_swap).await?;
+        ctx.assert_bob_redeemed(bob_state).await;
+
+        Ok(())
+    })
+    .await;
+}

swap/tests/harness/bitcoind.rs

@@ -1,6 +1,5 @@
-use std::collections::HashMap;
-use testcontainers::core::{Container, Docker, WaitForMessage};
-use testcontainers::Image;
+use std::collections::BTreeMap;
+use testcontainers::{core::WaitFor, Image, ImageArgs};
 
 pub const RPC_USER: &str = "admin";
 pub const RPC_PASSWORD: &str = "123";
@@ -10,57 +9,27 @@ pub const DATADIR: &str = "/home/bdk";
 
 #[derive(Debug)]
 pub struct Bitcoind {
-    args: BitcoindArgs,
     entrypoint: Option<String>,
-    volume: Option<String>,
+    volumes: BTreeMap<String, String>,
 }
 
 impl Image for Bitcoind {
     type Args = BitcoindArgs;
-    type EnvVars = HashMap<String, String>;
-    type Volumes = HashMap<String, String>;
-    type EntryPoint = str;
 
-    fn descriptor(&self) -> String {
-        "coblox/bitcoin-core:0.21.0".to_string()
+    fn name(&self) -> String {
+        "coblox/bitcoin-core".into()
     }
 
-    fn wait_until_ready<D: Docker>(&self, container: &Container<'_, D, Self>) {
-        container
-            .logs()
-            .stdout
-            .wait_for_message(&"init message: Done loading")
-            .unwrap();
+    fn tag(&self) -> String {
+        "0.21.0".into()
     }
 
-    fn args(&self) -> <Self as Image>::Args {
-        self.args.clone()
+    fn ready_conditions(&self) -> Vec<WaitFor> {
+        vec![WaitFor::message_on_stdout("init message: Done loading")]
     }
 
-    fn volumes(&self) -> Self::Volumes {
-        let mut volumes = HashMap::new();
-        match self.volume.clone() {
-            None => {}
-            Some(volume) => {
-                volumes.insert(volume, DATADIR.to_string());
-            }
-        }
-        volumes
-    }
-
-    fn env_vars(&self) -> Self::EnvVars {
-        HashMap::new()
-    }
-
-    fn with_args(self, args: <Self as Image>::Args) -> Self {
-        Bitcoind { args, ..self }
-    }
-
-    fn with_entrypoint(self, entrypoint: &Self::EntryPoint) -> Self {
-        Self {
-            entrypoint: Some(entrypoint.to_string()),
-            ..self
-        }
+    fn volumes(&self) -> Box<dyn Iterator<Item = (&String, &String)> + '_> {
+        Box::new(self.volumes.iter())
     }
 
     fn entrypoint(&self) -> Option<String> {
@@ -71,16 +40,15 @@ impl Image for Bitcoind {
 impl Default for Bitcoind {
     fn default() -> Self {
         Bitcoind {
-            args: BitcoindArgs::default(),
             entrypoint: Some("/usr/bin/bitcoind".into()),
-            volume: None,
+            volumes: BTreeMap::default(),
         }
     }
 }
 
 impl Bitcoind {
     pub fn with_volume(mut self, volume: String) -> Self {
-        self.volume = Some(volume);
+        self.volumes.insert(volume, DATADIR.to_string());
         self
     }
 }
@@ -109,7 +77,6 @@ impl IntoIterator for BitcoindArgs {
             format!("-rpcuser={}", RPC_USER),
             format!("-rpcpassword={}", RPC_PASSWORD),
             "-printtoconsole".to_string(),
-            "-rest".to_string(),
             "-fallbackfee=0.0002".to_string(),
             format!("-datadir={}", DATADIR),
             format!("-rpcport={}", RPC_PORT),
@@ -120,3 +87,9 @@ impl IntoIterator for BitcoindArgs {
         args.into_iter()
     }
 }
+
+impl ImageArgs for BitcoindArgs {
+    fn into_iterator(self) -> Box<dyn Iterator<Item = String>> {
+        Box::new(self.into_iter())
+    }
+}

swap/tests/harness/electrs.rs

@@ -1,8 +1,8 @@
+use std::collections::BTreeMap;
+
 use crate::harness::bitcoind;
 use bitcoin::Network;
-use std::collections::HashMap;
-use testcontainers::core::{Container, Docker, WaitForMessage};
-use testcontainers::Image;
+use testcontainers::{core::WaitFor, Image, ImageArgs};
 
 pub const HTTP_PORT: u16 = 60401;
 pub const RPC_PORT: u16 = 3002;
@@ -13,51 +13,25 @@ pub struct Electrs {
     args: ElectrsArgs,
     entrypoint: Option<String>,
     wait_for_message: String,
-    volume: String,
-    bitcoind_container_name: String,
+    volumes: BTreeMap<String, String>,
 }
 
 impl Image for Electrs {
     type Args = ElectrsArgs;
-    type EnvVars = HashMap<String, String>;
-    type Volumes = HashMap<String, String>;
-    type EntryPoint = str;
-
-    fn descriptor(&self) -> String {
-        format!("vulpemventures/electrs:{}", self.tag)
-    }
-
-    fn wait_until_ready<D: Docker>(&self, container: &Container<'_, D, Self>) {
-        container
-            .logs()
-            .stderr
-            .wait_for_message(&self.wait_for_message)
-            .unwrap();
+    fn name(&self) -> String {
+        "vulpemventures/electrs".into()
     }
 
-    fn args(&self) -> <Self as Image>::Args {
-        self.args.clone()
+    fn tag(&self) -> String {
+        self.tag.clone()
     }
 
-    fn volumes(&self) -> Self::Volumes {
-        let mut volumes = HashMap::new();
-        volumes.insert(self.volume.clone(), bitcoind::DATADIR.to_string());
-        volumes
+    fn ready_conditions(&self) -> Vec<WaitFor> {
+        vec![WaitFor::message_on_stderr(self.wait_for_message.clone())]
     }
 
-    fn env_vars(&self) -> Self::EnvVars {
-        HashMap::new()
-    }
-
-    fn with_args(self, args: <Self as Image>::Args) -> Self {
-        Electrs { args, ..self }
-    }
-
-    fn with_entrypoint(self, entrypoint: &Self::EntryPoint) -> Self {
-        Self {
-            entrypoint: Some(entrypoint.to_string()),
-            ..self
-        }
+    fn volumes(&self) -> Box<dyn Iterator<Item = (&String, &String)> + '_> {
+        Box::new(self.volumes.iter())
     }
 
     fn entrypoint(&self) -> Option<String> {
@@ -72,8 +46,7 @@ impl Default for Electrs {
             args: ElectrsArgs::default(),
             entrypoint: Some("/build/electrs".into()),
             wait_for_message: "Running accept thread".to_string(),
-            volume: uuid::Uuid::new_v4().to_string(),
-            bitcoind_container_name: uuid::Uuid::new_v4().to_string(),
+            volumes: BTreeMap::default(),
         }
     }
 }
@@ -87,7 +60,7 @@ impl Electrs {
     }
 
     pub fn with_volume(mut self, volume: String) -> Self {
-        self.volume = volume;
+        self.volumes.insert(volume, bitcoind::DATADIR.to_string());
         self
     }
 
@@ -95,6 +68,11 @@ impl Electrs {
         self.args.daemon_rpc_addr = name;
         self
     }
+
+    pub fn self_and_args(self) -> (Self, ElectrsArgs) {
+        let args = self.args.clone();
+        (self, args)
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -139,7 +117,7 @@ impl IntoIterator for ElectrsArgs {
         }
 
         args.push("-vvvvv".to_string());
-        args.push(format!("--daemon-dir=={}", self.daemon_dir.as_str()));
+        args.push(format!("--daemon-dir={}", self.daemon_dir.as_str()));
         args.push(format!("--daemon-rpc-addr={}", self.daemon_rpc_addr));
         args.push(format!("--cookie={}", self.cookie));
         args.push(format!("--http-addr={}", self.http_addr));
@@ -149,3 +127,9 @@ impl IntoIterator for ElectrsArgs {
         args.into_iter()
     }
 }
+
+impl ImageArgs for ElectrsArgs {
+    fn into_iterator(self) -> Box<dyn Iterator<Item = String>> {
+        Box::new(self.into_iter())
+    }
+}