diff --git a/.commitlintrc.yml b/.commitlintrc.yml
new file mode 100644
index 0000000..320a584
--- /dev/null
+++ b/.commitlintrc.yml
@@ -0,0 +1,21 @@
+extends:
+  - '@commitlint/config-conventional'
+
+rules:
+  # Allow slightly longer subjects; we have descriptive messages.
+  header-max-length: [2, always, 100]
+  # Enforce lowercase type (feat, fix, ...) and allow common scopes.
+  type-enum:
+    - 2
+    - always
+    - - build
+      - chore
+      - ci
+      - docs
+      - feat
+      - fix
+      - perf
+      - refactor
+      - revert
+      - style
+      - test
\ No newline at end of file
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1ef1faa..1dc0722 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,28 +10,60 @@ on:
       - main
       - subspaces
 
+env:
+  CARGO_TERM_COLOR: always
+
 jobs:
-  run-tests:
+  test:
+    name: Test
     runs-on: ubuntu-latest
-
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test --verbose
 
-      - name: Set up Rust
-        uses: actions-rs/toolchain@v1
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: stable
-          profile: minimal
-          override: true
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo fmt --all -- --check
+      - run: cargo clippy --all-targets --all-features -- -D warnings
 
-      - name: Cache cargo registry
-        uses: actions/cache@v3
-        with:
-          path: ~/.cargo/registry
-          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-registry-
+  docs:
+    name: Docs
+    runs-on: ubuntu-latest
+    env:
+      RUSTDOCFLAGS: -D warnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo doc --no-deps --all-features
+
+  msrv:
+    name: MSRV (1.88)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@1.88.0
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo check --all-features
 
-      - name: Run tests
-        run: cargo test
+  no-std:
+    name: no_std build (${{ matrix.crate }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        crate: [borsh_utils, spaces_protocol, spaces_nums, sip7]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo check -p ${{ matrix.crate }} --no-default-features
\ No newline at end of file
diff --git a/.github/workflows/commitlint.yml b/.github/workflows/commitlint.yml
new file mode 100644
index 0000000..57918ab
--- /dev/null
+++ b/.github/workflows/commitlint.yml
@@ -0,0 +1,16 @@
+name: Commitlint
+
+on:
+  pull_request:
+    types: [opened, reopened, edited, synchronize]
+
+jobs:
+  commitlint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: wagoid/commitlint-github-action@v6
+        with:
+          configFile: .commitlintrc.yml
\ No newline at end of file
diff --git a/.github/workflows/release-plz.yml b/.github/workflows/release-plz.yml
new file mode 100644
index 0000000..1a0548d
--- /dev/null
+++ b/.github/workflows/release-plz.yml
@@ -0,0 +1,49 @@
+name: Release-plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  push:
+    branches: [subspaces]
+
+jobs:
+  # Opens / updates the "release PR" that bumps versions and edits the CHANGELOG.
+  release-plz-pr:
+    name: Release-plz PR
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'buffrr' }}
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/action@v0.5
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
+  # Tags + publishes to crates.io when a release commit lands on main.
+  release-plz-release:
+    name: Release-plz publish
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'buffrr' }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/action@v0.5
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
\ No newline at end of file
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 7be1853..fbef3bb 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,9 +1,9 @@
-name: Build binaries and create release
+name: Build binaries and upload to release
 
 on:
   push:
     tags:
-      - 'v*.*.*'
+      - 'spaces_client-v*'
 
 jobs:
   release:
@@ -24,10 +24,12 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Get the tag name
+      - name: Extract version from tag
         id: get_tag
-        run: | 
+        run: |
+          # tag format: spaces_client-v0.1.0 → VERSION=0.1.0, TAG=<original>
           echo "TAG=${GITHUB_REF##*/}" >> $GITHUB_ENV
+          echo "VERSION=${GITHUB_REF##*-v}" >> $GITHUB_ENV
 
       - name: Set up Rust
         uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -44,7 +46,7 @@ jobs:
         env:
           CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
         run: |
-          cargo build --release --target ${{ matrix.target }}
+          cargo build --release --target ${{ matrix.target }} -p spaces_client
 
       - name: Get OS and architecture
         run: |
@@ -53,23 +55,16 @@ jobs:
 
       - name: Create release archive
         run: |
-          mkdir -p spaces-${{ env.TAG }}-${{ env.OS }}-${{ env.ARCH }}
-          cp target/${{ matrix.target }}/release/spaced spaces-${{ env.TAG }}-${{ env.OS }}-${{ env.ARCH }}/spaced
-          cp target/${{ matrix.target }}/release/space-cli spaces-${{ env.TAG }}-${{ env.OS }}-${{ env.ARCH }}/space-cli
-          tar -czf spaces-${{ env.TAG }}-${{ env.OS }}-${{ env.ARCH }}.tar.gz spaces-${{ env.TAG }}-${{ env.OS }}-${{ env.ARCH }}
+          mkdir -p spaces-v${{ env.VERSION }}-${{ env.OS }}-${{ env.ARCH }}
+          cp target/${{ matrix.target }}/release/spaced spaces-v${{ env.VERSION }}-${{ env.OS }}-${{ env.ARCH }}/spaced
+          cp target/${{ matrix.target }}/release/space-cli spaces-v${{ env.VERSION }}-${{ env.OS }}-${{ env.ARCH }}/space-cli
+          tar -czf spaces-v${{ env.VERSION }}-${{ env.OS }}-${{ env.ARCH }}.tar.gz spaces-v${{ env.VERSION }}-${{ env.OS }}-${{ env.ARCH }}
 
-      - name: Create GitHub Release
-        id: create_release
+      - name: Upload artifacts to existing release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.TAG }}  # Dynamically use the pushed tag
-          name: Release ${{ env.TAG }}  # Use the tag for the release name
-          body: |
-            Spaces release of version ${{ env.TAG }}.
-          draft: false
-          prerelease: false
-          files: | 
-            spaces-${{ env.TAG }}-${{ env.OS }}-${{ env.ARCH }}.tar.gz
-          make_latest: true
+          tag_name: ${{ env.TAG }}
+          files: |
+            spaces-v${{ env.VERSION }}-${{ env.OS }}-${{ env.ARCH }}.tar.gz
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index a422362..2e2ce84 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -175,9 +175,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
-name = "bdk_chain"
+name = "bdk_chain_backport"
 version = "0.21.0"
-source = "git+https://github.com/buffrr/bdk.git?rev=43bca8643dec6fdda99e4a29bf88709729af349e#43bca8643dec6fdda99e4a29bf88709729af349e"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d580eb55991b7a2415d71d195935f4f88b138257a5e7756724d77974c2f15153"
 dependencies = [
  "bdk_core",
  "bitcoin",
@@ -188,8 +189,9 @@ dependencies = [
 
 [[package]]
 name = "bdk_core"
-version = "0.4.0"
-source = "git+https://github.com/buffrr/bdk.git?rev=43bca8643dec6fdda99e4a29bf88709729af349e#43bca8643dec6fdda99e4a29bf88709729af349e"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b545aea1efc090e4f71f1dd5468090d9f54c3de48002064c04895ef811fbe0b2"
 dependencies = [
  "bitcoin",
  "hashbrown 0.14.5",
@@ -197,11 +199,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "bdk_wallet"
+name = "bdk_wallet_backport"
 version = "1.0.0-beta.6"
-source = "git+https://github.com/buffrr/bdk.git?rev=43bca8643dec6fdda99e4a29bf88709729af349e#43bca8643dec6fdda99e4a29bf88709729af349e"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbf2fadfbc496ddc97a19bc99196abafe6d393eb0f6e51f36aa6cf93b9aeb8db"
 dependencies = [
- "bdk_chain",
+ "bdk_chain_backport",
  "bip39",
  "bitcoin",
  "miniscript",
@@ -355,9 +358,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.11.0"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
 name = "block-buffer"
@@ -466,9 +469,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.57"
+version = "1.2.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -500,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.6.0"
+version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
+checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -522,9 +525,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.6.0"
+version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
+checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -741,9 +744,9 @@ checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
 [[package]]
 name = "fastrand"
-version = "2.3.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "filetime"
@@ -980,9 +983,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.16.1"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
 
 [[package]]
 name = "hashlink"
@@ -1143,9 +1146,9 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.8.1"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -1156,7 +1159,6 @@ dependencies = [
  "httparse",
  "itoa",
  "pin-project-lite",
- "pin-utils",
  "smallvec",
  "tokio",
  "want",
@@ -1180,19 +1182,18 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.27.7"
+version = "0.27.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
 dependencies = [
  "http 1.4.0",
- "hyper 1.8.1",
+ "hyper 1.9.0",
  "hyper-util",
- "rustls 0.23.37",
- "rustls-pki-types",
+ "rustls 0.23.38",
  "tokio",
  "tokio-rustls 0.26.4",
  "tower-service",
- "webpki-roots 1.0.6",
+ "webpki-roots 1.0.7",
 ]
 
 [[package]]
@@ -1207,7 +1208,7 @@ dependencies = [
  "futures-util",
  "http 1.4.0",
  "http-body 1.0.1",
- "hyper 1.8.1",
+ "hyper 1.9.0",
  "ipnet",
  "libc",
  "percent-encoding",
@@ -1220,12 +1221,13 @@ dependencies = [
 
 [[package]]
 name = "icu_collections"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
 dependencies = [
  "displaydoc",
  "potential_utf",
+ "utf8_iter",
  "yoke",
  "zerofrom",
  "zerovec",
@@ -1233,9 +1235,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locale_core"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -1246,9 +1248,9 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
 dependencies = [
  "icu_collections",
  "icu_normalizer_data",
@@ -1260,15 +1262,15 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
 
 [[package]]
 name = "icu_properties"
-version = "2.1.2"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
 dependencies = [
  "icu_collections",
  "icu_locale_core",
@@ -1280,15 +1282,15 @@ dependencies = [
 
 [[package]]
 name = "icu_properties_data"
-version = "2.1.2"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
 
 [[package]]
 name = "icu_provider"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
@@ -1328,12 +1330,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.13.0"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.0",
  "serde",
  "serde_core",
 ]
@@ -1355,9 +1357,9 @@ checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
 [[package]]
 name = "iri-string"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8e7418f59cc01c88316161279a7f665217ae316b388e58a0d10e29f54f1e5eb"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
 dependencies = [
  "memchr",
  "serde",
@@ -1411,10 +1413,12 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.91"
+version = "0.3.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
+checksum = "2964e92d1d9dc3364cae4d718d93f227e3abb088e747d92e0395bfdedf1c12ca"
 dependencies = [
+ "cfg-if",
+ "futures-util",
  "once_cell",
  "wasm-bindgen",
 ]
@@ -1546,20 +1550,20 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
 name = "libc"
-version = "0.2.183"
+version = "0.2.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
 
 [[package]]
 name = "libredox"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ddbf48fd451246b1f8c2610bd3b4ac0cc6e149d89832867093ab69a17194f08"
+checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
 dependencies = [
  "bitflags",
  "libc",
  "plain",
- "redox_syscall 0.7.3",
+ "redox_syscall 0.7.4",
 ]
 
 [[package]]
@@ -1587,9 +1591,9 @@ checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "litemap"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
 
 [[package]]
 name = "lock_api"
@@ -1654,9 +1658,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
 dependencies = [
  "libc",
  "wasi",
@@ -1671,9 +1675,9 @@ checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
 [[package]]
 name = "num-conv"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
 
 [[package]]
 name = "num-traits"
@@ -1813,17 +1817,11 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
 [[package]]
 name = "pkg-config"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
 
 [[package]]
 name = "plain"
@@ -1839,18 +1837,18 @@ checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
 [[package]]
 name = "portable-atomic-util"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
+checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
 dependencies = [
  "portable-atomic",
 ]
 
 [[package]]
 name = "potential_utf"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
 dependencies = [
  "zerovec",
 ]
@@ -1961,8 +1959,8 @@ dependencies = [
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash 2.1.1",
- "rustls 0.23.37",
+ "rustc-hash 2.1.2",
+ "rustls 0.23.38",
  "socket2 0.6.3",
  "thiserror 2.0.18",
  "tokio",
@@ -1979,10 +1977,10 @@ dependencies = [
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
- "rand 0.9.2",
+ "rand 0.9.4",
  "ring",
- "rustc-hash 2.1.1",
- "rustls 0.23.37",
+ "rustc-hash 2.1.2",
+ "rustls 0.23.38",
  "rustls-pki-types",
  "slab",
  "thiserror 2.0.18",
@@ -2039,9 +2037,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.5",
@@ -2096,9 +2094,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ce70a74e890531977d37e532c34d45e9055d2409ed08ddba14529471ed0be16"
+checksum = "f450ad9c3b1da563fb6948a8e0fb0fb9269711c9c73d9ea1de5058c79c8d643a"
 dependencies = [
  "bitflags",
 ]
@@ -2157,15 +2155,15 @@ dependencies = [
  "http 1.4.0",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.8.1",
- "hyper-rustls 0.27.7",
+ "hyper 1.9.0",
+ "hyper-rustls 0.27.9",
  "hyper-util",
  "js-sys",
  "log",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.37",
+ "rustls 0.23.38",
  "rustls-pki-types",
  "serde",
  "serde_json",
@@ -2180,7 +2178,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "webpki-roots 1.0.6",
+ "webpki-roots 1.0.7",
 ]
 
 [[package]]
@@ -2225,9 +2223,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustc-hash"
-version = "2.1.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
 
 [[package]]
 name = "rustix"
@@ -2269,15 +2267,15 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.37"
+version = "0.23.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
+checksum = "69f9466fb2c14ea04357e91413efb882e2a6d4a406e625449bc0a5d360d53a21"
 dependencies = [
  "log",
  "once_cell",
  "ring",
  "rustls-pki-types",
- "rustls-webpki 0.103.10",
+ "rustls-webpki 0.103.12",
  "subtle",
  "zeroize",
 ]
@@ -2325,9 +2323,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.10"
+version = "0.103.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+checksum = "8279bb85272c9f10811ae6a6c547ff594d6a7f3c6c6b02ee9726d1d0dcfcdd06"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -2441,9 +2439,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.27"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "serde"
@@ -2564,9 +2562,9 @@ dependencies = [
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
 
 [[package]]
 name = "sip7"
@@ -2629,8 +2627,9 @@ dependencies = [
 
 [[package]]
 name = "spacedb"
-version = "0.0.12"
-source = "git+https://github.com/spacesprotocol/spacedb#43f23e78e4e5fffb8d89661a4b7f39ab43a5a644"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a48cda82e951391df9d0a54c96f8b04e117ff39abad5359b181cb71c80798d77"
 dependencies = [
  "bincode",
  "borsh",
@@ -2661,7 +2660,7 @@ dependencies = [
 
 [[package]]
 name = "spaces_client"
-version = "0.0.7"
+version = "0.1.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2712,7 +2711,7 @@ dependencies = [
 
 [[package]]
 name = "spaces_protocol"
-version = "0.0.7"
+version = "0.1.0"
 dependencies = [
  "bitcoin",
  "borsh",
@@ -2723,7 +2722,7 @@ dependencies = [
 
 [[package]]
 name = "spaces_testutil"
-version = "0.0.1"
+version = "0.1.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2740,10 +2739,10 @@ dependencies = [
 
 [[package]]
 name = "spaces_wallet"
-version = "0.0.7"
+version = "0.1.0"
 dependencies = [
  "anyhow",
- "bdk_wallet",
+ "bdk_wallet_backport",
  "bech32",
  "bitcoin",
  "borsh",
@@ -2938,9 +2937,9 @@ checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
 
 [[package]]
 name = "tinystr"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
 dependencies = [
  "displaydoc",
  "zerovec",
@@ -2963,9 +2962,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.50.0"
+version = "1.52.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
 dependencies = [
  "bytes",
  "libc",
@@ -2980,9 +2979,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "2.6.1"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3005,7 +3004,7 @@ version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls 0.23.37",
+ "rustls 0.23.38",
  "tokio",
 ]
 
@@ -3037,18 +3036,18 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "1.1.0+spec-1.1.0"
+version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.25.8+spec-1.1.0"
+version = "0.25.11+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16bff38f1d86c47f9ff0647e6838d7bb362522bdf44006c7068c2b1e606f1f3c"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
 dependencies = [
  "indexmap",
  "toml_datetime",
@@ -3058,9 +3057,9 @@ dependencies = [
 
 [[package]]
 name = "toml_parser"
-version = "1.1.0+spec-1.1.0"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
  "winnow",
 ]
@@ -3218,11 +3217,11 @@ dependencies = [
  "flate2",
  "log",
  "percent-encoding",
- "rustls 0.23.37",
+ "rustls 0.23.38",
  "rustls-pki-types",
  "ureq-proto",
  "utf8-zero",
- "webpki-roots 1.0.6",
+ "webpki-roots 1.0.7",
 ]
 
 [[package]]
@@ -3329,9 +3328,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.114"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
+checksum = "0bf938a0bacb0469e83c1e148908bd7d5a6010354cf4fb73279b7447422e3a89"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -3342,23 +3341,19 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.64"
+version = "0.4.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
+checksum = "f371d383f2fb139252e0bfac3b81b265689bf45b6874af544ffa4c975ac1ebf8"
 dependencies = [
- "cfg-if",
- "futures-util",
  "js-sys",
- "once_cell",
  "wasm-bindgen",
- "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.114"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
+checksum = "eeff24f84126c0ec2db7a449f0c2ec963c6a49efe0698c4242929da037ca28ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3366,9 +3361,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.114"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
+checksum = "9d08065faf983b2b80a79fd87d8254c409281cf7de75fc4b773019824196c904"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -3379,9 +3374,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.114"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
+checksum = "5fd04d9e306f1907bd13c6361b5c6bfc7b3b3c095ed3f8a9246390f8dbdee129"
 dependencies = [
  "unicode-ident",
 ]
@@ -3422,9 +3417,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.91"
+version = "0.3.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
+checksum = "4f2dfbb17949fa2088e5d39408c48368947b86f7834484e87b73de55bc14d97d"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -3448,9 +3443,9 @@ checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.6"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
+checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -3706,9 +3701,9 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
+checksum = "09dac053f1cd375980747450bfc7250c264eaae0583872e845c0c7cd578872b5"
 dependencies = [
  "memchr",
 ]
@@ -3803,9 +3798,9 @@ dependencies = [
 
 [[package]]
 name = "writeable"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
 
 [[package]]
 name = "xattr"
@@ -3819,9 +3814,9 @@ dependencies = [
 
 [[package]]
 name = "yoke"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
 dependencies = [
  "stable_deref_trait",
  "yoke-derive",
@@ -3830,9 +3825,9 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3842,18 +3837,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.47"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.47"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3862,18 +3857,18 @@ dependencies = [
 
 [[package]]
 name = "zerofrom"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
 dependencies = [
  "zerofrom-derive",
 ]
 
 [[package]]
 name = "zerofrom-derive"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3889,9 +3884,9 @@ checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
 
 [[package]]
 name = "zerotrie"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
 dependencies = [
  "displaydoc",
  "yoke",
@@ -3900,9 +3895,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.5"
+version = "0.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -3911,9 +3906,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 5b46dc5..a907d09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,12 +2,31 @@
 resolver = "2"
 members = ["borsh_utils", "checkpoint", "client", "protocol", "testutil", "wallet", "nums", "sip7"]
 
+[workspace.package]
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.88"
+license = "MIT"
+repository = "https://github.com/buffrr/spaces"
+homepage = "https://spacesprotocol.org"
+authors = ["Buffrr <contact@buffrr.dev>"]
+
 [workspace.dependencies]
+# Internal crates
+borsh_utils = { path = "borsh_utils", version = "0.1.0", default-features = false }
+spaces_protocol = { path = "protocol", version = "0.1.0", default-features = false }
+spaces_nums = { path = "nums", version = "0.1.0", default-features = false }
+sip7 = { path = "sip7", version = "0.1.0", default-features = false }
+spaces_wallet = { path = "wallet", version = "0.1.0", default-features = false }
+spaces_client = { path = "client", version = "0.1.0", default-features = false }
+spaces_testutil = { path = "testutil", version = "0.1.0", default-features = false }
+
+# External
 anyhow = "1.0"
 hex = "0.4"
 serde_json = "1.0"
 tokio = { version = "1", features = ["full"] }
-spacedb = { git = "https://github.com/spacesprotocol/spacedb", features = ["hash-idx"] }
+spacedb = { version = "0.1.2", features = ["hash-idx"] }
 base64 = "0.22"
 rand = "0.8"
 log = "0.4"
@@ -24,7 +43,8 @@ tower = "0.4"
 hyper = "0.14"
 secp256k1 = "0.29"
 bech32 = "0.11"
-bdk_wallet = { git = "https://github.com/buffrr/bdk.git", rev = "43bca8643dec6fdda99e4a29bf88709729af349e", features = ["keys-bip39", "rusqlite"] }
+# temporary backport of bdk for the double-spend issue until we migrate to bdk v3.0
+bdk_wallet = { package = "bdk_wallet_backport", version = "1.0.0-beta.6", features = ["keys-bip39", "rusqlite"] }
 
 # Dev/test dependencies
 assert_cmd = "2.0"
diff --git a/borsh_utils/Cargo.toml b/borsh_utils/Cargo.toml
index 1407b9f..f9a7f82 100644
--- a/borsh_utils/Cargo.toml
+++ b/borsh_utils/Cargo.toml
@@ -1,7 +1,13 @@
 [package]
 name = "borsh_utils"
-version = "0.1.0"
-edition = "2021"
+description = "Borsh serialization helpers for Bitcoin primitives used by the Spaces protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [dependencies]
 bitcoin = { version = "0.32.8", features = ["serde"], default-features = false }
diff --git a/borsh_utils/src/lib.rs b/borsh_utils/src/lib.rs
index 5696fac..9c787b5 100644
--- a/borsh_utils/src/lib.rs
+++ b/borsh_utils/src/lib.rs
@@ -9,8 +9,8 @@ extern crate alloc;
 
 use alloc::vec;
 use bitcoin::hashes::Hash;
-use bitcoin::{secp256k1::schnorr, Amount, BlockHash, OutPoint, ScriptBuf, Txid};
-use borsh::{io, BorshDeserialize, BorshSerialize};
+use bitcoin::{Amount, BlockHash, OutPoint, ScriptBuf, Txid, secp256k1::schnorr};
+use borsh::{BorshDeserialize, BorshSerialize, io};
 
 /// Serialize a Txid
 pub fn serialize_txid<W: io::Write>(txid: &Txid, writer: &mut W) -> io::Result<()> {
diff --git a/checkpoint/Cargo.toml b/checkpoint/Cargo.toml
index 16bf506..022932a 100644
--- a/checkpoint/Cargo.toml
+++ b/checkpoint/Cargo.toml
@@ -1,7 +1,13 @@
 [package]
 name = "spaces_checkpoint"
-version = "0.1.0"
-edition = "2024"
+description = "Checkpoint loader and builder for the Spaces protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [[bin]]
 name = "checkpoint-builder"
@@ -20,7 +26,7 @@ serde_json = "1"
 anyhow = { version = "1", optional = true }
 clap = { version = "4", features = ["derive"], optional = true }
 spacedb = { workspace = true, optional = true }
-spaces_protocol = { path = "../protocol", features = ["std"], optional = true }
+spaces_protocol = { workspace = true, features = ["std"], optional = true }
 
 [dev-dependencies]
 tempfile = "3"
diff --git a/checkpoint/src/builder.rs b/checkpoint/src/builder.rs
index 2affb19..7bb7f27 100644
--- a/checkpoint/src/builder.rs
+++ b/checkpoint/src/builder.rs
@@ -1,8 +1,13 @@
+use clap::Parser;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use clap::Parser;
 
-fn s3_cp(local: &Path, dest: &str, endpoint_url: Option<&str>, profile: Option<&str>) -> anyhow::Result<()> {
+fn s3_cp(
+    local: &Path,
+    dest: &str,
+    endpoint_url: Option<&str>,
+    profile: Option<&str>,
+) -> anyhow::Result<()> {
     eprintln!("Uploading to {}...", dest);
     let mut cmd = Command::new("aws");
     cmd.args(["s3", "cp"]);
@@ -16,7 +21,8 @@ fn s3_cp(local: &Path, dest: &str, endpoint_url: Option<&str>, profile: Option<&
     }
     let status = cmd.status().map_err(|e| {
         anyhow::anyhow!(
-            "failed to run `aws` CLI: {} — install from https://aws.amazon.com/cli/", e
+            "failed to run `aws` CLI: {} — install from https://aws.amazon.com/cli/",
+            e
         )
     })?;
     if !status.success() {
@@ -65,8 +71,11 @@ fn main() -> anyhow::Result<()> {
 
     let digest = spaces_checkpoint::build_checkpoint(&args.data_dir, &output)?;
 
-    eprintln!("\nArchive: {} ({} bytes)", output.display(),
-        std::fs::metadata(&output)?.len());
+    eprintln!(
+        "\nArchive: {} ({} bytes)",
+        output.display(),
+        std::fs::metadata(&output)?.len()
+    );
     eprintln!("SHA-256: {}", hex::encode(digest));
 
     spaces_checkpoint::write_integrity(height, &block_hash, &digest)?;
@@ -76,7 +85,12 @@ fn main() -> anyhow::Result<()> {
         let bucket = bucket.trim_end_matches('/');
 
         // Upload the archive
-        s3_cp(&output, &format!("{}/{}", bucket, filename), args.endpoint_url.as_deref(), args.profile.as_deref())?;
+        s3_cp(
+            &output,
+            &format!("{}/{}", bucket, filename),
+            args.endpoint_url.as_deref(),
+            args.profile.as_deref(),
+        )?;
 
         // Write and upload latest.json
         let latest = spaces_checkpoint::Checkpoint {
@@ -86,10 +100,15 @@ fn main() -> anyhow::Result<()> {
         };
         let latest_path = args.output_dir.join("latest.json");
         std::fs::write(&latest_path, serde_json::to_string_pretty(&latest)?)?;
-        s3_cp(&latest_path, &format!("{}/latest.json", bucket), args.endpoint_url.as_deref(), args.profile.as_deref())?;
+        s3_cp(
+            &latest_path,
+            &format!("{}/latest.json", bucket),
+            args.endpoint_url.as_deref(),
+            args.profile.as_deref(),
+        )?;
 
         eprintln!("Upload complete.");
     }
 
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/checkpoint/src/integrity.rs b/checkpoint/src/integrity.rs
index ab60e9f..4492ea4 100644
--- a/checkpoint/src/integrity.rs
+++ b/checkpoint/src/integrity.rs
@@ -5,4 +5,4 @@ pub fn checkpoint() -> super::Checkpoint {
         block_hash: "000000000000000000012b40cac64a5fb5417cff15dc01461f99a76fc9643568".to_string(),
         digest: "e98c1999a3b98b517b174b3add778fb55f0fe63e0795e9f85952edc00a919f58".to_string(),
     }
-}
\ No newline at end of file
+}
diff --git a/checkpoint/src/lib.rs b/checkpoint/src/lib.rs
index 8bcbc01..d7d2510 100644
--- a/checkpoint/src/lib.rs
+++ b/checkpoint/src/lib.rs
@@ -1,10 +1,10 @@
 pub mod integrity;
 
+use flate2::read::GzDecoder;
+use sha2::{Digest, Sha256};
 use std::fmt;
 use std::io::{Cursor, Read};
 use std::path::Path;
-use flate2::read::GzDecoder;
-use sha2::{Sha256, Digest};
 
 pub const CHECKPOINT_BASE_URL: &str = "https://checkpoints.spacesprotocol.org";
 
@@ -30,9 +30,10 @@ impl Checkpoint {
         let bytes = hex::decode(&self.digest)
             .map_err(|e| CheckpointError::Unavailable(format!("invalid digest hex: {}", e)))?;
         if bytes.len() != 32 {
-            return Err(CheckpointError::Unavailable(
-                format!("invalid digest length: {}", bytes.len()),
-            ));
+            return Err(CheckpointError::Unavailable(format!(
+                "invalid digest length: {}",
+                bytes.len()
+            )));
         }
         let mut arr = [0u8; 32];
         arr.copy_from_slice(&bytes);
@@ -41,7 +42,11 @@ impl Checkpoint {
 
     /// Build the download URL for this checkpoint.
     pub fn url(&self, base_url: &str) -> String {
-        format!("{}/checkpoint-{}.tar.gz", base_url.trim_end_matches('/'), self.height)
+        format!(
+            "{}/checkpoint-{}.tar.gz",
+            base_url.trim_end_matches('/'),
+            self.height
+        )
     }
 }
 
@@ -53,7 +58,9 @@ pub fn fetch_latest(base_url: &str) -> Result<Option<Checkpoint>, CheckpointErro
         Ok(r) => r,
         Err(_) => return Ok(None),
     };
-    let body: String = response.into_body().read_to_string()
+    let body: String = response
+        .into_body()
+        .read_to_string()
         .map_err(|e| CheckpointError::Unavailable(e.to_string()))?;
     let latest: Checkpoint = serde_json::from_str(&body)
         .map_err(|e| CheckpointError::Unavailable(format!("invalid latest.json: {}", e)))?;
@@ -80,8 +87,11 @@ impl fmt::Display for CheckpointError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             CheckpointError::Unavailable(msg) => write!(f, "checkpoint unavailable: {}", msg),
-            CheckpointError::DigestMismatch { expected, got } =>
-                write!(f, "checkpoint hash mismatch: expected {}, got {}", expected, got),
+            CheckpointError::DigestMismatch { expected, got } => write!(
+                f,
+                "checkpoint hash mismatch: expected {}, got {}",
+                expected, got
+            ),
             CheckpointError::Extract(e) => write!(f, "failed to extract checkpoint: {}", e),
             CheckpointError::Io(e) => write!(f, "io error: {}", e),
         }
@@ -121,7 +131,9 @@ pub fn ensure_checkpoint(
             let delay = std::time::Duration::from_secs(1 << attempt);
             tracing::warn!(
                 "checkpoint download attempt {}/{} failed, retrying in {:?}...",
-                attempt, MAX_RETRIES, delay
+                attempt,
+                MAX_RETRIES,
+                delay
             );
             std::thread::sleep(delay);
         }
@@ -134,7 +146,8 @@ pub fn ensure_checkpoint(
                 if attempt == MAX_RETRIES {
                     tracing::warn!(
                         "checkpoint unavailable after {} attempts: {} — falling back to full sync",
-                        MAX_RETRIES + 1, e
+                        MAX_RETRIES + 1,
+                        e
                     );
                     return Ok(false);
                 }
@@ -153,10 +166,13 @@ fn download_and_verify(
 ) -> Result<Vec<u8>, CheckpointError> {
     tracing::info!("downloading checkpoint from {}", url);
 
-    let response = ureq::get(url).call()
+    let response = ureq::get(url)
+        .call()
         .map_err(|e| CheckpointError::Unavailable(e.to_string()))?;
 
-    let total = response.headers().get("content-length")
+    let total = response
+        .headers()
+        .get("content-length")
         .and_then(|v| v.to_str().ok())
         .and_then(|v| v.parse::<u64>().ok())
         .unwrap_or(0);
@@ -165,7 +181,8 @@ fn download_and_verify(
     let mut data = Vec::with_capacity(total as usize);
     let mut buf = [0u8; 64 * 1024];
     loop {
-        let n = reader.read(&mut buf)
+        let n = reader
+            .read(&mut buf)
             .map_err(|e| CheckpointError::Unavailable(e.to_string()))?;
         if n == 0 {
             break;
@@ -194,7 +211,9 @@ fn extract(target_dir: &Path, data: &[u8]) -> Result<(), CheckpointError> {
     tracing::info!("extracting checkpoint...");
     let decoder = GzDecoder::new(Cursor::new(data));
     let mut archive = tar::Archive::new(decoder);
-    archive.unpack(target_dir).map_err(CheckpointError::Extract)?;
+    archive
+        .unpack(target_dir)
+        .map_err(CheckpointError::Extract)?;
     tracing::info!("checkpoint extracted to {:?}", target_dir);
     Ok(())
 }
@@ -203,8 +222,8 @@ fn extract(target_dir: &Path, data: &[u8]) -> Result<(), CheckpointError> {
 /// by inspecting the latest snapshot metadata in root.sdb.
 #[cfg(feature = "cli")]
 pub fn read_tip(data_dir: &Path) -> anyhow::Result<(String, u32)> {
-    use spacedb::db::Database;
     use spacedb::Sha256Hasher;
+    use spacedb::db::Database;
     use spaces_protocol::constants::ChainAnchor;
 
     let db_path = data_dir.join("root.sdb");
@@ -214,14 +233,20 @@ pub fn read_tip(data_dir: &Path) -> anyhow::Result<(String, u32)> {
 
     let config = spacedb::Configuration::standard();
     let db: Database<Sha256Hasher> = Database::open_with_config(
-        db_path.to_str().ok_or_else(|| anyhow::anyhow!("invalid path"))?,
+        db_path
+            .to_str()
+            .ok_or_else(|| anyhow::anyhow!("invalid path"))?,
         config,
     )?;
 
-    let snapshot = db.iter().next()
+    let snapshot = db
+        .iter()
+        .next()
         .ok_or_else(|| anyhow::anyhow!("no snapshots in root.sdb"))?;
     let snapshot = snapshot?;
-    let anchor: ChainAnchor = snapshot.metadata().try_into()
+    let anchor: ChainAnchor = snapshot
+        .metadata()
+        .try_into()
         .map_err(|_| anyhow::anyhow!("could not read snapshot metadata"))?;
 
     Ok((anchor.hash.to_string(), anchor.height))
@@ -230,12 +255,9 @@ pub fn read_tip(data_dir: &Path) -> anyhow::Result<(String, u32)> {
 /// Build a checkpoint archive from a spaced data directory.
 /// Returns the SHA-256 digest of the produced archive.
 #[cfg(feature = "cli")]
-pub fn build_checkpoint(
-    data_dir: &Path,
-    output: &Path,
-) -> anyhow::Result<[u8; 32]> {
-    use flate2::write::GzEncoder;
+pub fn build_checkpoint(data_dir: &Path, output: &Path) -> anyhow::Result<[u8; 32]> {
     use flate2::Compression;
+    use flate2::write::GzEncoder;
     use std::fs::File;
 
     for name in CHECKPOINT_FILES {
@@ -274,15 +296,35 @@ pub fn checkpoint() -> super::Checkpoint {{
         digest: "{}".to_string(),
     }}
 }}"#,
-        height, block_hash, hex::encode(digest),
+        height,
+        block_hash,
+        hex::encode(digest),
     )
 }
 
+#[cfg(feature = "cli")]
+const INTEGRITY_PATH: &str = "checkpoint/src/integrity.rs";
+
+/// Write the checkpoint constant to integrity.rs.
+/// Must be run from the workspace root.
+#[cfg(feature = "cli")]
+pub fn write_integrity(height: u32, block_hash: &str, digest: &[u8; 32]) -> anyhow::Result<()> {
+    let path = Path::new(INTEGRITY_PATH);
+    if !path.exists() {
+        anyhow::bail!(
+            "{} not found — run checkpoint-builder from the workspace root",
+            INTEGRITY_PATH
+        );
+    }
+    std::fs::write(path, format_integrity_file(height, block_hash, digest))?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::sync::atomic::{AtomicU64, Ordering};
     use std::sync::Arc;
+    use std::sync::atomic::{AtomicU64, Ordering};
 
     #[test]
     fn download_reports_progress() {
@@ -307,10 +349,16 @@ mod tests {
         let applied = ensure_checkpoint(dir.path(), &url, &digest, Some(&*progress)).unwrap();
 
         assert!(applied, "checkpoint should be applied");
-        assert!(call_count.load(Ordering::SeqCst) > 1, "progress should be called multiple times");
+        assert!(
+            call_count.load(Ordering::SeqCst) > 1,
+            "progress should be called multiple times"
+        );
 
         let total = last_total.load(Ordering::SeqCst);
-        assert!(total > 0, "total bytes should be reported from content-length");
+        assert!(
+            total > 0,
+            "total bytes should be reported from content-length"
+        );
 
         let downloaded = last_downloaded.load(Ordering::SeqCst);
         assert_eq!(downloaded, total, "final downloaded should equal total");
@@ -321,21 +369,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(feature = "cli")]
-const INTEGRITY_PATH: &str = "checkpoint/src/integrity.rs";
-
-/// Write the checkpoint constant to integrity.rs.
-/// Must be run from the workspace root.
-#[cfg(feature = "cli")]
-pub fn write_integrity(height: u32, block_hash: &str, digest: &[u8; 32]) -> anyhow::Result<()> {
-    let path = Path::new(INTEGRITY_PATH);
-    if !path.exists() {
-        anyhow::bail!(
-            "{} not found — run checkpoint-builder from the workspace root",
-            INTEGRITY_PATH
-        );
-    }
-    std::fs::write(path, format_integrity_file(height, block_hash, digest))?;
-    Ok(())
-}
\ No newline at end of file
diff --git a/client/Cargo.toml b/client/Cargo.toml
index 502db51..45082a9 100644
--- a/client/Cargo.toml
+++ b/client/Cargo.toml
@@ -1,7 +1,13 @@
 [package]
 name = "spaces_client"
-version = "0.0.7"
-edition = "2021"
+description = "Spaces client (spaced) and CLI (space-cli) for the Spaces Protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [[bin]]
 name = "space-cli"
@@ -20,12 +26,12 @@ required-features = ["schema"]
 path = "src/lib.rs"
 
 [dependencies]
-spaces_wallet = { path = "../wallet" }
-spaces_protocol = { path = "../protocol", features = ["std"] }
-spaces_nums= { path = "../nums", features = ["std"] }
-sip7 = { path = "../sip7", features = ["serde"] }
+spaces_wallet = { workspace = true }
+spaces_protocol = { workspace = true, features = ["std"] }
+spaces_nums = { workspace = true, features = ["std"] }
+sip7 = { workspace = true, features = ["serde"] }
 spacedb = { workspace = true }
-borsh_utils = { path = "../borsh_utils" }
+borsh_utils = { workspace = true }
 
 tokio = { workspace = true, features = ["signal"] }
 anyhow = { workspace = true }
@@ -56,4 +62,4 @@ schema = ["schemars"]
 [dev-dependencies]
 assert_cmd = { workspace = true }
 predicates = { workspace = true }
-spaces_testutil = { path = "../testutil" }
+spaces_testutil = { workspace = true }
diff --git a/client/src/app.rs b/client/src/app.rs
index dc219a2..38689cb 100644
--- a/client/src/app.rs
+++ b/client/src/app.rs
@@ -1,14 +1,14 @@
-use std::path::PathBuf;
-use std::sync::Arc;
-use anyhow::anyhow;
-use tokio::sync::{broadcast, mpsc};
-use tokio::task::{JoinHandle, JoinSet};
 use crate::config::Args;
 use crate::rpc::{AsyncChainState, RpcServerImpl, WalletLoadRequest, WalletManager};
 use crate::source::{BitcoinBlockSource, BitcoinRpc};
 use crate::spaces::Spaced;
-use crate::store::chain::{Chain};
+use crate::store::chain::Chain;
 use crate::wallets::RpcWallet;
+use anyhow::anyhow;
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::{broadcast, mpsc};
+use tokio::task::{JoinHandle, JoinSet};
 
 pub struct App {
     shutdown: broadcast::Sender<()>,
@@ -23,7 +23,12 @@ impl App {
         }
     }
 
-    async fn setup_rpc_wallet(&mut self, spaced: &Spaced, rx: mpsc::Receiver<WalletLoadRequest>, cbf: bool) {
+    async fn setup_rpc_wallet(
+        &mut self,
+        spaced: &Spaced,
+        rx: mpsc::Receiver<WalletLoadRequest>,
+        cbf: bool,
+    ) {
         let wallet_service = RpcWallet::service(
             spaced.network,
             spaced.rpc.clone(),
@@ -31,7 +36,7 @@ impl App {
             rx,
             self.shutdown.clone(),
             spaced.num_workers,
-            cbf
+            cbf,
         );
 
         self.services.spawn(async move {
@@ -59,7 +64,7 @@ impl App {
             chain_state,
             self.shutdown.subscribe(),
         )
-            .await;
+        .await;
 
         self.services.spawn(async {
             async_chain_state_handle
@@ -79,7 +84,8 @@ impl App {
                 .map_err(|e| anyhow!("RPC Server error: {}", e))
         });
 
-        self.setup_rpc_wallet(spaced, wallet_loader_rx, spaced.cbf).await;
+        self.setup_rpc_wallet(spaced, wallet_loader_rx, spaced.cbf)
+            .await;
     }
 
     async fn setup_sync_service(&mut self, mut spaced: Spaced) {
@@ -123,15 +129,7 @@ async fn create_async_store(
     let async_store = AsyncChainState::new(tx);
     let client = reqwest::Client::new();
     let handle = tokio::spawn(async move {
-        AsyncChainState::handler(
-            &client,
-            rpc,
-            anchors,
-            state,
-            rx,
-            shutdown,
-        )
-            .await
+        AsyncChainState::handler(&client, rpc, anchors, state, rx, shutdown).await
     });
     (async_store, handle)
 }
diff --git a/client/src/auth.rs b/client/src/auth.rs
index 0ab9559..45836b5 100644
--- a/client/src/auth.rs
+++ b/client/src/auth.rs
@@ -1,5 +1,5 @@
 use base64::Engine;
-use hyper::{http::HeaderValue, Body, HeaderMap, Request, Response, StatusCode};
+use hyper::{Body, HeaderMap, Request, Response, StatusCode, http::HeaderValue};
 use jsonrpsee::{
     core::ClientError,
     http_client::{HttpClient, HttpClientBuilder},
@@ -51,7 +51,7 @@ impl<S> BasicAuth<S> {
             .get("authorization")
             .and_then(|h| h.to_str().ok())
             .and_then(|s| s.strip_prefix("Basic "))
-            .map_or(false, |token| token == self.token.as_ref())
+            .is_some_and(|token| token == self.token.as_ref())
     }
 
     fn unauthorized_response() -> Response<Body> {
diff --git a/client/src/bin/space-cli.rs b/client/src/bin/space-cli.rs
index 4faa7e1..4899b67 100644
--- a/client/src/bin/space-cli.rs
+++ b/client/src/bin/space-cli.rs
@@ -1,41 +1,39 @@
 extern crate core;
 
-use std::{
-    fs, io,
-    io::Write,
-    path::PathBuf,
-};
-use std::str::FromStr;
 use anyhow::anyhow;
 use clap::{Parser, Subcommand};
 use colored::{Color, Colorize};
 use jsonrpsee::{
-    core::{client::Error, ClientError},
+    core::{ClientError, client::Error},
     http_client::HttpClient,
 };
+use spaces_client::rpc::{
+    CommitParams, CreateNumParams, DelegateParams, OperateParams, SetFallbackParams,
+};
+use spaces_client::store::Sha256;
 use spaces_client::{
     auth::{auth_token_from_cookie, auth_token_from_creds, http_client_with_auth},
-    config::{default_cookie_path, default_spaces_rpc_port, ExtendedNetwork},
+    config::{ExtendedNetwork, default_cookie_path, default_spaces_rpc_port},
     format::{
-        print_error_rpc_response, print_list_bidouts, print_list_nums_response,
+        Format, print_error_rpc_response, print_list_bidouts, print_list_nums_response,
         print_list_spaces_response, print_list_transactions, print_list_unspent,
-        print_list_wallets, print_server_info, print_wallet_balance_response,
-        print_wallet_info, print_wallet_response, Format,
+        print_list_wallets, print_server_info, print_wallet_balance_response, print_wallet_info,
+        print_wallet_response,
     },
     rpc::{
-        BidParams, OpenParams, RegisterParams, RpcClient, RpcWalletRequest,
-        RpcWalletTxBuilder, SendCoinsParams, Subject, TransferSpacesParams,
+        BidParams, OpenParams, RegisterParams, RpcClient, RpcWalletRequest, RpcWalletTxBuilder,
+        SendCoinsParams, Subject, TransferSpacesParams,
     },
     wallets::{AddressKind, WalletResponse},
 };
-use spaces_client::rpc::{CommitParams, CreateNumParams, DelegateParams, OperateParams, SetFallbackParams};
-use spaces_client::store::Sha256;
+use spaces_nums::num_id::NumId;
 use spaces_protocol::bitcoin::{Amount, FeeRate, OutPoint, Txid};
 use spaces_protocol::slabel::SLabel;
-use spaces_nums::num_id::NumId;
-use spaces_wallet::{bitcoin::secp256k1::schnorr::Signature, export::WalletExport, Listing};
-use spaces_wallet::bitcoin::hashes::sha256;
 use spaces_wallet::bitcoin::ScriptBuf;
+use spaces_wallet::bitcoin::hashes::sha256;
+use spaces_wallet::{Listing, bitcoin::secp256k1::schnorr::Signature, export::WalletExport};
+use std::str::FromStr;
+use std::{fs, io, io::Write, path::PathBuf};
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -454,11 +452,8 @@ impl SpaceCli {
             args.rpc_url = Some(default_rpc_url(&args.chain));
         }
 
-        let auth_token = if args.rpc_user.is_some() {
-            auth_token_from_creds(
-                args.rpc_user.as_ref().unwrap(),
-                args.rpc_password.as_ref().unwrap(),
-            )
+        let auth_token = if let Some(user) = args.rpc_user.as_ref() {
+            auth_token_from_creds(user, args.rpc_password.as_ref().unwrap())
         } else {
             let cookie_path = match &args.rpc_cookie {
                 Some(path) => path,
@@ -479,7 +474,7 @@ impl SpaceCli {
             Self {
                 wallet: args.wallet.clone(),
                 format: args.output_format,
-                dust: args.dust.map(|d| Amount::from_sat(d)),
+                dust: args.dust.map(Amount::from_sat),
                 force: args.force,
                 skip_tx_check: args.skip_tx_check,
                 network: args.chain,
@@ -538,7 +533,7 @@ async fn main() -> anyhow::Result<()> {
 
     match result {
         Ok(_) => {}
-        Err(error) => match ClientError::from(error) {
+        Err(error) => match error {
             Error::Call(rpc) => {
                 print_error_rpc_response(rpc.code(), rpc.message().to_string(), cli.format);
             }
@@ -633,9 +628,8 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
         Commands::ExportWallet { path } => {
             let result = cli.client.wallet_export(&cli.wallet).await?;
             let content = serde_json::to_string_pretty(&result).expect("result");
-            fs::write(path, content).map_err(|e| {
-                ClientError::Custom(format!("Could not save to path: {}", e.to_string()))
-            })?;
+            fs::write(path, content)
+                .map_err(|e| ClientError::Custom(format!("Could not save to path: {}", e)))?;
         }
         Commands::GetWalletInfo => {
             let result = cli.client.wallet_get_info(&cli.wallet).await?;
@@ -698,12 +692,16 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
             .await?
         }
         Commands::Renew { spaces, fee_rate } => {
-            let spaces: Vec<_> = spaces.into_iter().map(|s| {
-                let normalized = normalize_space(&s);
-                Subject::Label(SLabel::from_str(&normalized).expect("valid space"))
-            }).collect();
+            let spaces: Vec<_> = spaces
+                .into_iter()
+                .map(|s| {
+                    let normalized = normalize_space(&s);
+                    Subject::Label(SLabel::from_str(&normalized).expect("valid space"))
+                })
+                .collect();
             cli.send_request(
-                Some(RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+                Some(RpcWalletRequest::Transfer(TransferSpacesParams {
+                    secret: None,
                     spaces,
                     to: None,
                     data: None,
@@ -722,8 +720,9 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
         } => {
             let secret = if secret_stdin {
                 let mut input = String::new();
-                io::stdin().read_line(&mut input)
-                    .map_err(|e| ClientError::Custom(format!("failed to read secret from stdin: {}", e)))?;
+                io::stdin().read_line(&mut input).map_err(|e| {
+                    ClientError::Custom(format!("failed to read secret from stdin: {}", e))
+                })?;
                 Some(input.trim().to_string())
             } else {
                 None
@@ -768,13 +767,17 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
             use base64::Engine;
             let data = if let Some(raw_b64) = raw {
                 // Raw base64-encoded wire-format bytes
-                base64::engine::general_purpose::STANDARD.decode(&raw_b64)
-                    .map_err(|e| ClientError::Custom(format!("Could not base64 decode data: {}", e)))?
+                base64::engine::general_purpose::STANDARD
+                    .decode(&raw_b64)
+                    .map_err(|e| {
+                        ClientError::Custom(format!("Could not base64 decode data: {}", e))
+                    })?
             } else if stdin {
                 // Read JSON records from stdin
                 let mut input = String::new();
-                io::stdin().read_line(&mut input).map_err(|e|
-                    ClientError::Custom(format!("Failed to read stdin: {}", e)))?;
+                io::stdin()
+                    .read_line(&mut input)
+                    .map_err(|e| ClientError::Custom(format!("Failed to read stdin: {}", e)))?;
                 let record_set: sip7::RecordSet = serde_json::from_str(input.trim())
                     .map_err(|e| ClientError::Custom(format!("Invalid SIP-7 JSON: {}", e)))?;
                 record_set.to_bytes()
@@ -782,15 +785,29 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 // Build from --txt and --blob flags
                 let mut records = Vec::new();
                 for txt in &txt_records {
-                    let (key, value) = txt.split_once('=').ok_or_else(||
-                        ClientError::Custom(format!("Invalid --txt format '{}': expected key=value", txt)))?;
+                    let (key, value) = txt.split_once('=').ok_or_else(|| {
+                        ClientError::Custom(format!(
+                            "Invalid --txt format '{}': expected key=value",
+                            txt
+                        ))
+                    })?;
                     records.push(sip7::Record::txt(key, &[value]));
                 }
                 for blob in &blob_records {
-                    let (key, b64_value) = blob.split_once('=').ok_or_else(||
-                        ClientError::Custom(format!("Invalid --blob format '{}': expected key=base64", blob)))?;
-                    let value = base64::engine::general_purpose::STANDARD.decode(b64_value)
-                        .map_err(|e| ClientError::Custom(format!("Invalid base64 in --blob '{}': {}", key, e)))?;
+                    let (key, b64_value) = blob.split_once('=').ok_or_else(|| {
+                        ClientError::Custom(format!(
+                            "Invalid --blob format '{}': expected key=base64",
+                            blob
+                        ))
+                    })?;
+                    let value = base64::engine::general_purpose::STANDARD
+                        .decode(b64_value)
+                        .map_err(|e| {
+                            ClientError::Custom(format!(
+                                "Invalid base64 in --blob '{}': {}",
+                                key, e
+                            ))
+                        })?;
                     records.push(sip7::Record::blob(key, value));
                 }
                 sip7::RecordSet::pack(records)
@@ -798,21 +815,22 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                     .to_bytes()
             } else {
                 return Err(ClientError::Custom(
-                    "No data specified. Use --txt, --blob, --raw, or --stdin".to_string()
+                    "No data specified. Use --txt, --blob, --raw, or --stdin".to_string(),
                 ));
             };
 
             cli.send_request(
-                Some(RpcWalletRequest::SetFallback(SetFallbackParams { subject, data })),
+                Some(RpcWalletRequest::SetFallback(SetFallbackParams {
+                    subject,
+                    data,
+                })),
                 None,
                 fee_rate,
                 false,
             )
             .await?;
         }
-        Commands::GetFallback {
-            subject,
-        } => {
+        Commands::GetFallback { subject } => {
             let response = cli.client.get_fallback(subject).await?;
             println!("{}", serde_json::to_string_pretty(&response)?);
         }
@@ -944,10 +962,10 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
             println!("{} Listing verified", "✓".color(Color::Green));
         }
         Commands::GenerateKey => {
-            use spaces_wallet::bitcoin::secp256k1::{Secp256k1, Keypair};
             use spaces_wallet::bitcoin::key::TapTweak;
-            use spaces_wallet::bitcoin::script::Builder;
             use spaces_wallet::bitcoin::opcodes::all::OP_PUSHNUM_1;
+            use spaces_wallet::bitcoin::script::Builder;
+            use spaces_wallet::bitcoin::secp256k1::{Keypair, Secp256k1};
 
             let secp = Secp256k1::new();
             let (secret_key, _) = secp.generate_keypair(&mut rand::thread_rng());
@@ -970,8 +988,10 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
         Commands::CreateNum { bind_spk, fee_rate } => {
             let spk = match bind_spk {
                 Some(hex) => {
-                    let spk = ScriptBuf::from(hex::decode(hex)
-                        .map_err(|_| ClientError::Custom("Invalid spk hex".to_string()))?);
+                    let spk = ScriptBuf::from(
+                        hex::decode(hex)
+                            .map_err(|_| ClientError::Custom("Invalid spk hex".to_string()))?,
+                    );
                     let num_id = NumId::from_spk::<Sha256>(spk.clone());
                     println!("Creating num id: {}", num_id);
                     Some(spk)
@@ -989,7 +1009,7 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 fee_rate,
                 false,
             )
-                .await?
+            .await?
         }
         Commands::GetNum { subject } => {
             let num = cli
@@ -1010,17 +1030,19 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
         }
         Commands::Operate { subject, fee_rate } => {
             cli.send_request(
-                Some(RpcWalletRequest::Operate(OperateParams {
-                    subject,
-                })),
+                Some(RpcWalletRequest::Operate(OperateParams { subject })),
                 None,
                 fee_rate,
                 false,
             )
-                .await?;
+            .await?;
             println!("Operate setup should be complete once tx is confirmed");
         }
-        Commands::Commit { subject, root, fee_rate } => {
+        Commands::Commit {
+            subject,
+            root,
+            fee_rate,
+        } => {
             cli.send_request(
                 Some(RpcWalletRequest::Commit(CommitParams {
                     subject,
@@ -1030,7 +1052,7 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 fee_rate,
                 false,
             )
-                .await?;
+            .await?;
         }
         Commands::Rollback { subject, fee_rate } => {
             cli.send_request(
@@ -1042,20 +1064,21 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 fee_rate,
                 false,
             )
-                .await?;
+            .await?;
             println!("Rollback transaction sent");
         }
-        Commands::Delegate { subject, to, fee_rate } => {
+        Commands::Delegate {
+            subject,
+            to,
+            fee_rate,
+        } => {
             cli.send_request(
-                Some(RpcWalletRequest::Delegate(DelegateParams {
-                    subject,
-                    to,
-                })),
+                Some(RpcWalletRequest::Delegate(DelegateParams { subject, to })),
                 None,
                 fee_rate,
                 false,
             )
-                .await?;
+            .await?;
         }
         Commands::GetDelegator { subject } => {
             let delegator = cli
diff --git a/client/src/bin/spaced.rs b/client/src/bin/spaced.rs
index 319e1ed..87850b4 100644
--- a/client/src/bin/spaced.rs
+++ b/client/src/bin/spaced.rs
@@ -1,14 +1,10 @@
-use std::{env};
+use std::env;
 
 use env_logger::Env;
 use log::error;
-use spaces_client::{
-    config::{safe_exit},
-};
-use tokio::{
-    sync::{broadcast},
-};
 use spaces_client::app::App;
+use spaces_client::config::safe_exit;
+use tokio::sync::broadcast;
 
 #[tokio::main]
 async fn main() {
@@ -26,7 +22,7 @@ async fn main() {
     match app.run(env::args().collect()).await {
         Ok(_) => {}
         Err(e) => {
-            error!("{}", e.to_string());
+            error!("{}", e);
             safe_exit(1);
         }
     }
diff --git a/client/src/cbf.rs b/client/src/cbf.rs
index 2e428f0..6c3ae37 100644
--- a/client/src/cbf.rs
+++ b/client/src/cbf.rs
@@ -1,19 +1,21 @@
-use std::collections::{BTreeMap, HashSet, VecDeque};
-use std::time::Duration;
+use crate::client::{BlockSource, BlockchainInfo};
+use crate::source::BitcoinBlockSource;
+use crate::wallets::{WalletProgressUpdate, WalletStatus};
 use anyhow::anyhow;
 use log::info;
-use tokio::time::Instant;
 use spaces_protocol::bitcoin::BlockHash;
 use spaces_protocol::constants::ChainAnchor;
-use spaces_wallet::bdk_wallet::chain::{local_chain, BlockId, ConfirmationBlockTime, IndexedTxGraph, TxUpdate};
+use spaces_wallet::SpacesWallet;
 use spaces_wallet::bdk_wallet::chain::keychain_txout::KeychainTxOutIndex;
+use spaces_wallet::bdk_wallet::chain::{
+    BlockId, ConfirmationBlockTime, IndexedTxGraph, TxUpdate, local_chain,
+};
 use spaces_wallet::bdk_wallet::{KeychainKind, Update};
-use spaces_wallet::bitcoin::bip158::BlockFilter;
 use spaces_wallet::bitcoin::ScriptBuf;
-use spaces_wallet::SpacesWallet;
-use crate::client::{BlockSource, BlockchainInfo};
-use crate::source::BitcoinBlockSource;
-use crate::wallets::{WalletStatus, WalletProgressUpdate};
+use spaces_wallet::bitcoin::bip158::BlockFilter;
+use std::collections::{BTreeMap, HashSet, VecDeque};
+use std::time::Duration;
+use tokio::time::Instant;
 
 pub struct CompactFilterSync {
     graph: IndexedTxGraph<ConfirmationBlockTime, KeychainTxOutIndex<KeychainKind>>,
@@ -47,7 +49,10 @@ impl CompactFilterSync {
     pub fn new(wallet: &SpacesWallet) -> Self {
         let initial_tip = {
             let tip = wallet.local_chain().tip();
-            ChainAnchor { height: tip.height(), hash: tip.hash() }
+            ChainAnchor {
+                height: tip.height(),
+                hash: tip.hash(),
+            }
         };
 
         let mut cbf = Self {
@@ -110,7 +115,10 @@ impl CompactFilterSync {
         source: &BitcoinBlockSource,
         progress: &mut WalletProgressUpdate,
     ) -> anyhow::Result<()> {
-        if self.wait.is_some_and(|w| w.elapsed() < Duration::from_secs(10)) {
+        if self
+            .wait
+            .is_some_and(|w| w.elapsed() < Duration::from_secs(10))
+        {
             return Ok(());
         }
         self.wait = None;
@@ -119,12 +127,17 @@ impl CompactFilterSync {
             SyncState::SyncChecks => {
                 let info = source.get_blockchain_info()?;
                 // if wallet already past prune height, we don't need filters
-                if let Some(prune_height) = info.prune_height {
-                    if self.initial_tip.height >= prune_height {
-                        info!("wallet({}): tip {} >= prune height {}, cbf done", wallet.name(), self.initial_tip.height, prune_height);
-                        self.state = SyncState::Synced;
-                        return Ok(());
-                    }
+                if let Some(prune_height) = info.prune_height
+                    && self.initial_tip.height >= prune_height
+                {
+                    info!(
+                        "wallet({}): tip {} >= prune height {}, cbf done",
+                        wallet.name(),
+                        self.initial_tip.height,
+                        prune_height
+                    );
+                    self.state = SyncState::Synced;
+                    return Ok(());
                 }
                 if info.headers != info.blocks {
                     info!("Source still syncing, retrying...");
@@ -140,8 +153,9 @@ impl CompactFilterSync {
                     }
 
                     info!("Filters syncing, retrying...");
-                    *progress = WalletProgressUpdate::new(WalletStatus::CbfFilterSync,
-                                                          Some(info.filters_progress.unwrap_or(0.0))
+                    *progress = WalletProgressUpdate::new(
+                        WalletStatus::CbfFilterSync,
+                        Some(info.filters_progress.unwrap_or(0.0)),
                     );
                     self.wait = Some(Instant::now());
                     return Ok(());
@@ -154,17 +168,21 @@ impl CompactFilterSync {
                     .ok_or_else(|| anyhow!("filter sync: checkpoint missing"))?;
                 if self.initial_tip.height < checkpoint.height {
                     return Err(anyhow!(
-                        "Wallet birthday {} < checkpoint {}", self.initial_tip.height, checkpoint.height
+                        "Wallet birthday {} < checkpoint {}",
+                        self.initial_tip.height,
+                        checkpoint.height
                     ));
                 }
 
                 let start = self.initial_tip.height;
-                let end = info
-                    .prune_height
-                    .ok_or(anyhow!("Prune height missing"))?;
+                let end = info.prune_height.ok_or(anyhow!("Prune height missing"))?;
                 let available_filters = info.filters.ok_or(anyhow!("Filters missing"))?;
                 if end > available_filters {
-                    return Err(anyhow!("Prune height {} > {} available filters", end, available_filters));
+                    return Err(anyhow!(
+                        "Prune height {} > {} available filters",
+                        end,
+                        available_filters
+                    ));
                 }
 
                 if start >= end {
@@ -193,21 +211,33 @@ impl CompactFilterSync {
                     self.queued_blocks.insert(height, idx_filter.hash);
                     self.load_more_scripts(wallet);
                     self.block_matches += 1;
-                    info!("wallet({}) processed block filter {} - match found", wallet.name(), height);
+                    info!(
+                        "wallet({}) processed block filter {} - match found",
+                        wallet.name(),
+                        height
+                    );
                 } else {
-                    info!("wallet({}) processed block filter {} - no match", wallet.name(), height);
+                    info!(
+                        "wallet({}) processed block filter {} - no match",
+                        wallet.name(),
+                        height
+                    );
                 }
 
                 let completed = self.total_filters as f32 - self.queued_filters.len() as f32;
                 *progress = WalletProgressUpdate::new(
                     WalletStatus::CbfProcessFilters,
-                    Some(completed / self.total_filters as f32)
+                    Some(completed / self.total_filters as f32),
                 );
             }
             SyncState::QueueBlocks => {
                 if !self.queued_blocks.is_empty() {
                     let heights: Vec<u32> = self.queued_blocks.keys().copied().collect();
-                    info!("wallet({}): queueing {} blocks", wallet.name(), heights.len());
+                    info!(
+                        "wallet({}): queueing {} blocks",
+                        wallet.name(),
+                        heights.len()
+                    );
                     source.queue_blocks(heights)?;
                 }
                 self.state = SyncState::WaitForBlocks;
@@ -220,7 +250,11 @@ impl CompactFilterSync {
                     .ok_or_else(|| anyhow!("filter sync: block queue missing"))?;
 
                 if status.pending > 0 {
-                    info!("wallet({}): waiting for {} pending blocks", wallet.name(), status.pending);
+                    info!(
+                        "wallet({}): waiting for {} pending blocks",
+                        wallet.name(),
+                        status.pending
+                    );
 
                     // The client has a global state for pending blocks in the queue
                     // so we cap it just in case other things are queuing blocks
@@ -229,7 +263,7 @@ impl CompactFilterSync {
                     let completed = self.block_matches as f32 - pending;
                     *progress = WalletProgressUpdate::new(
                         WalletStatus::CbfDownloadMatchingBlocks,
-                        Some(completed / self.block_matches as f32)
+                        Some(completed / self.block_matches as f32),
                     );
                     self.wait = Some(Instant::now());
                     return Ok(());
@@ -237,7 +271,9 @@ impl CompactFilterSync {
 
                 if status.completed < self.queued_blocks.len() as u32 {
                     return Err(anyhow!(
-                        "incomplete downloads: {} of {}", status.completed, self.queued_blocks.len()
+                        "incomplete downloads: {} of {}",
+                        status.completed,
+                        self.queued_blocks.len()
                     ));
                 }
                 self.state = SyncState::ProcessBlocks;
@@ -251,19 +287,31 @@ impl CompactFilterSync {
                     }
                     Some(f) => f,
                 };
-                info!("wallet({}): processing block {} {}", wallet.name(), height, hash);
-                let block = source.get_block(&hash)?
-                    .ok_or(anyhow!("block {} {} not found", height, hash))?;
+                info!(
+                    "wallet({}): processing block {} {}",
+                    wallet.name(),
+                    height,
+                    hash
+                );
+                let block = source.get_block(&hash)?.ok_or(anyhow!(
+                    "block {} {} not found",
+                    height,
+                    hash
+                ))?;
                 self.chain_changeset.insert(height, Some(hash));
                 let _ = self.graph.apply_block_relevant(&block, height);
                 let completed = self.block_matches - self.queued_blocks.len() as u32;
                 *progress = WalletProgressUpdate::new(
                     WalletStatus::CbfProcessMatchingBlocks,
-                    Some(completed as f32 / self.block_matches as f32)
+                    Some(completed as f32 / self.block_matches as f32),
                 );
             }
             SyncState::ApplyUpdate => {
-                info!("wallet({}): updating wallet tip to {}", wallet.name(), self.filters_tip);
+                info!(
+                    "wallet({}): updating wallet tip to {}",
+                    wallet.name(),
+                    self.filters_tip
+                );
                 let filters_anchor = BlockId {
                     height: self.filters_tip,
                     hash: source.get_block_hash(self.filters_tip)?,
@@ -272,7 +320,11 @@ impl CompactFilterSync {
                 let update = self.get_scan_response();
                 wallet.apply_update(update)?;
                 wallet.insert_checkpoint(filters_anchor)?;
-                info!("wallet({}): compact filter sync portion complete at {}", wallet.name(), self.filters_tip);
+                info!(
+                    "wallet({}): compact filter sync portion complete at {}",
+                    wallet.name(),
+                    self.filters_tip
+                );
                 self.state = SyncState::Synced;
                 // Only CBF portion is done
                 *progress = WalletProgressUpdate::new(WalletStatus::Syncing, None);
diff --git a/client/src/checker.rs b/client/src/checker.rs
index 9009b40..f4519b1 100644
--- a/client/src/checker.rs
+++ b/client/src/checker.rs
@@ -2,15 +2,15 @@ use std::collections::BTreeMap;
 
 use anyhow::anyhow;
 use spaces_protocol::{
+    Covenant, RevokeReason, SpaceOut,
     bitcoin::{OutPoint, Transaction},
     hasher::{KeyHasher, SpaceKey},
     prepare::{SpacesSource, TxContext},
     validate::{TxChangeSet, UpdateKind, Validator},
-    Covenant, RevokeReason, SpaceOut,
 };
 
-use crate::store::chain::Chain;
 use crate::store::Sha256;
+use crate::store::chain::Chain;
 
 pub struct TxChecker<'a> {
     pub original: &'a mut Chain,
@@ -46,7 +46,7 @@ impl<'a> TxChecker<'a> {
     ) -> anyhow::Result<Option<TxChangeSet>> {
         let changeset = self.apply_tx(height, tx)?;
         if let Some(changeset) = changeset.as_ref() {
-            Self::check(&changeset)?;
+            Self::check(changeset)?;
         }
         Ok(changeset)
     }
@@ -74,11 +74,9 @@ impl<'a> TxChecker<'a> {
                 txid,
                 vout: create.n as _,
             };
-            if create.space.is_some() {
-                let space = SpaceKey::from(Sha256::hash(
-                    create.space.as_ref().expect("space").name.as_ref(),
-                ));
-                self.spaces.insert(space, Some(outpoint));
+            if let Some(space) = create.space.as_ref() {
+                let key = SpaceKey::from(Sha256::hash(space.name.as_ref()));
+                self.spaces.insert(key, Some(outpoint));
             }
             self.spaceouts.insert(outpoint, Some(create));
         }
@@ -115,29 +113,27 @@ impl<'a> TxChecker<'a> {
             .iter()
             .any(|spend| spend.script_error.is_some())
         {
-            return Err(anyhow!("tx-check: transaction not broadcasted as it may have an open that will be rejected"));
+            return Err(anyhow!(
+                "tx-check: transaction not broadcasted as it may have an open that will be rejected"
+            ));
         }
         for create in changset.creates.iter() {
-            if let Some(space) = create.space.as_ref() {
-                match space.covenant {
-                    Covenant::Reserved => {
-                        return Err(anyhow!("tx-check: transaction not broadcasted as it may cause spaces to use a reserved covenant"))
-                    }
-                    _ => {}
-                }
+            if let Some(space) = create.space.as_ref()
+                && matches!(space.covenant, Covenant::Reserved)
+            {
+                return Err(anyhow!(
+                    "tx-check: transaction not broadcasted as it may cause spaces to use a reserved covenant"
+                ));
             }
         }
         for update in changset.updates.iter() {
-            match update.kind {
-                UpdateKind::Revoke(kind) => {
-                    match kind {
-                        RevokeReason::Expired => {}
-                        _ => {
-                            return Err(anyhow!("tx-check: transaction not broadcasted as it may cause a space to be revoked (code: {:?})", kind))
-                        }
-                    }
-                }
-                _ => {}
+            if let UpdateKind::Revoke(kind) = update.kind
+                && !matches!(kind, RevokeReason::Expired)
+            {
+                return Err(anyhow!(
+                    "tx-check: transaction not broadcasted as it may cause a space to be revoked (code: {:?})",
+                    kind
+                ));
             }
         }
         Ok(())
@@ -150,8 +146,8 @@ impl SpacesSource for TxChecker<'_> {
         space_hash: &SpaceKey,
     ) -> spaces_protocol::errors::Result<Option<OutPoint>> {
         match self.spaces.get(space_hash) {
-            None => self.original.get_space_outpoint(space_hash.into()),
-            Some(res) => Ok(res.clone()),
+            None => self.original.get_space_outpoint(space_hash),
+            Some(res) => Ok(*res),
         }
     }
 
diff --git a/client/src/client.rs b/client/src/client.rs
index e97d011..6b49fdd 100644
--- a/client/src/client.rs
+++ b/client/src/client.rs
@@ -3,27 +3,25 @@ pub extern crate spaces_protocol;
 
 use std::{error::Error, fmt};
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use borsh::{BorshDeserialize, BorshSerialize};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::de::Error as SerdeError;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use spaces_nums::{CommitmentKey, CommitmentTipKey, DelegatorKey, NumOutpointKey};
 use spaces_protocol::{
+    Bytes, Covenant, FullSpaceOut, RevokeReason, SpaceOut,
     bitcoin::{Amount, Block, BlockHash, OutPoint, Txid},
     constants::{ChainAnchor, ROLLOUT_BATCH_SIZE, ROLLOUT_BLOCK_INTERVAL},
     hasher::{BidKey, KeyHasher, OutpointKey, SpaceKey},
     prepare::TxContext,
     validate::{TxChangeSet, UpdateKind, Validator},
-    Bytes, Covenant, FullSpaceOut, RevokeReason, SpaceOut,
 };
-use spaces_nums::{CommitmentKey, CommitmentTipKey, DelegatorKey, NumOutpointKey};
 use spaces_wallet::bitcoin::{Network, Transaction};
 
-use crate::{
-    source::{BitcoinRpcError, BestChain},
-};
 use crate::source::BlockQueueResult;
-use crate::store::chain::{Chain};
+use crate::source::{BestChain, BitcoinRpcError};
 use crate::store::Sha256;
+use crate::store::chain::Chain;
 
 pub trait BlockSource {
     fn get_block_hash(&self, height: u32) -> Result<BlockHash, BitcoinRpcError>;
@@ -31,9 +29,16 @@ pub trait BlockSource {
     fn get_median_time(&self) -> Result<u64, BitcoinRpcError>;
     fn in_mempool(&self, txid: &Txid, height: u32) -> Result<bool, BitcoinRpcError>;
     fn get_block_count(&self) -> Result<u64, BitcoinRpcError>;
-    fn get_best_chain(&self, tip: Option<u32>, expected_chain: Network) -> Result<BestChain, BitcoinRpcError>;
+    fn get_best_chain(
+        &self,
+        tip: Option<u32>,
+        expected_chain: Network,
+    ) -> Result<BestChain, BitcoinRpcError>;
     fn get_blockchain_info(&self) -> Result<BlockchainInfo, BitcoinRpcError>;
-    fn get_block_filter_by_height(&self, height: u32) -> Result<Option<BlockFilterRpc>, BitcoinRpcError>;
+    fn get_block_filter_by_height(
+        &self,
+        height: u32,
+    ) -> Result<Option<BlockFilterRpc>, BitcoinRpcError>;
     fn queue_blocks(&self, heights: Vec<u32>) -> Result<(), BitcoinRpcError>;
     fn queue_filters(&self) -> Result<(), BitcoinRpcError>;
 }
@@ -42,10 +47,7 @@ pub trait BlockSource {
 pub struct BlockFilterRpc {
     pub hash: BlockHash,
     pub height: u32,
-    #[serde(
-        serialize_with = "serialize_hex",
-        deserialize_with = "deserialize_hex"
-    )]
+    #[serde(serialize_with = "serialize_hex", deserialize_with = "deserialize_hex")]
     pub content: Vec<u8>,
 }
 
@@ -74,7 +76,6 @@ pub struct BlockchainInfo {
     pub headers_synced: Option<bool>,
 }
 
-
 #[derive(Debug, Clone)]
 pub struct Client {
     validator: Validator,
@@ -105,7 +106,6 @@ pub struct PtrTxEntry {
     pub tx: Option<TxData>,
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
 pub struct TxEntry {
     #[serde(flatten)]
@@ -147,16 +147,21 @@ impl Client {
         }
     }
 
-    fn verify_block_connected(chain: &mut Chain, height: u32, block_hash: BlockHash, block: &Block) -> anyhow::Result<()> {
+    fn verify_block_connected(
+        chain: &mut Chain,
+        height: u32,
+        block_hash: BlockHash,
+        block: &Block,
+    ) -> anyhow::Result<()> {
         // Spaces tip must connect to block
         {
             let tip = chain.tip();
             if tip.hash != block.header.prev_blockhash || tip.height + 1 != height {
                 return Err(SyncError {
-                    checkpoint: tip.clone(),
+                    checkpoint: tip,
                     connect_to: (height, block_hash),
                 }
-                    .into());
+                .into());
             }
         }
         // Nums tip must connect to block
@@ -164,10 +169,10 @@ impl Client {
             let tip = chain.nums_tip();
             if tip.hash != block.header.prev_blockhash || tip.height + 1 != height {
                 return Err(SyncError {
-                    checkpoint: tip.clone(),
+                    checkpoint: tip,
                     connect_to: (height, block_hash),
                 }
-                    .into());
+                .into());
             }
         }
 
@@ -202,7 +207,7 @@ impl Client {
         }
 
         // Rollouts:
-        if (height - 1) % ROLLOUT_BLOCK_INTERVAL == 0 {
+        if (height - 1).is_multiple_of(ROLLOUT_BLOCK_INTERVAL) {
             let batch = Self::get_rollout_batch(ROLLOUT_BATCH_SIZE, chain)?;
             let coinbase = block
                 .coinbase()
@@ -232,7 +237,7 @@ impl Client {
             let mut spaceouts_input_ctx = None;
             if let Some(prepared) = TxContext::from_tx::<Chain, Sha256>(chain, tx)? {
                 spaceouts_input_ctx = Some(prepared.inputs.clone());
-                let validated_tx = self.validator.process(height, &tx, prepared);
+                let validated_tx = self.validator.process(height, tx, prepared);
                 spaceouts = Some(validated_tx.creates.clone());
 
                 if let Some(idx) = spaces_meta.as_mut() {
@@ -250,7 +255,7 @@ impl Client {
                         },
                     });
                 }
-                self.apply_space_tx(chain, &tx, validated_tx);
+                self.apply_space_tx(chain, tx, validated_tx);
             }
 
             let ptrs_ctx = if chain.can_scan_nums(height) {
@@ -258,17 +263,28 @@ impl Client {
                     chain,
                     tx,
                     spaceouts_input_ctx.is_some(),
-                    spaceouts.clone().unwrap_or(vec![]) , height)?
+                    spaceouts.clone().unwrap_or(vec![]),
+                    height,
+                )?
             } else {
                 None
             };
 
             if let Some(ptrs_ctx) = ptrs_ctx {
-                let spent_spaceouts = spaceouts_input_ctx.unwrap_or_default().into_iter()
-                    .map(|input| input.sstxo.previous_output).collect::<Vec<_>>();
+                let spent_spaceouts = spaceouts_input_ctx
+                    .unwrap_or_default()
+                    .into_iter()
+                    .map(|input| input.sstxo.previous_output)
+                    .collect::<Vec<_>>();
                 let created_spaceouts = spaceouts.unwrap_or_default();
-                let ptrs_validated = self.ptr_validator
-                    .process::<Sha256>(height, &tx, position as _, ptrs_ctx, spent_spaceouts, created_spaceouts);
+                let ptrs_validated = self.ptr_validator.process::<Sha256>(
+                    height,
+                    tx,
+                    position as _,
+                    ptrs_ctx,
+                    spent_spaceouts,
+                    created_spaceouts,
+                );
 
                 if let Some(idx) = num_meta.as_mut() {
                     {
@@ -299,7 +315,12 @@ impl Client {
         Ok((spaces_meta, num_meta))
     }
 
-    fn apply_ptrs_tx(&self, state: &mut Chain, tx: &Transaction, changeset: spaces_nums::TxChangeSet) {
+    fn apply_ptrs_tx(
+        &self,
+        state: &mut Chain,
+        tx: &Transaction,
+        changeset: spaces_nums::TxChangeSet,
+    ) {
         // Remove spends
         for n in changeset.spends.into_iter() {
             let previous = tx.input[n].previous_output;
@@ -313,7 +334,8 @@ impl Client {
         }
         // Remove revoked commitments
         for revoked in changeset.revoked_commitments {
-            let commitment_key = CommitmentKey::new::<Sha256>(&revoked.space, revoked.commitment.state_root);
+            let commitment_key =
+                CommitmentKey::new::<Sha256>(&revoked.space, revoked.commitment.state_root);
             state.remove_commitment(commitment_key);
 
             let registry_key = CommitmentTipKey::from_slabel::<Sha256>(&revoked.space);
@@ -333,14 +355,16 @@ impl Client {
 
         // Insert new commitments
         for commitment_info in changeset.commitments {
-            let commitment_key = CommitmentKey::new::<Sha256>(&commitment_info.space, commitment_info.commitment.state_root);
+            let commitment_key = CommitmentKey::new::<Sha256>(
+                &commitment_info.space,
+                commitment_info.commitment.state_root,
+            );
             let registry_key = CommitmentTipKey::from_slabel::<Sha256>(&commitment_info.space);
 
             // Points space -> commitments tip
             state.insert_commitment_tip(registry_key, commitment_info.commitment.state_root);
             // commitment key = HASH(HASH(space) || state root) -> commitment
             state.insert_commitment(commitment_key, commitment_info.commitment);
-
         }
 
         // Create ptrs
@@ -385,18 +409,15 @@ impl Client {
                             state.remove_space(space_key);
 
                             // Remove any bids from pre-auction pool
-                            match space.covenant {
-                                Covenant::Bid {
-                                    total_burned,
-                                    claim_height,
-                                    ..
-                                } => {
-                                    if claim_height.is_none() {
-                                        let bid_key = BidKey::from_bid(total_burned, base_hash);
-                                        state.remove_bid(bid_key)
-                                    }
-                                }
-                                _ => {}
+                            if let Covenant::Bid {
+                                total_burned,
+                                claim_height,
+                                ..
+                            } = space.covenant
+                                && claim_height.is_none()
+                            {
+                                let bid_key = BidKey::from_bid(total_burned, base_hash);
+                                state.remove_bid(bid_key)
                             }
                         }
                         RevokeReason::Expired => {
diff --git a/client/src/config.rs b/client/src/config.rs
index f336ee5..ed18e8d 100644
--- a/client/src/config.rs
+++ b/client/src/config.rs
@@ -12,17 +12,17 @@ use jsonrpsee::core::Serialize;
 use log::error;
 use rand::{
     distributions::Alphanumeric,
-    {thread_rng, Rng},
+    {Rng, thread_rng},
 };
 use serde::Deserialize;
 use spaces_protocol::bitcoin::Network;
 
+use crate::store::chain::{Chain, ROOT_ANCHORS_COUNT};
 use crate::{
     auth::{auth_token_from_cookie, auth_token_from_creds},
     source::{BitcoinRpc, BitcoinRpcAuth},
     spaces::Spaced,
 };
-use crate::store::chain::{Chain, ROOT_ANCHORS_COUNT};
 
 const RPC_OPTIONS: &str = "RPC Server Options";
 
@@ -72,7 +72,7 @@ pub struct Args {
     /// This option can be specified multiple times (default: 127.0.0.1 and ::1 i.e., localhost)
     #[arg(long, help_heading = Some(RPC_OPTIONS), default_values = ["127.0.0.1", "::1"], env = "SPACED_RPC_BIND")]
     rpc_bind: Vec<String>,
-    /// Listen for JSON-RPC connections on <port>
+    /// Listen for JSON-RPC connections on `<port>`
     #[arg(long, help_heading = Some(RPC_OPTIONS), env = "SPACED_RPC_PORT")]
     rpc_port: Option<u16>,
     /// Index blocks including the full transaction data
@@ -126,6 +126,7 @@ impl ExtendedNetwork {
         }
     }
 
+    #[allow(clippy::result_unit_err)]
     pub fn from_core_arg(arg: &str) -> Result<Self, ()> {
         match arg.to_lowercase().as_str() {
             "main" => Ok(ExtendedNetwork::Mainnet),
@@ -173,11 +174,8 @@ impl Args {
             })
             .collect();
 
-        let auth_token = if args.rpc_user.is_some() {
-            auth_token_from_creds(
-                args.rpc_user.as_ref().unwrap(),
-                args.rpc_password.as_ref().unwrap(),
-            )
+        let auth_token = if let Some(user) = args.rpc_user.as_ref() {
+            auth_token_from_creds(user, args.rpc_password.as_ref().unwrap())
         } else {
             let cookie = format!(
                 "__cookie__:{}",
@@ -200,13 +198,17 @@ impl Args {
 
         let bitcoin_rpc_auth = if let Some(cookie) = args.bitcoin_rpc_cookie {
             let cookie = std::fs::read_to_string(&cookie).map_err(|e| {
-                anyhow!("Failed to read Bitcoin RPC cookie '{}': {}", cookie.display(), e)
+                anyhow!(
+                    "Failed to read Bitcoin RPC cookie '{}': {}",
+                    cookie.display(),
+                    e
+                )
             })?;
             BitcoinRpcAuth::Cookie(cookie)
         } else if let Some(user) = args.bitcoin_rpc_user {
             BitcoinRpcAuth::UserPass(user, args.bitcoin_rpc_password.expect("password"))
-        } else if let Some(cookie) = default_bitcoin_cookie_path(&args.chain)
-            .and_then(|p| std::fs::read_to_string(&p).ok())
+        } else if let Some(cookie) =
+            default_bitcoin_cookie_path(&args.chain).and_then(|p| std::fs::read_to_string(&p).ok())
         {
             log::info!("Using Bitcoin Core cookie authentication");
             BitcoinRpcAuth::Cookie(cookie)
@@ -288,7 +290,9 @@ pub fn default_bitcoin_cookie_path(network: &ExtendedNetwork) -> Option<PathBuf>
     } else if cfg!(target_os = "macos") {
         home?.join("Library/Application Support/Bitcoin")
     } else if cfg!(target_os = "windows") {
-        std::env::var_os("APPDATA").map(PathBuf::from)?.join("Bitcoin")
+        std::env::var_os("APPDATA")
+            .map(PathBuf::from)?
+            .join("Bitcoin")
     } else {
         return None;
     };
diff --git a/client/src/format.rs b/client/src/format.rs
index 8297e5d..a6a0805 100644
--- a/client/src/format.rs
+++ b/client/src/format.rs
@@ -3,9 +3,11 @@ use colored::{Color, Colorize};
 use jsonrpsee::core::Serialize;
 use serde::Deserialize;
 use spaces_protocol::{
-    bitcoin::{Amount, Network, OutPoint}, Covenant
+    Covenant,
+    bitcoin::{Amount, Network, OutPoint},
 };
 use spaces_wallet::{
+    Balance, DoubleUtxo, WalletOutput,
     address::SpaceAddress,
     bdk_wallet::KeychainKind,
     bitcoin::{Address, Txid},
@@ -13,15 +15,14 @@ use spaces_wallet::{
         BidEventDetails, BidoutEventDetails, OpenEventDetails, SendEventDetails,
         TransferEventDetails, TxEventKind,
     },
-    Balance, DoubleUtxo, WalletOutput,
 };
 use tabled::{Table, Tabled};
 
+use crate::wallets::{WalletInfoWithProgress, WalletStatus};
 use crate::{
     rpc::ServerInfo,
     wallets::{ListNumsResponse, ListSpacesResponse, TxInfo, TxResponse, WalletResponse},
 };
-use crate::wallets::{WalletInfoWithProgress, WalletStatus};
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, ValueEnum, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -184,7 +185,10 @@ pub fn print_wallet_info(prog: WalletInfoWithProgress, format: Format) {
     match format {
         Format::Text => {
             println!("WALLET: {}", prog.info.label);
-            println!("  Tip {}\n  Birthday {}", prog.info.tip, prog.info.start_block);
+            println!(
+                "  Tip {}\n  Birthday {}",
+                prog.info.tip, prog.info.start_block
+            );
 
             println!("  Public descriptors");
             for desc in prog.info.descriptors {
@@ -195,7 +199,7 @@ pub fn print_wallet_info(prog: WalletInfoWithProgress, format: Format) {
             println!("  Sync Status:");
             let p = prog.sync.progress.unwrap_or(0.0);
             match prog.sync.status {
-                WalletStatus::HeadersSync  => {
+                WalletStatus::HeadersSync => {
                     println!("    Syncing block headers");
                 }
                 WalletStatus::ChainSync => {
@@ -204,20 +208,23 @@ pub fn print_wallet_info(prog: WalletInfoWithProgress, format: Format) {
                 WalletStatus::SpacesSync => {
                     println!("    Spaces Syncing: {:.1}%", p * 100.0);
                 }
-                WalletStatus::CbfFilterSync  => {
+                WalletStatus::CbfFilterSync => {
                     println!("    Filters Syncing: {:.1}%", p * 100.0);
                 }
                 WalletStatus::CbfProcessFilters => {
-                    println!("    Processing Filters: {:.1}%", p* 100.0);
+                    println!("    Processing Filters: {:.1}%", p * 100.0);
                 }
                 WalletStatus::CbfDownloadMatchingBlocks => {
                     println!("    Downloading Matching Blocks: {:.1}%", p * 100.0);
                 }
                 WalletStatus::CbfProcessMatchingBlocks => {
-                    println!("    Processing Matching Blocks: {:.1}%",p * 100.0);
+                    println!("    Processing Matching Blocks: {:.1}%", p * 100.0);
                 }
                 WalletStatus::Syncing => {
-                    println!("    Syncing: In progress ({:.1}%):", prog.info.progress * 100.0);
+                    println!(
+                        "    Syncing: In progress ({:.1}%):",
+                        prog.info.progress * 100.0
+                    );
                 }
                 WalletStatus::CbfApplyUpdate => {
                     println!("    Applying compact filters update");
@@ -225,7 +232,6 @@ pub fn print_wallet_info(prog: WalletInfoWithProgress, format: Format) {
                 WalletStatus::Complete => {
                     println!("    Complete");
                 }
-
             }
 
             println!();
@@ -238,7 +244,7 @@ pub fn print_wallet_info(prog: WalletInfoWithProgress, format: Format) {
 
 fn ascii_table<I, T>(iter: I) -> String
 where
-    I: IntoIterator<Item=T>,
+    I: IntoIterator<Item = T>,
     T: Tabled,
 {
     Table::new(iter)
@@ -282,7 +288,9 @@ pub fn print_list_spaces_response(
             let mut winnings = Vec::new();
             let mut owned = Vec::new();
             for slabel in response.pending {
-                pendings.push(PendingSpaces { space: slabel.to_string() });
+                pendings.push(PendingSpaces {
+                    space: slabel.to_string(),
+                });
             }
             for res in response.outbid {
                 let space = res.spaceout.space.as_ref().expect("space");
@@ -291,16 +299,14 @@ pub fn print_list_spaces_response(
                     last_confirmed_bid: 0,
                     days_left: "".to_string(),
                 };
-                match space.covenant {
-                    Covenant::Bid {
-                        total_burned,
-                        claim_height,
-                        ..
-                    } => {
-                        outbid.last_confirmed_bid = total_burned.to_sat();
-                        outbid.days_left = format_days_left(current_block, claim_height);
-                    }
-                    _ => {}
+                if let Covenant::Bid {
+                    total_burned,
+                    claim_height,
+                    ..
+                } = space.covenant
+                {
+                    outbid.last_confirmed_bid = total_burned.to_sat();
+                    outbid.days_left = format_days_left(current_block, claim_height);
                 }
                 outbids.push(outbid);
             }
@@ -313,22 +319,20 @@ pub fn print_list_spaces_response(
                     days_left: "--".to_string(),
                     claim_at: "--".to_string(),
                 };
-                match space.covenant {
-                    Covenant::Bid {
-                        total_burned,
-                        claim_height,
-                        ..
-                    } => {
-                        winning.bid = total_burned.to_sat();
-                        winning.claim_at = claim_height
-                            .map(|h| h.to_string())
-                            .unwrap_or("--".to_string());
-                        winning.days_left = format_days_left(current_block, claim_height);
-                        if winning.days_left == "0.00" {
-                            winning.days_left = "Ready to claim".to_string();
-                        }
+                if let Covenant::Bid {
+                    total_burned,
+                    claim_height,
+                    ..
+                } = space.covenant
+                {
+                    winning.bid = total_burned.to_sat();
+                    winning.claim_at = claim_height
+                        .map(|h| h.to_string())
+                        .unwrap_or("--".to_string());
+                    winning.days_left = format_days_left(current_block, claim_height);
+                    if winning.days_left == "0.00" {
+                        winning.days_left = "Ready to claim".to_string();
                     }
-                    _ => {}
                 }
                 winnings.push(winning);
             }
@@ -340,19 +344,18 @@ pub fn print_list_spaces_response(
                     days_left: "--".to_string(),
                     utxo: res.outpoint(),
                 };
-                match &space.covenant {
-                    Covenant::Transfer { expire_height, .. } => {
-                        registered.expire_at = *expire_height as _;
-                        registered.days_left =
-                            format_days_left(current_block, Some(*expire_height));
-                    }
-                    _ => {}
+                if let Covenant::Transfer { expire_height, .. } = &space.covenant {
+                    registered.expire_at = *expire_height as _;
+                    registered.days_left = format_days_left(current_block, Some(*expire_height));
                 }
                 owned.push(registered);
             }
 
             if !pendings.is_empty() {
-                println!("⏳ PENDING ({} spaces): ", pendings.len().to_string().bold());
+                println!(
+                    "⏳ PENDING ({} spaces): ",
+                    pendings.len().to_string().bold()
+                );
                 let table = ascii_table(pendings);
                 println!("{}", table);
             }
@@ -374,11 +377,7 @@ pub fn print_list_spaces_response(
             }
 
             if !owned.is_empty() {
-                println!(
-                    "{} ({} spaces): ",
-                    "🔑 OWNED",
-                    owned.len().to_string().bold()
-                );
+                println!("🔑 OWNED ({} spaces): ", owned.len().to_string().bold());
                 let table = ascii_table(owned);
                 println!("{}", table);
             }
@@ -411,15 +410,17 @@ pub fn print_wallet_response_text(network: Network, response: WalletResponse) {
     let mut secondary_txs = Vec::new();
 
     for tx in response.result {
-        if tx.events.iter().any(|event| match event.kind {
-            TxEventKind::Open
-            | TxEventKind::Bid
-            | TxEventKind::Register
-            | TxEventKind::Transfer
-            | TxEventKind::Send
-            | TxEventKind::Renew
-            | TxEventKind::Buy => true,
-            _ => false,
+        if tx.events.iter().any(|event| {
+            matches!(
+                event.kind,
+                TxEventKind::Open
+                    | TxEventKind::Bid
+                    | TxEventKind::Register
+                    | TxEventKind::Transfer
+                    | TxEventKind::Send
+                    | TxEventKind::Renew
+                    | TxEventKind::Buy
+            )
         }) {
             main_txs.push(tx);
         } else {
diff --git a/client/src/lib.rs b/client/src/lib.rs
index 934d626..64fb07a 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -9,7 +9,9 @@ use std::time::{Duration, Instant};
 use base64::Engine;
 use serde::{Deserialize, Deserializer, Serializer};
 
+pub mod app;
 pub mod auth;
+mod cbf;
 mod checker;
 pub mod client;
 pub mod config;
@@ -18,11 +20,9 @@ pub mod rpc;
 #[cfg(feature = "schema")]
 pub mod rpc_schema;
 pub mod source;
+mod spaces;
 pub mod store;
 pub mod wallets;
-mod cbf;
-pub mod app;
-mod spaces;
 
 fn std_wait<F>(mut predicate: F, wait: Duration)
 where
diff --git a/client/src/rpc.rs b/client/src/rpc.rs
index 3cb64fa..33447a5 100644
--- a/client/src/rpc.rs
+++ b/client/src/rpc.rs
@@ -1,77 +1,78 @@
-use std::{
-    collections::BTreeMap, fs, fs::File, io::Write, net::SocketAddr, path::PathBuf, str::FromStr,
-    sync::Arc,
+use crate::auth::BasicAuthLayer;
+use crate::store::Sha256;
+use crate::store::chain::{CACHED_SNAPSHOT_LOOKBACK, COMMIT_BLOCK_INTERVAL, Chain};
+use crate::store::spaces::RolloutEntry;
+use crate::wallets::WalletInfoWithProgress;
+use crate::{
+    calc_progress,
+    checker::TxChecker,
+    client::{BlockMeta, BlockchainInfo, NumBlockMeta, TxEntry},
+    config::ExtendedNetwork,
+    deserialize_base64, serialize_base64,
+    source::BitcoinRpc,
+    wallets::{
+        AddressKind, ListNumsResponse, ListSpacesResponse, RpcWallet, TxInfo, TxResponse,
+        WalletCommand, WalletResponse,
+    },
 };
-use std::collections::HashSet;
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use bdk::{
+    KeychainKind,
     bitcoin::{Amount, BlockHash, FeeRate, Network, Txid},
     chain::BlockId,
     keys::{
-        bip39::{Language, Mnemonic, WordCount},
         DerivableKey, ExtendedKey, GeneratableKey, GeneratedKey,
+        bip39::{Language, Mnemonic, WordCount},
     },
     miniscript::Tap,
-    KeychainKind,
 };
 use jsonrpsee::{
     core::async_trait,
     proc_macros::rpc,
-    server::{middleware::http::ProxyGetRequestLayer, Server},
+    server::{Server, middleware::http::ProxyGetRequestLayer},
     types::ErrorObjectOwned,
 };
 use log::info;
 use serde::{Deserialize, Serialize};
 use spacedb::tx::ProofType;
+use spaces_nums::num_id::NumId;
+use spaces_nums::snumeric::SNumeric;
+use spaces_nums::{
+    ChainProofRequest, Commitment, CommitmentKey, CommitmentTipKey, DelegatorKey, FullNumOut,
+    NumKeyKind, NumOut, NumOutpointKey, NumSource, RootAnchor,
+};
+use spaces_protocol::bitcoin::ScriptBuf;
+use spaces_protocol::hasher::Hash;
 use spaces_protocol::{
-    bitcoin,
+    Bytes, Covenant, FullSpaceOut, SpaceOut, bitcoin,
     bitcoin::{
-        bip32::Xpriv,
         Network::{Regtest, Testnet},
         OutPoint,
+        bip32::Xpriv,
     },
     constants::ChainAnchor,
     hasher::{KeyHasher, OutpointKey, SpaceKey},
     prepare::SpacesSource,
     slabel::SLabel,
     validate::TxChangeSet,
-    Bytes, Covenant, FullSpaceOut, SpaceOut,
 };
+pub use spaces_wallet::Subject;
+use spaces_wallet::bitcoin::hashes::sha256;
 use spaces_wallet::{
+    Balance, DoubleUtxo, Listing, SpacesWallet, WalletConfig, WalletDescriptors, WalletOutput,
     bdk_wallet as bdk, bdk_wallet::template::Bip86, bitcoin::hashes::Hash as BitcoinHash,
-    bitcoin::secp256k1::schnorr,
-    export::WalletExport, Balance, DoubleUtxo, Listing, SpacesWallet,
-    WalletConfig, WalletDescriptors, WalletOutput,
+    bitcoin::secp256k1::schnorr, export::WalletExport,
+};
+use std::collections::HashSet;
+use std::{
+    collections::BTreeMap, fs, fs::File, io::Write, net::SocketAddr, path::PathBuf, str::FromStr,
+    sync::Arc,
 };
-pub use spaces_wallet::Subject;
 use tokio::{
     select,
-    sync::{broadcast, mpsc, oneshot, RwLock},
+    sync::{RwLock, broadcast, mpsc, oneshot},
     task::JoinSet,
 };
-use spaces_protocol::bitcoin::ScriptBuf;
-use spaces_protocol::hasher::Hash;
-use spaces_nums::{NumSource, FullNumOut, NumOut, Commitment, CommitmentTipKey, CommitmentKey, DelegatorKey, NumOutpointKey, RootAnchor, ChainProofRequest, NumKeyKind};
-use spaces_nums::snumeric::SNumeric;
-use spaces_nums::num_id::NumId;
-use spaces_wallet::bitcoin::hashes::sha256;
-use crate::auth::BasicAuthLayer;
-use crate::wallets::WalletInfoWithProgress;
-use crate::{
-    calc_progress,
-    checker::TxChecker,
-    client::{BlockMeta, NumBlockMeta, TxEntry, BlockchainInfo},
-    config::ExtendedNetwork,
-    deserialize_base64, serialize_base64,
-    source::BitcoinRpc,
-    wallets::{
-        AddressKind, ListNumsResponse, ListSpacesResponse, RpcWallet, TxInfo, TxResponse,
-        WalletCommand, WalletResponse,
-    },
-};
-use crate::store::chain::{Chain, COMMIT_BLOCK_INTERVAL, CACHED_SNAPSHOT_LOOKBACK};
-use crate::store::Sha256;
-use crate::store::spaces::RolloutEntry;
 
 pub(crate) type Responder<T> = oneshot::Sender<T>;
 
@@ -87,7 +88,6 @@ pub struct ServerInfo {
     pub progress: f32,
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct ChainInfo {
@@ -219,7 +219,6 @@ pub struct AsyncChainState {
     sender: mpsc::Sender<ChainStateCommand>,
 }
 
-
 #[rpc(server, client)]
 pub trait Rpc {
     #[method(name = "getserverinfo")]
@@ -241,27 +240,24 @@ pub trait Rpc {
     async fn get_spaceout(&self, outpoint: OutPoint) -> Result<Option<SpaceOut>, ErrorObjectOwned>;
 
     #[method(name = "getnum")]
-    async fn get_num(
-        &self,
-        subject: Subject,
-    ) -> Result<Option<FullNumOut>, ErrorObjectOwned>;
+    async fn get_num(&self, subject: Subject) -> Result<Option<FullNumOut>, ErrorObjectOwned>;
 
     #[method(name = "getnumowner")]
-    async fn get_num_owner(
-        &self,
-        subject: Subject,
-    ) -> Result<Option<OutPoint>, ErrorObjectOwned>;
+    async fn get_num_owner(&self, subject: Subject) -> Result<Option<OutPoint>, ErrorObjectOwned>;
 
     #[method(name = "getnumout")]
     async fn get_numout(&self, outpoint: OutPoint) -> Result<Option<NumOut>, ErrorObjectOwned>;
 
     #[method(name = "getcommitment")]
-    async fn get_commitment(&self, subject: Subject, root: Option<sha256::Hash>) -> Result<Option<Commitment>, ErrorObjectOwned>;
+    async fn get_commitment(
+        &self,
+        subject: Subject,
+        root: Option<sha256::Hash>,
+    ) -> Result<Option<Commitment>, ErrorObjectOwned>;
 
     #[method(name = "getdelegation")]
     async fn get_delegation(&self, subject: Subject) -> Result<Option<NumId>, ErrorObjectOwned>;
 
-
     #[method(name = "getdelegator")]
     async fn get_delegator(&self, subject: Subject) -> Result<Option<SLabel>, ErrorObjectOwned>;
 
@@ -301,7 +297,6 @@ pub trait Rpc {
     #[method(name = "walletimport")]
     async fn wallet_import(&self, wallet: WalletExport) -> Result<(), ErrorObjectOwned>;
 
-
     #[method(name = "walletcanoperate")]
     async fn wallet_can_operate(
         &self,
@@ -327,7 +322,7 @@ pub trait Rpc {
 
     #[method(name = "walletgetinfo")]
     async fn wallet_get_info(&self, name: &str)
-                             -> Result<WalletInfoWithProgress, ErrorObjectOwned>;
+    -> Result<WalletInfoWithProgress, ErrorObjectOwned>;
 
     #[method(name = "walletexport")]
     async fn wallet_export(&self, name: &str) -> Result<WalletExport, ErrorObjectOwned>;
@@ -447,7 +442,11 @@ pub trait Rpc {
 
     /// Debug method to set a space's expire height (regtest only)
     #[method(name = "debugsetexpireheight")]
-    async fn debug_set_expire_height(&self, space: &str, expire_height: u32) -> Result<(), ErrorObjectOwned>;
+    async fn debug_set_expire_height(
+        &self,
+        space: &str,
+        expire_height: u32,
+    ) -> Result<(), ErrorObjectOwned>;
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -604,7 +603,6 @@ pub struct RpcServerImpl {
     client: reqwest::Client,
 }
 
-
 /// Combined proof result for a chain proof request containing subtrees from both
 /// spaces and ptrs trees at the same snapshot height.
 #[derive(Clone, Serialize, Deserialize)]
@@ -679,7 +677,11 @@ impl WalletManager {
         Ok(export)
     }
 
-    pub async fn create_wallet(&self, client: &reqwest::Client, name: &str) -> anyhow::Result<String> {
+    pub async fn create_wallet(
+        &self,
+        client: &reqwest::Client,
+        name: &str,
+    ) -> anyhow::Result<String> {
         let mnemonic: GeneratedKey<_, Tap> =
             Mnemonic::generate((WordCount::Words12, Language::English))
                 .map_err(|_| anyhow!("Mnemonic generation error"))?;
@@ -690,7 +692,12 @@ impl WalletManager {
         Ok(mnemonic.to_string())
     }
 
-    pub async fn recover_wallet(&self, client: &reqwest::Client, name: &str, mnemonic: &str) -> anyhow::Result<()> {
+    pub async fn recover_wallet(
+        &self,
+        client: &reqwest::Client,
+        name: &str,
+        mnemonic: &str,
+    ) -> anyhow::Result<()> {
         let start_block = self.get_wallet_start_block(client).await?;
         self.setup_new_wallet(name.to_string(), mnemonic.to_string(), start_block)?;
         self.load_wallet(name).await?;
@@ -836,13 +843,13 @@ impl WalletManager {
     async fn get_wallet_start_block(&self, client: &reqwest::Client) -> anyhow::Result<BlockId> {
         let count: i32 = self
             .rpc
-            .send_json(&client, &self.rpc.get_block_count())
+            .send_json(client, &self.rpc.get_block_count())
             .await?;
         let height = std::cmp::max(count - 1, 0) as u32;
 
         let hash = self
             .rpc
-            .send_json(&client, &self.rpc.get_block_hash(height))
+            .send_json(client, &self.rpc.get_block_hash(height))
             .await?;
 
         Ok(BlockId { height, hash })
@@ -913,16 +920,19 @@ impl RpcServerImpl {
 
             let mut module = self.clone().into_rpc();
             let methods: Vec<String> = module.method_names().map(|s| s.to_string()).collect();
-            module.register_method("rpc.discover", move |_, _| {
-                serde_json::json!({ "methods": methods })
-            }).expect("register rpc.discover");
+            module
+                .register_method(
+                    "rpc.discover",
+                    move |_, _| serde_json::json!({ "methods": methods }),
+                )
+                .expect("register rpc.discover");
 
             #[cfg(feature = "schema")]
             {
                 let spec = crate::rpc_schema::full_spec();
-                module.register_method("rpc.schema", move |_, _| {
-                    spec.clone()
-                }).expect("register rpc.schema");
+                module
+                    .register_method("rpc.schema", move |_, _| spec.clone())
+                    .expect("register rpc.schema");
             }
 
             let handle = listener.start(module);
@@ -1028,7 +1038,11 @@ impl RpcServer for RpcServerImpl {
         Ok(spaceout)
     }
 
-    async fn get_commitment(&self, subject: Subject, root: Option<sha256::Hash>) -> Result<Option<Commitment>, ErrorObjectOwned> {
+    async fn get_commitment(
+        &self,
+        subject: Subject,
+        root: Option<sha256::Hash>,
+    ) -> Result<Option<Commitment>, ErrorObjectOwned> {
         let c = self
             .store
             .get_commitment(subject, root.map(|r| *r.as_ref()))
@@ -1055,7 +1069,6 @@ impl RpcServer for RpcServerImpl {
         Ok(delegator)
     }
 
-
     async fn check_package(
         &self,
         txs: Vec<String>,
@@ -1152,7 +1165,7 @@ impl RpcServer for RpcServerImpl {
         subject: Subject,
         message: Bytes,
     ) -> Result<Bytes, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_sign_schnorr(subject, message.to_vec())
             .await
@@ -1165,7 +1178,7 @@ impl RpcServer for RpcServerImpl {
         wallet: &str,
         subject: Subject,
     ) -> Result<bool, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_can_operate(subject)
             .await
@@ -1189,7 +1202,7 @@ impl RpcServer for RpcServerImpl {
         &self,
         wallet: &str,
     ) -> Result<WalletInfoWithProgress, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_get_info()
             .await
@@ -1228,7 +1241,7 @@ impl RpcServer for RpcServerImpl {
         request: RpcWalletTxBuilder,
     ) -> Result<WalletResponse, ErrorObjectOwned> {
         let result = self
-            .wallet(&wallet)
+            .wallet(wallet)
             .await?
             .send_batch_tx(request)
             .await
@@ -1241,7 +1254,7 @@ impl RpcServer for RpcServerImpl {
         wallet: &str,
         kind: AddressKind,
     ) -> Result<String, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_get_new_address(kind)
             .await
@@ -1253,7 +1266,7 @@ impl RpcServer for RpcServerImpl {
         wallet: &str,
         kind: AddressKind,
     ) -> Result<String, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_increment_address(kind)
             .await
@@ -1267,7 +1280,7 @@ impl RpcServer for RpcServerImpl {
         fee_rate: FeeRate,
         skip_tx_check: bool,
     ) -> Result<Vec<TxResponse>, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_fee_bump(txid, fee_rate, skip_tx_check)
             .await
@@ -1281,7 +1294,7 @@ impl RpcServer for RpcServerImpl {
         fee_rate: Option<FeeRate>,
         skip_tx_check: bool,
     ) -> Result<TxResponse, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_buy(listing, fee_rate, skip_tx_check)
             .await
@@ -1294,7 +1307,7 @@ impl RpcServer for RpcServerImpl {
         space: String,
         amount: u64,
     ) -> Result<Listing, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_sell(space, amount)
             .await
@@ -1332,7 +1345,7 @@ impl RpcServer for RpcServerImpl {
         count: usize,
         skip: usize,
     ) -> Result<Vec<TxInfo>, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_list_transactions(count, skip)
             .await
@@ -1345,7 +1358,7 @@ impl RpcServer for RpcServerImpl {
         outpoint: OutPoint,
         fee_rate: FeeRate,
     ) -> Result<TxResponse, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_force_spend(outpoint, fee_rate)
             .await
@@ -1356,7 +1369,7 @@ impl RpcServer for RpcServerImpl {
         &self,
         wallet: &str,
     ) -> Result<ListSpacesResponse, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_list_spaces()
             .await
@@ -1369,7 +1382,7 @@ impl RpcServer for RpcServerImpl {
         kind: Option<String>,
     ) -> Result<ListNumsResponse, ErrorObjectOwned> {
         let external = kind.as_deref() == Some("external");
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_list_nums(external)
             .await
@@ -1380,7 +1393,7 @@ impl RpcServer for RpcServerImpl {
         &self,
         wallet: &str,
     ) -> Result<Vec<WalletOutput>, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_list_unspent()
             .await
@@ -1388,7 +1401,7 @@ impl RpcServer for RpcServerImpl {
     }
 
     async fn wallet_list_bidouts(&self, wallet: &str) -> Result<Vec<DoubleUtxo>, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_list_bidouts()
             .await
@@ -1396,34 +1409,42 @@ impl RpcServer for RpcServerImpl {
     }
 
     async fn wallet_get_balance(&self, wallet: &str) -> Result<Balance, ErrorObjectOwned> {
-        self.wallet(&wallet)
+        self.wallet(wallet)
             .await?
             .send_get_balance()
             .await
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }
 
-    async fn get_fallback(&self, subject: Subject) -> Result<Option<FallbackResponse>, ErrorObjectOwned> {
-        let data = match &subject {
-            Subject::Label(label) if !label.is_numeric() => {
-                let space_hash = SpaceKey::from(Sha256::hash(label.as_ref()));
-                let fso = self.store.get_space(space_hash).await
-                    .map_err(|e| ErrorObjectOwned::owned(-1, e.to_string(), None::<String>))?;
-                fso.and_then(|fso| {
-                    if let Some(space) = &fso.spaceout.space {
-                        if let Covenant::Transfer { data, .. } = &space.covenant {
+    async fn get_fallback(
+        &self,
+        subject: Subject,
+    ) -> Result<Option<FallbackResponse>, ErrorObjectOwned> {
+        let data =
+            match &subject {
+                Subject::Label(label) if !label.is_numeric() => {
+                    let space_hash = SpaceKey::from(Sha256::hash(label.as_ref()));
+                    let fso =
+                        self.store.get_space(space_hash).await.map_err(|e| {
+                            ErrorObjectOwned::owned(-1, e.to_string(), None::<String>)
+                        })?;
+                    fso.and_then(|fso| {
+                        if let Some(space) = &fso.spaceout.space
+                            && let Covenant::Transfer { data, .. } = &space.covenant
+                        {
                             return data.as_ref().map(|b| b.clone().to_vec());
                         }
-                    }
-                    None
-                })
-            }
-            _ => {
-                let fpt = self.store.get_ptr(subject).await
-                    .map_err(|e| ErrorObjectOwned::owned(-1, e.to_string(), None::<String>))?;
-                fpt.and_then(|fpt| fpt.numout.num.data.map(|b| b.to_vec()))
-            }
-        };
+                        None
+                    })
+                }
+                _ => {
+                    let fpt =
+                        self.store.get_ptr(subject).await.map_err(|e| {
+                            ErrorObjectOwned::owned(-1, e.to_string(), None::<String>)
+                        })?;
+                    fpt.and_then(|fpt| fpt.numout.num.data.map(|b| b.to_vec()))
+                }
+            };
 
         match data {
             None => Ok(None),
@@ -1440,16 +1461,28 @@ impl RpcServer for RpcServerImpl {
         }
     }
 
-    async fn debug_set_expire_height(&self, space: &str, expire_height: u32) -> Result<(), ErrorObjectOwned> {
+    async fn debug_set_expire_height(
+        &self,
+        space: &str,
+        expire_height: u32,
+    ) -> Result<(), ErrorObjectOwned> {
         // Only allow on regtest
-        let info = self.store.get_server_info().await
+        let info = self
+            .store
+            .get_server_info()
+            .await
             .map_err(|e| ErrorObjectOwned::owned(-1, e.to_string(), None::<String>))?;
         if info.network != ExtendedNetwork::Regtest {
-            return Err(ErrorObjectOwned::owned(-1, "debug_set_expire_height is only available on regtest", None::<String>));
+            return Err(ErrorObjectOwned::owned(
+                -1,
+                "debug_set_expire_height is only available on regtest",
+                None::<String>,
+            ));
         }
 
-        let space_label = SLabel::from_str(space)
-            .map_err(|e| ErrorObjectOwned::owned(-1, format!("Invalid space name: {}", e), None::<String>))?;
+        let space_label = SLabel::from_str(space).map_err(|e| {
+            ErrorObjectOwned::owned(-1, format!("Invalid space name: {}", e), None::<String>)
+        })?;
 
         self.store
             .debug_set_expire_height(space_label, expire_height)
@@ -1470,7 +1503,7 @@ impl AsyncChainState {
         rpc: &BitcoinRpc,
     ) -> Result<Option<TxEntry>, anyhow::Error> {
         let info: serde_json::Value = rpc
-            .send_json(client, &rpc.get_raw_transaction(&txid, true))
+            .send_json(client, &rpc.get_raw_transaction(txid, true))
             .await
             .map_err(|e| anyhow!("Could not retrieve tx ({})", e))?;
 
@@ -1478,13 +1511,8 @@ impl AsyncChainState {
             BlockHash::from_str(info.get("blockhash").and_then(|t| t.as_str()).ok_or_else(
                 || anyhow!("Could not retrieve block hash for tx (is it in the mempool?)"),
             )?)?;
-        let block = Self::get_indexed_block(
-            state,
-            HeightOrHash::Hash(block_hash),
-            client,
-            rpc,
-        )
-            .await?;
+        let block =
+            Self::get_indexed_block(state, HeightOrHash::Hash(block_hash), client, rpc).await?;
 
         Ok(block
             .block_meta
@@ -1633,16 +1661,22 @@ impl AsyncChainState {
                 let _ = resp.send(result);
             }
             ChainStateCommand::GetNum { subject, resp } => {
-                let result = resolve_num_id(state, &subject)
-                    .and_then(|id| state.get_num_info(&id));
+                let result = resolve_num_id(state, &subject).and_then(|id| state.get_num_info(&id));
                 let _ = resp.send(result);
             }
             ChainStateCommand::GetNumOutpoint { subject, resp } => {
-                let result = resolve_num_id(state, &subject)
-                    .and_then(|id| state.get_num_outpoint_by_id(&id).context("could not fetch numout"));
+                let result = resolve_num_id(state, &subject).and_then(|id| {
+                    state
+                        .get_num_outpoint_by_id(&id)
+                        .context("could not fetch numout")
+                });
                 let _ = resp.send(result);
             }
-            ChainStateCommand::GetCommitment { subject, root, resp } => {
+            ChainStateCommand::GetCommitment {
+                subject,
+                root,
+                resp,
+            } => {
                 let result = get_commitment(state, &subject, root);
                 let _ = resp.send(result);
             }
@@ -1651,9 +1685,11 @@ impl AsyncChainState {
                 let _ = resp.send(result);
             }
             ChainStateCommand::GetDelegator { subject, resp } => {
-                let result = resolve_num_id(state, &subject)
-                    .and_then(|id| state.get_delegator(&DelegatorKey::from_id::<Sha256>(id))
-                        .map_err(|e| anyhow!("could not get delegator: {}", e)));
+                let result = resolve_num_id(state, &subject).and_then(|id| {
+                    state
+                        .get_delegator(&DelegatorKey::from_id::<Sha256>(id))
+                        .map_err(|e| anyhow!("could not get delegator: {}", e))
+                });
                 let _ = resp.send(result);
             }
             ChainStateCommand::GetNumOut { outpoint, resp } => {
@@ -1666,18 +1702,14 @@ impl AsyncChainState {
                 height_or_hash,
                 resp,
             } => {
-                let res =
-                    Self::get_indexed_block(state, height_or_hash, client, rpc)
-                        .await;
+                let res = Self::get_indexed_block(state, height_or_hash, client, rpc).await;
                 let _ = resp.send(res);
             }
             ChainStateCommand::GetNumBlockMeta {
                 height_or_hash,
                 resp,
             } => {
-                let res =
-                    Self::get_indexed_ptr_block(state, height_or_hash, client, rpc)
-                        .await;
+                let res = Self::get_indexed_ptr_block(state, height_or_hash, client, rpc).await;
                 let _ = resp.send(res);
             }
             ChainStateCommand::GetTxMeta { txid, resp } => {
@@ -1693,11 +1725,14 @@ impl AsyncChainState {
                 _ = resp.send(rollouts);
             }
             ChainStateCommand::VerifyListing { listing, resp } => {
-                _ = resp.send(
-                    SpacesWallet::verify_listing::<Sha256>(state, &listing).map(|_| ()),
-                );
+                _ = resp.send(SpacesWallet::verify_listing::<Sha256>(state, &listing).map(|_| ()));
             }
-            ChainStateCommand::VerifySchnorr { subject, message, signature, resp } => {
+            ChainStateCommand::VerifySchnorr {
+                subject,
+                message,
+                signature,
+                resp,
+            } => {
                 let result = (|| {
                     let sig = schnorr::Signature::from_slice(&signature)
                         .map_err(|_| anyhow!("Invalid signature format"))?;
@@ -1719,8 +1754,16 @@ impl AsyncChainState {
             ChainStateCommand::GetRootAnchors { resp } => {
                 _ = resp.send(Self::handle_get_anchor(anchors_path, state));
             }
-            ChainStateCommand::DebugSetExpireHeight { space, expire_height, resp } => {
-                _ = resp.send(Self::handle_debug_set_expire_height(state, space, expire_height));
+            ChainStateCommand::DebugSetExpireHeight {
+                space,
+                expire_height,
+                resp,
+            } => {
+                _ = resp.send(Self::handle_debug_set_expire_height(
+                    state,
+                    space,
+                    expire_height,
+                ));
             }
         }
     }
@@ -1731,18 +1774,26 @@ impl AsyncChainState {
         expire_height: u32,
     ) -> anyhow::Result<()> {
         let space_key = SpaceKey::from(Sha256::hash(space.as_ref()));
-        let outpoint = state.get_space_outpoint(&space_key)?
+        let outpoint = state
+            .get_space_outpoint(&space_key)?
             .ok_or_else(|| anyhow::anyhow!("Space not found: {}", space))?;
-        let mut spaceout = state.get_spaceout(&outpoint)?
+        let mut spaceout = state
+            .get_spaceout(&outpoint)?
             .ok_or_else(|| anyhow::anyhow!("Spaceout not found for outpoint"))?;
 
         // Update expire_height in the covenant
         if let Some(ref mut space_data) = spaceout.space {
             match &mut space_data.covenant {
-                Covenant::Transfer { expire_height: ref mut eh, .. } => {
+                Covenant::Transfer {
+                    expire_height: eh, ..
+                } => {
                     *eh = expire_height;
                 }
-                _ => return Err(anyhow::anyhow!("Space is not in Transfer covenant (not owned)")),
+                _ => {
+                    return Err(anyhow::anyhow!(
+                        "Space is not in Transfer covenant (not owned)"
+                    ));
+                }
             }
         } else {
             return Err(anyhow::anyhow!("SpaceOut has no space data"));
@@ -1761,9 +1812,9 @@ impl AsyncChainState {
         if let Some(anchors_path) = anchors_path {
             let anchors: Vec<RootAnchor> = serde_json::from_reader(
                 File::open(anchors_path)
-                    .or_else(|e| Err(anyhow!("Could not open anchors file: {}", e)))?,
+                    .map_err(|e| anyhow!("Could not open anchors file: {}", e))?,
             )
-                .or_else(|e| Err(anyhow!("Could not read anchors file: {}", e)))?;
+            .map_err(|e| anyhow!("Could not read anchors file: {}", e))?;
             return Ok(anchors);
         }
 
@@ -1773,7 +1824,10 @@ impl AsyncChainState {
 
         // Try to compute PTR root if we're past PTR genesis
         let ptrs_root = if state.can_scan_nums(meta.height) {
-            state.nums_mut().state.inner()
+            state
+                .nums_mut()
+                .state
+                .inner()
                 .ok()
                 .and_then(|s| s.compute_root().ok())
         } else {
@@ -1821,12 +1875,12 @@ impl AsyncChainState {
 
             let outpoint_key = OutpointKey::from_outpoint::<Sha256>(fso.outpoint());
             space_tree_keys.insert(outpoint_key.into());
-            if let Some(space) = &fso.spaceout.space {
-                if let Covenant::Transfer { expire_height, .. } = &space.covenant {
-                    let last_update = expire_height
-                        .saturating_sub(spaces_protocol::constants::RENEWAL_INTERVAL);
-                    most_recent_update = std::cmp::max(most_recent_update, last_update);
-                }
+            if let Some(space) = &fso.spaceout.space
+                && let Covenant::Transfer { expire_height, .. } = &space.covenant
+            {
+                let last_update =
+                    expire_height.saturating_sub(spaces_protocol::constants::RENEWAL_INTERVAL);
+                most_recent_update = std::cmp::max(most_recent_update, last_update);
             }
 
             let id = NumId::from_spk::<Sha256>(fso.spaceout.script_pubkey);
@@ -1838,44 +1892,45 @@ impl AsyncChainState {
                 NumKeyKind::Num(numeric) => {
                     let id = state.get_num_id(&numeric)?;
                     if let Some(id) = id {
-                        let fpt = state.get_num_info(&id)?
+                        let fpt = state
+                            .get_num_info(&id)?
                             .expect("num id must exist if numeric exists");
-                        num_tree_keys.insert(
-                            NumOutpointKey::from_outpoint::<Sha256>(fpt.outpoint()).into()
-                        );
-                        most_recent_update = std::cmp::max(most_recent_update, fpt.numout.num.last_update);
+                        num_tree_keys
+                            .insert(NumOutpointKey::from_outpoint::<Sha256>(fpt.outpoint()).into());
+                        most_recent_update =
+                            std::cmp::max(most_recent_update, fpt.numout.num.last_update);
 
                         // insert delegate information
                         let operator_id = NumId::from_spk::<Sha256>(fpt.numout.script_pubkey);
                         let operator = state.get_num_info(&operator_id)?;
                         if let Some(operator) = operator {
                             num_tree_keys.insert(
-                                NumOutpointKey::from_outpoint::<Sha256>(operator.outpoint()).into()
+                                NumOutpointKey::from_outpoint::<Sha256>(operator.outpoint()).into(),
                             );
 
-                            most_recent_update = std::cmp::max(most_recent_update, operator.numout.num.last_update);
-
+                            most_recent_update =
+                                std::cmp::max(most_recent_update, operator.numout.num.last_update);
                         } else {
                             num_tree_keys.insert(operator_id.into());
                         }
-
                     }
                 }
                 NumKeyKind::Id(id) => {
                     if let Some(fpt) = state.get_num_info(&id)? {
-                        num_tree_keys.insert(
-                            NumOutpointKey::from_outpoint::<Sha256>(fpt.outpoint()).into()
-                        );
-                        most_recent_update = std::cmp::max(most_recent_update, fpt.numout.num.last_update);
+                        num_tree_keys
+                            .insert(NumOutpointKey::from_outpoint::<Sha256>(fpt.outpoint()).into());
+                        most_recent_update =
+                            std::cmp::max(most_recent_update, fpt.numout.num.last_update);
 
                         // insert delegate information
                         let operator_id = NumId::from_spk::<Sha256>(fpt.numout.script_pubkey);
                         let operator = state.get_num_info(&operator_id)?;
                         if let Some(operator) = operator {
                             num_tree_keys.insert(
-                                NumOutpointKey::from_outpoint::<Sha256>(operator.outpoint()).into()
+                                NumOutpointKey::from_outpoint::<Sha256>(operator.outpoint()).into(),
                             );
-                            most_recent_update = std::cmp::max(most_recent_update, operator.numout.num.last_update);
+                            most_recent_update =
+                                std::cmp::max(most_recent_update, operator.numout.num.last_update);
                         } else {
                             num_tree_keys.insert(operator_id.into());
                         }
@@ -1886,10 +1941,10 @@ impl AsyncChainState {
                 }
                 NumKeyKind::Commitment(k) => {
                     num_tree_keys.insert(k.into());
-                },
+                }
                 NumKeyKind::CommitmentTip(k) => {
                     num_tree_keys.insert(k.into());
-                },
+                }
             }
         }
 
@@ -1900,23 +1955,25 @@ impl AsyncChainState {
             let blocks_remaining = next_commit - tip.height;
             return Err(anyhow!(
                 "Cannot prove: data updated at block {} is not yet committed. Try again in {} block(s)",
-                most_recent_update, blocks_remaining
+                most_recent_update,
+                blocks_remaining
             ));
         }
 
-        let num_tree_keys : Vec<_> = num_tree_keys.into_iter().collect();
-        let space_tree_keys : Vec<_> = space_tree_keys.into_iter().collect();
+        let num_tree_keys: Vec<_> = num_tree_keys.into_iter().collect();
+        let space_tree_keys: Vec<_> = space_tree_keys.into_iter().collect();
 
         let cached_height = Self::cached_snapshot_height(tip.height);
-        let use_cached = !prefer_recent
-            && cached_height.is_some_and(|h| most_recent_update <= h);
+        let use_cached = !prefer_recent && cached_height.is_some_and(|h| most_recent_update <= h);
 
         let (spaces_proof, spaces_root, block_anchor, ptrs_proof, ptrs_root) = if use_cached {
             let height = cached_height.unwrap();
             let snapshot = state.snapshot_at(height)?;
 
             let spaces_anchor: ChainAnchor = snapshot.spaces.metadata().try_into()?;
-            let spaces_proof = snapshot.spaces.prove(&space_tree_keys, ProofType::Standard)?;
+            let spaces_proof = snapshot
+                .spaces
+                .prove(&space_tree_keys, ProofType::Standard)?;
             let spaces_root = spaces_proof.compute_root()?;
 
             let ptrs_anchor: ChainAnchor = snapshot.nums.metadata().try_into()?;
@@ -1929,7 +1986,13 @@ impl AsyncChainState {
             let ptrs_proof = snapshot.nums.prove(&num_tree_keys, ProofType::Standard)?;
             let ptrs_root = ptrs_proof.compute_root()?;
 
-            (spaces_proof, spaces_root, spaces_anchor, ptrs_proof, ptrs_root)
+            (
+                spaces_proof,
+                spaces_root,
+                spaces_anchor,
+                ptrs_proof,
+                ptrs_root,
+            )
         } else {
             let spaces_snapshot = state.spaces_inner()?;
             let spaces_root = spaces_snapshot.compute_root()?;
@@ -1948,7 +2011,13 @@ impl AsyncChainState {
             let ptrs_proof = ptrs_snapshot.prove(&num_tree_keys, ProofType::Standard)?;
             let ptrs_root = ptrs_proof.compute_root()?;
 
-            (spaces_proof, spaces_root, spaces_anchor, ptrs_proof, ptrs_root)
+            (
+                spaces_proof,
+                spaces_root,
+                spaces_anchor,
+                ptrs_proof,
+                ptrs_root,
+            )
         };
 
         let spaces_buf = spaces_proof.to_vec()?;
@@ -2044,10 +2113,18 @@ impl AsyncChainState {
         resp_rx.await?
     }
 
-    pub async fn debug_set_expire_height(&self, space: SLabel, expire_height: u32) -> anyhow::Result<()> {
+    pub async fn debug_set_expire_height(
+        &self,
+        space: SLabel,
+        expire_height: u32,
+    ) -> anyhow::Result<()> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
-            .send(ChainStateCommand::DebugSetExpireHeight { space, expire_height, resp })
+            .send(ChainStateCommand::DebugSetExpireHeight {
+                space,
+                expire_height,
+                resp,
+            })
             .await?;
         resp_rx.await?
     }
@@ -2127,10 +2204,18 @@ impl AsyncChainState {
         resp_rx.await?
     }
 
-    pub async fn get_commitment(&self, subject: Subject, root: Option<Hash>) -> anyhow::Result<Option<Commitment>> {
+    pub async fn get_commitment(
+        &self,
+        subject: Subject,
+        root: Option<Hash>,
+    ) -> anyhow::Result<Option<Commitment>> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
-            .send(ChainStateCommand::GetCommitment { subject, root, resp })
+            .send(ChainStateCommand::GetCommitment {
+                subject,
+                root,
+                resp,
+            })
             .await?;
         resp_rx.await?
     }
@@ -2193,7 +2278,8 @@ fn resolve_num_id(state: &mut Chain, subject: &Subject) -> anyhow::Result<NumId>
         Subject::NumId(id) => Ok(*id),
         Subject::Label(label) if label.is_numeric() => {
             let numeric: SNumeric = label.clone().try_into().unwrap();
-            state.get_num_id(&numeric)?
+            state
+                .get_num_id(&numeric)?
                 .ok_or_else(|| anyhow!("numeric '{}' not found", numeric))
         }
         Subject::Label(_) => Err(anyhow!("expected a num id or numeric, not a space")),
@@ -2259,12 +2345,12 @@ async fn get_server_info(
     })
 }
 
-
 fn resolve_label(state: &mut Chain, subject: &Subject) -> anyhow::Result<SLabel> {
     match subject {
         Subject::Label(label) => Ok(label.clone()),
         Subject::NumId(id) => {
-            let info = state.get_num_info(id)?
+            let info = state
+                .get_num_info(id)?
                 .ok_or_else(|| anyhow!("num id '{}' not found", id))?;
             Ok(info.numout.num.name.to_slabel())
         }
@@ -2281,18 +2367,22 @@ fn get_delegation(state: &mut Chain, subject: &Subject) -> anyhow::Result<Option
             let Some(num_info) = state.get_num_info(&num_id)? else {
                 return Ok(None);
             };
-            (NumId::from_spk::<Sha256>(num_info.numout.script_pubkey), num.clone())
-        },
+            (
+                NumId::from_spk::<Sha256>(num_info.numout.script_pubkey),
+                num.clone(),
+            )
+        }
         Subject::Label(space) => {
-            let info = match state.get_space_info(
-                &SpaceKey::from(Sha256::hash(space.as_ref()))
-            )? {
+            let info = match state.get_space_info(&SpaceKey::from(Sha256::hash(space.as_ref())))? {
                 None => return Ok(None),
-                Some(info) => info
+                Some(info) => info,
             };
-            (NumId::from_spk::<Sha256>(info.spaceout.script_pubkey), space.clone())
+            (
+                NumId::from_spk::<Sha256>(info.spaceout.script_pubkey),
+                space.clone(),
+            )
         }
-        Subject::NumId(id) => return Ok(Some(id.clone()))
+        Subject::NumId(id) => return Ok(Some(*id)),
     };
 
     let delegate = state.get_delegator(&DelegatorKey::from_id::<Sha256>(id))?;
@@ -2304,13 +2394,18 @@ fn get_delegation(state: &mut Chain, subject: &Subject) -> anyhow::Result<Option
     }
 }
 
-fn get_commitment(state: &mut Chain, subject: &Subject, root: Option<Hash>) -> anyhow::Result<Option<Commitment>> {
+fn get_commitment(
+    state: &mut Chain,
+    subject: &Subject,
+    root: Option<Hash>,
+) -> anyhow::Result<Option<Commitment>> {
     let label = resolve_label(state, subject)?;
     let root = match root {
         None => {
             let rk = CommitmentTipKey::from_slabel::<Sha256>(&label);
-            let k = state.get_commitments_tip(&rk)
-                    .map_err(|e| anyhow!("could not fetch state root: {}", e))?;
+            let k = state
+                .get_commitments_tip(&rk)
+                .map_err(|e| anyhow!("could not fetch state root: {}", e))?;
             if let Some(k) = k {
                 k
             } else {
@@ -2321,8 +2416,11 @@ fn get_commitment(state: &mut Chain, subject: &Subject, root: Option<Hash>) -> a
     };
 
     let ck = CommitmentKey::new::<Sha256>(&label, root);
-    state.get_commitment(&ck)
-        .map_err(|e|
-            anyhow!("could not fetch commitment with root: {}: {}", hex::encode(root), e)
+    state.get_commitment(&ck).map_err(|e| {
+        anyhow!(
+            "could not fetch commitment with root: {}: {}",
+            hex::encode(root),
+            e
         )
-}
\ No newline at end of file
+    })
+}
diff --git a/client/src/rpc_schema.rs b/client/src/rpc_schema.rs
index 648f151..e9dd7a9 100644
--- a/client/src/rpc_schema.rs
+++ b/client/src/rpc_schema.rs
@@ -1,6 +1,6 @@
 use schemars::schema_for;
 use serde::Serialize;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 use crate::rpc::*;
 use crate::wallets::*;
@@ -26,12 +26,34 @@ pub struct MethodSchema {
     pub extra_examples: Vec<(&'static str, Value)>,
 }
 
-fn param(name: &'static str, r#type: &'static str, description: &'static str, example: Value) -> ParamInfo {
-    ParamInfo { name, description, r#type, required: true, example }
+fn param(
+    name: &'static str,
+    r#type: &'static str,
+    description: &'static str,
+    example: Value,
+) -> ParamInfo {
+    ParamInfo {
+        name,
+        description,
+        r#type,
+        required: true,
+        example,
+    }
 }
 
-fn opt_param(name: &'static str, r#type: &'static str, description: &'static str, example: Value) -> ParamInfo {
-    ParamInfo { name, description, r#type, required: false, example }
+fn opt_param(
+    name: &'static str,
+    r#type: &'static str,
+    description: &'static str,
+    example: Value,
+) -> ParamInfo {
+    ParamInfo {
+        name,
+        description,
+        r#type,
+        required: false,
+        example,
+    }
 }
 
 fn rpc_request(method: &str, params: &[&ParamInfo]) -> Value {
@@ -59,7 +81,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getspace",
             description: "Get full space output by space name or hash",
-            params: vec![param("space_or_hash", "string", "Space name (e.g. \"@example\") or hex hash", json!("@example"))],
+            params: vec![param(
+                "space_or_hash",
+                "string",
+                "Space name (e.g. \"@example\") or hex hash",
+                json!("@example"),
+            )],
             result_type: "Option<FullSpaceOut>",
             result_schema: None,
             extra_examples: vec![],
@@ -67,7 +94,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getspaceowner",
             description: "Get the outpoint that owns a space",
-            params: vec![param("space_or_hash", "string", "Space name (e.g. \"@example\") or hex hash", json!("@example"))],
+            params: vec![param(
+                "space_or_hash",
+                "string",
+                "Space name (e.g. \"@example\") or hex hash",
+                json!("@example"),
+            )],
             result_type: "Option<OutPoint>",
             result_schema: None,
             extra_examples: vec![],
@@ -75,7 +107,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getspaceout",
             description: "Get a space output by outpoint",
-            params: vec![param("outpoint", "OutPoint", "Transaction outpoint (txid:vout)", json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d:0"))],
+            params: vec![param(
+                "outpoint",
+                "OutPoint",
+                "Transaction outpoint (txid:vout)",
+                json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d:0"),
+            )],
             result_type: "Option<SpaceOut>",
             result_schema: None,
             extra_examples: vec![],
@@ -84,7 +121,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getnum",
             description: "Get full num output by numeric id or num id",
-            params: vec![param("subject", "Subject", "#numeric or num1... id", json!("#1-2-3"))],
+            params: vec![param(
+                "subject",
+                "Subject",
+                "#numeric or num1... id",
+                json!("#1-2-3"),
+            )],
             result_type: "Option<FullNumOut>",
             result_schema: None,
             extra_examples: vec![],
@@ -92,7 +134,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getnumowner",
             description: "Get the outpoint that owns a num",
-            params: vec![param("subject", "Subject", "#numeric or num1... id", json!("#1-2-3"))],
+            params: vec![param(
+                "subject",
+                "Subject",
+                "#numeric or num1... id",
+                json!("#1-2-3"),
+            )],
             result_type: "Option<OutPoint>",
             result_schema: None,
             extra_examples: vec![],
@@ -100,7 +147,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getnumout",
             description: "Get a num output by outpoint",
-            params: vec![param("outpoint", "OutPoint", "Transaction outpoint (txid:vout)", json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d:0"))],
+            params: vec![param(
+                "outpoint",
+                "OutPoint",
+                "Transaction outpoint (txid:vout)",
+                json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d:0"),
+            )],
             result_type: "Option<NumOut>",
             result_schema: None,
             extra_examples: vec![],
@@ -110,8 +162,18 @@ pub fn build_schema() -> Vec<MethodSchema> {
             name: "getcommitment",
             description: "Get commitment for a subject, optionally at a specific root",
             params: vec![
-                param("subject", "Subject", "@space, #numeric, or num1... id", json!("@example")),
-                opt_param("root", "string", "Specific commitment root hash", json!(null)),
+                param(
+                    "subject",
+                    "Subject",
+                    "@space, #numeric, or num1... id",
+                    json!("@example"),
+                ),
+                opt_param(
+                    "root",
+                    "string",
+                    "Specific commitment root hash",
+                    json!(null),
+                ),
             ],
             result_type: "Option<Commitment>",
             result_schema: None,
@@ -120,7 +182,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getdelegation",
             description: "Get the operator num id delegated for a subject",
-            params: vec![param("subject", "Subject", "@space, #numeric, or num1... id", json!("@example"))],
+            params: vec![param(
+                "subject",
+                "Subject",
+                "@space, #numeric, or num1... id",
+                json!("@example"),
+            )],
             result_type: "Option<NumId>",
             result_schema: None,
             extra_examples: vec![],
@@ -128,7 +195,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getdelegator",
             description: "Get the subject that a num is operating for",
-            params: vec![param("subject", "Subject", "#numeric or num1... id of the operator", json!("num1qp..."))],
+            params: vec![param(
+                "subject",
+                "Subject",
+                "#numeric or num1... id of the operator",
+                json!("num1qp..."),
+            )],
             result_type: "Option<SLabel>",
             result_schema: None,
             extra_examples: vec![],
@@ -137,7 +209,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "checkpackage",
             description: "Simulate a package of transactions and return their changesets",
-            params: vec![param("txs", "string[]", "Array of raw transaction hex strings", json!(["0200000001..."]))],
+            params: vec![param(
+                "txs",
+                "string[]",
+                "Array of raw transaction hex strings",
+                json!(["0200000001..."]),
+            )],
             result_type: "Vec<Option<TxChangeSet>>",
             result_schema: None,
             extra_examples: vec![],
@@ -145,7 +222,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "estimatebid",
             description: "Estimate the minimum bid amount to enter a rollout at the given target",
-            params: vec![param("target", "integer", "Target number of blocks ahead", json!(10))],
+            params: vec![param(
+                "target",
+                "integer",
+                "Target number of blocks ahead",
+                json!(10),
+            )],
             result_type: "u64",
             result_schema: None,
             extra_examples: vec![],
@@ -153,7 +235,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getrollout",
             description: "Get the rollout entries for a given target",
-            params: vec![param("target", "integer", "Target number of blocks ahead", json!(10))],
+            params: vec![param(
+                "target",
+                "integer",
+                "Target number of blocks ahead",
+                json!(10),
+            )],
             result_type: "Vec<RolloutEntry>",
             result_schema: None,
             extra_examples: vec![],
@@ -161,7 +248,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getblockmeta",
             description: "Get spaces block metadata by height or hash",
-            params: vec![param("height_or_hash", "integer|string", "Block height or block hash", json!(100))],
+            params: vec![param(
+                "height_or_hash",
+                "integer|string",
+                "Block height or block hash",
+                json!(100),
+            )],
             result_type: "BlockMetaWithHash",
             result_schema: Some(serde_json::to_value(schema_for!(BlockMetaWithHash)).unwrap()),
             extra_examples: vec![],
@@ -169,7 +261,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getnumblockmeta",
             description: "Get nums block metadata by height or hash",
-            params: vec![param("height_or_hash", "integer|string", "Block height or block hash", json!(100))],
+            params: vec![param(
+                "height_or_hash",
+                "integer|string",
+                "Block height or block hash",
+                json!(100),
+            )],
             result_type: "NumBlockMetaWithHash",
             result_schema: Some(serde_json::to_value(schema_for!(NumBlockMetaWithHash)).unwrap()),
             extra_examples: vec![],
@@ -177,7 +274,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "gettxmeta",
             description: "Get transaction metadata by txid",
-            params: vec![param("txid", "string", "Transaction id", json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"))],
+            params: vec![param(
+                "txid",
+                "string",
+                "Transaction id",
+                json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"),
+            )],
             result_type: "Option<TxEntry>",
             result_schema: None,
             extra_examples: vec![],
@@ -202,7 +304,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "walletimport",
             description: "Import a wallet from an export object",
-            params: vec![param("wallet", "WalletExport", "Wallet export data", json!({"descriptor": "...", "blockheight": 0, "label": "default"}))],
+            params: vec![param(
+                "wallet",
+                "WalletExport",
+                "Wallet export data",
+                json!({"descriptor": "...", "blockheight": 0, "label": "default"}),
+            )],
             result_type: "()",
             result_schema: None,
             extra_examples: vec![],
@@ -212,7 +319,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Check if a wallet controls the operator num for a subject",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("subject", "Subject", "@space, #numeric, or num1... id", json!("@example")),
+                param(
+                    "subject",
+                    "Subject",
+                    "@space, #numeric, or num1... id",
+                    json!("@example"),
+                ),
             ],
             result_type: "bool",
             result_schema: None,
@@ -223,8 +335,18 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Sign a message with a subject's schnorr key",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("subject", "Subject", "@space, #numeric, or num1... id", json!("@example")),
-                param("message", "string", "Message bytes (hex)", json!("48656c6c6f")),
+                param(
+                    "subject",
+                    "Subject",
+                    "@space, #numeric, or num1... id",
+                    json!("@example"),
+                ),
+                param(
+                    "message",
+                    "string",
+                    "Message bytes (hex)",
+                    json!("48656c6c6f"),
+                ),
             ],
             result_type: "string",
             result_schema: None,
@@ -234,9 +356,24 @@ pub fn build_schema() -> Vec<MethodSchema> {
             name: "verifyschnorr",
             description: "Verify a schnorr signature for a subject",
             params: vec![
-                param("subject", "Subject", "@space, #numeric, or num1... id", json!("@example")),
-                param("message", "string", "Message bytes (hex)", json!("48656c6c6f")),
-                param("signature", "string", "Signature bytes (hex)", json!("aabbccdd...")),
+                param(
+                    "subject",
+                    "Subject",
+                    "@space, #numeric, or num1... id",
+                    json!("@example"),
+                ),
+                param(
+                    "message",
+                    "string",
+                    "Message bytes (hex)",
+                    json!("48656c6c6f"),
+                ),
+                param(
+                    "signature",
+                    "string",
+                    "Signature bytes (hex)",
+                    json!("aabbccdd..."),
+                ),
             ],
             result_type: "bool",
             result_schema: None,
@@ -271,7 +408,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Recover a wallet from a mnemonic phrase",
             params: vec![
                 param("name", "string", "Wallet name", json!("default")),
-                param("mnemonic", "string", "BIP-39 mnemonic phrase", json!("abandon abandon abandon ... about")),
+                param(
+                    "mnemonic",
+                    "string",
+                    "BIP-39 mnemonic phrase",
+                    json!("abandon abandon abandon ... about"),
+                ),
             ],
             result_type: "()",
             result_schema: None,
@@ -282,116 +424,148 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Send a batch of wallet requests (open, bid, register, transfer, etc.)",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("request", "RpcWalletTxBuilder", "Transaction builder with requests", json!({
-                    "requests": [{"request": "open", "name": "@example", "amount": 1000}],
-                    "fee_rate": 1.0,
-                    "force": false,
-                    "confirmed_only": false,
-                    "skip_tx_check": false,
-                })),
-            ],
-            result_type: "WalletResponse",
-            result_schema: Some(serde_json::to_value(schema_for!(RpcWalletTxBuilder)).unwrap()),
-            extra_examples: vec![
-                ("Bid on a space", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "bid", "name": "@example", "amount": 2000}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Register a space", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "register", "name": "@example"}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Transfer spaces", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "transfer", "spaces": ["@example"], "to": "bc1q..."}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Create a num", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "createnum"}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Set up an operator for a space", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "operate", "subject": "@example"}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Commit a root hash", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "commit", "subject": "@example", "root": "a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"}],
+                param(
+                    "request",
+                    "RpcWalletTxBuilder",
+                    "Transaction builder with requests",
+                    json!({
+                        "requests": [{"request": "open", "name": "@example", "amount": 1000}],
                         "fee_rate": 1.0,
                         "force": false,
                         "confirmed_only": false,
                         "skip_tx_check": false,
-                    }]
-                })),
-                ("Delegate operator to another wallet", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "delegate", "subject": "@example", "to": "bc1q..."}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Set fallback data", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "setfallback", "subject": "@example", "data": [0, 1, 2]}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
-                ("Send coins", json!({
-                    "jsonrpc": "2.0", "id": 1,
-                    "method": "walletsendrequest",
-                    "params": ["default", {
-                        "requests": [{"request": "send", "amount": 50000, "to": "bc1q..."}],
-                        "fee_rate": 1.0,
-                        "force": false,
-                        "confirmed_only": false,
-                        "skip_tx_check": false,
-                    }]
-                })),
+                    }),
+                ),
+            ],
+            result_type: "WalletResponse",
+            result_schema: Some(serde_json::to_value(schema_for!(RpcWalletTxBuilder)).unwrap()),
+            extra_examples: vec![
+                (
+                    "Bid on a space",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "bid", "name": "@example", "amount": 2000}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Register a space",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "register", "name": "@example"}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Transfer spaces",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "transfer", "spaces": ["@example"], "to": "bc1q..."}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Create a num",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "createnum"}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Set up an operator for a space",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "operate", "subject": "@example"}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Commit a root hash",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "commit", "subject": "@example", "root": "a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Delegate operator to another wallet",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "delegate", "subject": "@example", "to": "bc1q..."}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Set fallback data",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "setfallback", "subject": "@example", "data": [0, 1, 2]}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
+                (
+                    "Send coins",
+                    json!({
+                        "jsonrpc": "2.0", "id": 1,
+                        "method": "walletsendrequest",
+                        "params": ["default", {
+                            "requests": [{"request": "send", "amount": 50000, "to": "bc1q..."}],
+                            "fee_rate": 1.0,
+                            "force": false,
+                            "confirmed_only": false,
+                            "skip_tx_check": false,
+                        }]
+                    }),
+                ),
             ],
         },
         MethodSchema {
@@ -399,7 +573,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Get a new address from the wallet",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("kind", "AddressKind", "\"Coin\" or \"Space\"", json!("Coin")),
+                param(
+                    "kind",
+                    "AddressKind",
+                    "\"Coin\" or \"Space\"",
+                    json!("Coin"),
+                ),
             ],
             result_type: "string",
             result_schema: None,
@@ -410,7 +589,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Increment and return the next address from the wallet",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("kind", "AddressKind", "\"Coin\" or \"Space\"", json!("Coin")),
+                param(
+                    "kind",
+                    "AddressKind",
+                    "\"Coin\" or \"Space\"",
+                    json!("Coin"),
+                ),
             ],
             result_type: "string",
             result_schema: None,
@@ -421,9 +605,19 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Bump the fee of an existing transaction",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("txid", "string", "Transaction id to bump", json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d")),
+                param(
+                    "txid",
+                    "string",
+                    "Transaction id to bump",
+                    json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"),
+                ),
                 param("fee_rate", "number", "New fee rate in sat/vB", json!(2.0)),
-                param("skip_tx_check", "bool", "Skip transaction validation", json!(false)),
+                param(
+                    "skip_tx_check",
+                    "bool",
+                    "Skip transaction validation",
+                    json!(false),
+                ),
             ],
             result_type: "Vec<TxResponse>",
             result_schema: Some(serde_json::to_value(schema_for!(TxResponse)).unwrap()),
@@ -434,9 +628,19 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Buy a space from a listing",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("listing", "Listing", "The listing to buy", json!({"space": "@example", "price": 100000, "seller_psbt": "..."})),
+                param(
+                    "listing",
+                    "Listing",
+                    "The listing to buy",
+                    json!({"space": "@example", "price": 100000, "seller_psbt": "..."}),
+                ),
                 opt_param("fee_rate", "number", "Fee rate in sat/vB", json!(1.0)),
-                param("skip_tx_check", "bool", "Skip transaction validation", json!(false)),
+                param(
+                    "skip_tx_check",
+                    "bool",
+                    "Skip transaction validation",
+                    json!(false),
+                ),
             ],
             result_type: "TxResponse",
             result_schema: Some(serde_json::to_value(schema_for!(TxResponse)).unwrap()),
@@ -448,7 +652,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
                 param("space", "string", "Space name", json!("@example")),
-                param("amount", "integer", "Asking price in satoshis", json!(100000)),
+                param(
+                    "amount",
+                    "integer",
+                    "Asking price in satoshis",
+                    json!(100000),
+                ),
             ],
             result_type: "Listing",
             result_schema: None,
@@ -457,7 +666,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "verifylisting",
             description: "Verify that a listing is valid",
-            params: vec![param("listing", "Listing", "The listing to verify", json!({"space": "@example", "price": 100000, "seller_psbt": "..."}))],
+            params: vec![param(
+                "listing",
+                "Listing",
+                "The listing to verify",
+                json!({"space": "@example", "price": 100000, "seller_psbt": "..."}),
+            )],
             result_type: "()",
             result_schema: None,
             extra_examples: vec![],
@@ -466,8 +680,18 @@ pub fn build_schema() -> Vec<MethodSchema> {
             name: "buildchainproof",
             description: "Build a chain proof for verifying spaces/nums state",
             params: vec![
-                param("request", "ChainProofRequest", "The proof request specifying keys to prove", json!({"keys": [{"space": "@example"}]})),
-                opt_param("prefer_recent", "bool", "Prefer the most recent snapshot", json!(true)),
+                param(
+                    "request",
+                    "ChainProofRequest",
+                    "The proof request specifying keys to prove",
+                    json!({"keys": [{"space": "@example"}]}),
+                ),
+                opt_param(
+                    "prefer_recent",
+                    "bool",
+                    "Prefer the most recent snapshot",
+                    json!(true),
+                ),
             ],
             result_type: "ChainProofResult",
             result_schema: Some(serde_json::to_value(schema_for!(ChainProofResult)).unwrap()),
@@ -486,8 +710,18 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "List wallet transactions with pagination",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("count", "integer", "Number of transactions to return", json!(10)),
-                param("skip", "integer", "Number of transactions to skip", json!(0)),
+                param(
+                    "count",
+                    "integer",
+                    "Number of transactions to return",
+                    json!(10),
+                ),
+                param(
+                    "skip",
+                    "integer",
+                    "Number of transactions to skip",
+                    json!(0),
+                ),
             ],
             result_type: "Vec<TxInfo>",
             result_schema: Some(serde_json::to_value(schema_for!(TxInfo)).unwrap()),
@@ -498,7 +732,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Force spend a specific outpoint",
             params: vec![
                 param("wallet", "string", "Wallet name", json!("default")),
-                param("outpoint", "OutPoint", "Transaction outpoint (txid:vout)", json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d:0")),
+                param(
+                    "outpoint",
+                    "OutPoint",
+                    "Transaction outpoint (txid:vout)",
+                    json!("a]1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d:0"),
+                ),
                 param("fee_rate", "number", "Fee rate in sat/vB", json!(1.0)),
             ],
             result_type: "TxResponse",
@@ -548,7 +787,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
         MethodSchema {
             name: "getfallback",
             description: "Get fallback data and parsed SIP-7 records for a subject",
-            params: vec![param("subject", "Subject", "@space, #numeric, or num1... id", json!("@example"))],
+            params: vec![param(
+                "subject",
+                "Subject",
+                "@space, #numeric, or num1... id",
+                json!("@example"),
+            )],
             result_type: "Option<FallbackResponse>",
             result_schema: Some(serde_json::to_value(schema_for!(FallbackResponse)).unwrap()),
             extra_examples: vec![],
@@ -558,7 +802,12 @@ pub fn build_schema() -> Vec<MethodSchema> {
             description: "Debug method to set a space's expire height (regtest only)",
             params: vec![
                 param("space", "string", "Space name", json!("@example")),
-                param("expire_height", "integer", "New expiration height", json!(1000)),
+                param(
+                    "expire_height",
+                    "integer",
+                    "New expiration height",
+                    json!(1000),
+                ),
             ],
             result_type: "()",
             result_schema: None,
@@ -594,7 +843,7 @@ pub fn to_markdown() -> String {
                     p.description
                 ));
             }
-            md.push_str("\n");
+            md.push('\n');
         }
 
         md.push_str(&format!("**Returns:** `{}`\n\n", method.result_type));
diff --git a/client/src/source.rs b/client/src/source.rs
index 2293591..5d3ad68 100644
--- a/client/src/source.rs
+++ b/client/src/source.rs
@@ -1,28 +1,28 @@
+use crate::client::BlockFilterRpc;
+use crate::{client::BlockSource, std_wait};
+use base64::Engine;
+use bitcoin::{Block, BlockHash, Txid};
+use hex::FromHexError;
+use log::{error, warn};
+use reqwest::StatusCode;
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use serde_json::Value;
+use spaces_protocol::bitcoin::Network;
+use spaces_protocol::constants::ChainAnchor;
+use spaces_wallet::{bitcoin, bitcoin::Transaction};
+use std::error::Error;
 use std::{
     collections::BTreeMap,
     fmt,
     sync::{
+        Arc,
         atomic::{AtomicU64, AtomicUsize, Ordering},
         mpsc::Receiver,
-        Arc,
     },
     time::Duration,
 };
-use std::error::Error;
-use base64::Engine;
-use bitcoin::{Block, BlockHash, Txid};
-use hex::FromHexError;
-use log::{error, warn};
-use reqwest::StatusCode;
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use serde_json::Value;
-use spaces_protocol::constants::ChainAnchor;
-use spaces_wallet::{bitcoin, bitcoin::Transaction};
 use threadpool::ThreadPool;
 use tokio::time::Instant;
-use spaces_protocol::bitcoin::Network;
-use crate::{client::BlockSource, std_wait};
-use crate::client::BlockFilterRpc;
 
 const BITCOIN_RPC_IN_WARMUP: i32 = -28; // Client still warming up
 const BITCOIN_RPC_CLIENT_NOT_CONNECTED: i32 = -9; // Bitcoin is not connected
@@ -35,7 +35,7 @@ pub struct BitcoinRpc {
     id: Arc<AtomicU64>,
     auth_token: Option<String>,
     url: String,
-    legacy: bool
+    legacy: bool,
 }
 
 pub struct BlockFetcher {
@@ -161,7 +161,7 @@ impl BitcoinRpc {
             "method": method,
             "params": params,
         });
-        return BitcoinRpcRequest { id, body };
+        BitcoinRpcRequest { id, body }
     }
 
     pub fn get_block_count(&self) -> BitcoinRpcRequest {
@@ -224,8 +224,9 @@ impl BitcoinRpc {
 
     pub fn send_raw_transaction(&self, tx: &Transaction) -> BitcoinRpcRequest {
         let raw_hex = bitcoin::consensus::encode::serialize_hex(&tx);
-        let params =
-            serde_json::json!([raw_hex, /* max fee rate */ 0, /* max burn amount */ 21_000_000]);
+        let params = serde_json::json!([
+            raw_hex, /* max fee rate */ 0, /* max burn amount */ 21_000_000
+        ]);
 
         self.make_request("sendrawtransaction", params)
     }
@@ -306,7 +307,7 @@ impl BitcoinRpc {
                 Ok(res) => return Self::clean_rpc_response(res).await,
                 Err(e) if e.is_temporary() && attempt < max_retries - 1 => {
                     log_rpc_error(&request.body, &e, delay);
-                    last_error = Some(e.into());
+                    last_error = Some(e);
                     tokio::time::sleep(delay).await;
                     delay *= 2;
                 }
@@ -339,7 +340,7 @@ impl BitcoinRpc {
                 Ok(res) => return Self::clean_rpc_response_blocking(res),
                 Err(e) if e.is_temporary() && attempt < max_retries - 1 => {
                     log_rpc_error(&request.body, &e, delay);
-                    last_error = Some(e.into());
+                    last_error = Some(e);
                     std::thread::sleep(delay);
                     delay *= 2;
                 }
@@ -385,7 +386,7 @@ impl BitcoinRpc {
 
     fn parse_error_bytes(status: StatusCode, res_bytes: &[u8]) -> BitcoinRpcError {
         let parsed_response: Result<JsonRpcResponse<Option<String>>, serde_json::Error> =
-            serde_json::from_slice(&res_bytes);
+            serde_json::from_slice(res_bytes);
 
         match parsed_response {
             Ok(json) => {
@@ -589,7 +590,7 @@ impl BlockFetcher {
         source: &BitcoinBlockSource,
         hash: &BlockHash,
     ) -> Result<Block, BitcoinRpcError> {
-        let block_req = source.rpc.get_block(&hash);
+        let block_req = source.rpc.get_block(hash);
         let id = block_req.id;
         let response = source
             .rpc
@@ -598,25 +599,28 @@ impl BlockFetcher {
         let mut raw = response.bytes()?.to_vec();
 
         let start_needle = "{\"result\":\"";
-        let end_needle = format!("\",\"error\":null,\"id\":\"{}\"}}\n", id.to_string());
+        let end_needle = format!("\",\"error\":null,\"id\":\"{}\"}}\n", id);
 
         // Check if we can quickly extract block
-        let hex_block =
-            if raw.starts_with(start_needle.as_bytes()) && raw.ends_with(end_needle.as_bytes()) {
-                raw.drain(0..start_needle.len());
-                raw.truncate(raw.len() - end_needle.len());
-                raw
-            } else {
-                // fallback to decoding json
-                let hex_block: JsonRpcResponse<Option<String>> = serde_json::from_slice(raw.as_slice())
-                    .map_err(|e| BitcoinRpcError::Other(format!("fetch block {}: {}",hash, e.to_string())))?;
-                if let Some(e) = hex_block.error {
-                    return Err(BitcoinRpcError::Rpc(e));
-                }
-                let block = hex_block.result
-                    .ok_or(BitcoinRpcError::Other(format!("could not find block with hash {}", hash)))?;
-                block.into_bytes()
-            };
+        let hex_block = if raw.starts_with(start_needle.as_bytes())
+            && raw.ends_with(end_needle.as_bytes())
+        {
+            raw.drain(0..start_needle.len());
+            raw.truncate(raw.len() - end_needle.len());
+            raw
+        } else {
+            // fallback to decoding json
+            let hex_block: JsonRpcResponse<Option<String>> = serde_json::from_slice(raw.as_slice())
+                .map_err(|e| BitcoinRpcError::Other(format!("fetch block {}: {}", hash, e)))?;
+            if let Some(e) = hex_block.error {
+                return Err(BitcoinRpcError::Rpc(e));
+            }
+            let block = hex_block.result.ok_or(BitcoinRpcError::Other(format!(
+                "could not find block with hash {}",
+                hash
+            )))?;
+            block.into_bytes()
+        };
 
         if hex_block.len() % 2 != 0 {
             return Err(BitcoinRpcError::Other(
@@ -624,14 +628,11 @@ impl BlockFetcher {
             ));
         }
 
-        let raw_block = hex_to_bytes(hex_block).map_err(|e| {
-            BitcoinRpcError::Other(format!("Hex deserialize error: {}", e.to_string()))
-        })?;
+        let raw_block = hex_to_bytes(hex_block)
+            .map_err(|e| BitcoinRpcError::Other(format!("Hex deserialize error: {}", e)))?;
 
-        let block: Block =
-            bitcoin::consensus::encode::deserialize(raw_block.as_slice()).map_err(|e| {
-                BitcoinRpcError::Other(format!("Block Deserialize error: {}", e.to_string()))
-            })?;
+        let block: Block = bitcoin::consensus::encode::deserialize(raw_block.as_slice())
+            .map_err(|e| BitcoinRpcError::Other(format!("Block Deserialize error: {}", e)))?;
         Ok(block)
     }
 }
@@ -680,7 +681,7 @@ impl Workers {
 
             self.last_emitted = id;
             self.ordered_sender
-                .send(BlockEvent::Block(id.clone(), block))
+                .send(BlockEvent::Block(id, block))
                 .map_err(|_| BlockFetchError::ChannelClosed)?;
             return Ok(true);
         }
@@ -789,16 +790,16 @@ impl BitcoinRpcError {
                 if e.is_timeout() || e.is_connect() {
                     return true;
                 }
-                if let Some(status) = e.status() {
-                    match status {
-                        StatusCode::REQUEST_TIMEOUT
-                        | StatusCode::TOO_MANY_REQUESTS
-                        | StatusCode::INTERNAL_SERVER_ERROR
-                        | StatusCode::BAD_GATEWAY
-                        | StatusCode::SERVICE_UNAVAILABLE
-                        | StatusCode::GATEWAY_TIMEOUT => return true,
-                        _ => {}
-                    }
+                if let Some(
+                    StatusCode::REQUEST_TIMEOUT
+                    | StatusCode::TOO_MANY_REQUESTS
+                    | StatusCode::INTERNAL_SERVER_ERROR
+                    | StatusCode::BAD_GATEWAY
+                    | StatusCode::SERVICE_UNAVAILABLE
+                    | StatusCode::GATEWAY_TIMEOUT,
+                ) = e.status()
+                {
+                    return true;
                 }
                 false
             }
@@ -856,15 +857,17 @@ impl ErrorForRpc for reqwest::Response {
             Ok(rpc_res) => rpc_res,
             Err(e) => {
                 // Try to decode without result
-                let error_res: Option<JsonRpcResponse<Option<String>>> = serde_json::from_str(&text).ok();
-                if let Some(error_res) = error_res {
-                    if let Some(error) = error_res.error {
-                        return Err(BitcoinRpcError::Rpc(error));
-                    }
+                let error_res: Option<JsonRpcResponse<Option<String>>> =
+                    serde_json::from_str(&text).ok();
+                if let Some(error_res) = error_res
+                    && let Some(error) = error_res.error
+                {
+                    return Err(BitcoinRpcError::Rpc(error));
                 }
-                return Err(BitcoinRpcError::Other(
-                    format!("Expected a JSON response, got '{}': {}", text, e),
-                ));
+                return Err(BitcoinRpcError::Other(format!(
+                    "Expected a JSON response, got '{}': {}",
+                    text, e
+                )));
             }
         };
 
@@ -878,25 +881,26 @@ impl ErrorForRpc for reqwest::Response {
 
 impl ErrorForRpcBlocking for reqwest::blocking::Response {
     fn error_for_rpc<T: DeserializeOwned>(self) -> Result<T, BitcoinRpcError> {
-        let text = self.text().map_err(|e| BitcoinRpcError::Other(
-            format!("Could not read response body: {}", e),
-        ))?;
+        let text = self
+            .text()
+            .map_err(|e| BitcoinRpcError::Other(format!("Could not read response body: {}", e)))?;
 
         // Attempt to deserialize the text as JSON
-        let rpc_res: JsonRpcResponse<T> = match serde_json::from_str(&text)
-             {
+        let rpc_res: JsonRpcResponse<T> = match serde_json::from_str(&text) {
             Ok(rpc_res) => rpc_res,
             Err(e) => {
                 // try to decode without result
-                let error_res : Option<JsonRpcResponse<Option<String>>> = serde_json::from_str(&text).ok();
-                if let Some(error_res) = error_res {
-                    if let Some(error) = error_res.error {
-                        return Err(BitcoinRpcError::Rpc(error));
-                    }
+                let error_res: Option<JsonRpcResponse<Option<String>>> =
+                    serde_json::from_str(&text).ok();
+                if let Some(error_res) = error_res
+                    && let Some(error) = error_res.error
+                {
+                    return Err(BitcoinRpcError::Rpc(error));
                 }
-                return Err(BitcoinRpcError::Other(
-                    format!("Expected a JSON response, got '{}': {}", text, e),
-                ))
+                return Err(BitcoinRpcError::Other(format!(
+                    "Expected a JSON response, got '{}': {}",
+                    text, e
+                )));
             }
         };
 
@@ -914,7 +918,6 @@ pub struct BlockQueueResult {
     pub completed: u32,
 }
 
-
 #[derive(Clone)]
 pub struct BitcoinBlockSource {
     pub client: reqwest::blocking::Client,
@@ -935,13 +938,12 @@ impl BitcoinBlockSource {
 
 impl BlockSource for BitcoinBlockSource {
     fn get_block_hash(&self, height: u32) -> Result<BlockHash, BitcoinRpcError> {
-        Ok(self
-            .rpc
-            .send_json_blocking(&self.client, &self.rpc.get_block_hash(height))?)
+        self.rpc
+            .send_json_blocking(&self.client, &self.rpc.get_block_hash(height))
     }
 
     fn get_block(&self, hash: &BlockHash) -> Result<Option<Block>, BitcoinRpcError> {
-        BlockFetcher::fetch_block(self, hash).map(|b| Some(b))
+        BlockFetcher::fetch_block(self, hash).map(Some)
     }
 
     fn get_median_time(&self) -> Result<u64, BitcoinRpcError> {
@@ -982,12 +984,15 @@ impl BlockSource for BitcoinBlockSource {
     }
 
     fn get_block_count(&self) -> Result<u64, BitcoinRpcError> {
-        Ok(self
-            .rpc
-            .send_json_blocking(&self.client, &self.rpc.get_block_count())?)
+        self.rpc
+            .send_json_blocking(&self.client, &self.rpc.get_block_count())
     }
 
-    fn get_best_chain(&self, tip: Option<u32>, expected_chain: Network) -> Result<BestChain, BitcoinRpcError> {
+    fn get_best_chain(
+        &self,
+        tip: Option<u32>,
+        expected_chain: Network,
+    ) -> Result<BestChain, BitcoinRpcError> {
         #[derive(Deserialize)]
         struct Info {
             pub chain: String,
@@ -1007,18 +1012,21 @@ impl BlockSource for BitcoinBlockSource {
             Network::Bitcoin => "main",
             Network::Regtest => "regtest",
             Network::Signet => "signet",
-            _ => "test"
+            _ => "test",
         };
         if info.chain.starts_with("test") {
             info.chain = "test".to_string()
         }
         if info.chain != expected_chain {
-            warn!("Invalid chain from connected rpc node - expected {}, got {}", expected_chain, info.chain);
+            warn!(
+                "Invalid chain from connected rpc node - expected {}, got {}",
+                expected_chain, info.chain
+            );
             return Ok(BestChain::None);
         }
 
         let synced = info.headers == info.blocks;
-        let best_chain =  if !synced {
+        let best_chain = if !synced {
             let block_hash = self.get_block_hash(info.blocks)?;
             ChainAnchor {
                 hash: block_hash,
@@ -1039,7 +1047,9 @@ impl BlockSource for BitcoinBlockSource {
         Ok(BestChain::Tip(best_chain))
     }
 
-    fn get_blockchain_info(&self) -> anyhow::Result<crate::client::BlockchainInfo, BitcoinRpcError> {
+    fn get_blockchain_info(
+        &self,
+    ) -> anyhow::Result<crate::client::BlockchainInfo, BitcoinRpcError> {
         let mut info: crate::client::BlockchainInfo = self
             .rpc
             .send_json_blocking(&self.client, &self.rpc.get_blockchain_info())?;
@@ -1049,7 +1059,10 @@ impl BlockSource for BitcoinBlockSource {
         Ok(info)
     }
 
-    fn get_block_filter_by_height(&self, height: u32) -> anyhow::Result<Option<BlockFilterRpc>, BitcoinRpcError> {
+    fn get_block_filter_by_height(
+        &self,
+        height: u32,
+    ) -> anyhow::Result<Option<BlockFilterRpc>, BitcoinRpcError> {
         let filter: Option<BlockFilterRpc> = self
             .rpc
             .send_json_blocking(&self.client, &self.rpc.get_block_filter_by_height(height))?;
@@ -1057,30 +1070,29 @@ impl BlockSource for BitcoinBlockSource {
     }
 
     fn queue_blocks(&self, heights: Vec<u32>) -> anyhow::Result<(), BitcoinRpcError> {
-         self
-            .rpc
+        self.rpc
             .send_json_blocking::<()>(&self.client, &self.rpc.queue_blocks(heights))?;
         Ok(())
     }
 
     fn queue_filters(&self) -> anyhow::Result<(), BitcoinRpcError> {
-        self
-            .rpc
+        self.rpc
             .send_json_blocking::<()>(&self.client, &self.rpc.queue_filters())?;
         Ok(())
     }
 }
 
 fn log_rpc_error(request: &Value, e: &BitcoinRpcError, delay: Duration) {
-    let rpc_method = serde_json::to_string(&request.get("method"))
-        .unwrap_or("".to_string());
-    let rpc_params = serde_json::to_string(&request.get("params"))
-        .unwrap_or("".to_string());
+    let rpc_method = serde_json::to_string(&request.get("method")).unwrap_or("".to_string());
+    let rpc_params = serde_json::to_string(&request.get("params")).unwrap_or("".to_string());
     let src = match e {
-        BitcoinRpcError::Transport(e) =>
-            e.source().map(|s| format!("({:?})", s)),
-        _ => None
-    }.unwrap_or("".to_string());
+        BitcoinRpcError::Transport(e) => e.source().map(|s| format!("({:?})", s)),
+        _ => None,
+    }
+    .unwrap_or("".to_string());
 
-    error!("Rpc {}{}: {}{} - retrying in {:?}...", rpc_method, rpc_params, e, src, delay);
+    error!(
+        "Rpc {}{}: {}{} - retrying in {:?}...",
+        rpc_method, rpc_params, e, src, delay
+    );
 }
diff --git a/client/src/spaces.rs b/client/src/spaces.rs
index 432776d..90cf127 100644
--- a/client/src/spaces.rs
+++ b/client/src/spaces.rs
@@ -1,12 +1,10 @@
 use std::{net::SocketAddr, path::PathBuf, time::Duration};
 
 use log::{info, warn};
-use spaces_protocol::{
-    bitcoin::{Block},
-    constants::ChainAnchor,
-};
+use spaces_protocol::{bitcoin::Block, constants::ChainAnchor};
 use tokio::sync::broadcast;
 
+use crate::store::chain::Chain;
 use crate::{
     client::{BlockSource, Client},
     config::ExtendedNetwork,
@@ -15,7 +13,6 @@ use crate::{
     },
     std_wait,
 };
-use crate::store::chain::{Chain};
 
 /// Number of blocks to keep from tip when pruning
 const PRUNING_BUFFER: u32 = 120;
@@ -39,7 +36,7 @@ pub struct Spaced {
 impl Spaced {
     pub fn restore(&self, source: &BitcoinBlockSource) -> anyhow::Result<()> {
         self.chain.restore(|h| {
-           let h = source.get_block_hash(h)?;
+            let h = source.get_block_hash(h)?;
             Ok(h)
         })?;
         Ok(())
@@ -70,7 +67,10 @@ impl Spaced {
                 info!("Pruned blocks up to height {}", pruned_up_to);
             }
             Err(e) => {
-                warn!("Failed to prune: {} (is Bitcoin Core started with -prune=1?)", e);
+                warn!(
+                    "Failed to prune: {} (is Bitcoin Core started with -prune=1?)",
+                    e
+                );
             }
         }
     }
@@ -84,8 +84,8 @@ impl Spaced {
         let sp_idx = self.chain.has_spaces_index();
         let pt_idx = self.chain.has_nums_index();
 
-        let (block_result,ptr_block_result) = node
-            .scan_block(&mut self.chain, id.height, id.hash, &block, sp_idx, pt_idx)?;
+        let (block_result, ptr_block_result) =
+            node.scan_block(&mut self.chain, id.height, id.hash, &block, sp_idx, pt_idx)?;
 
         if let Some(result) = block_result {
             self.chain.apply_block_to_spaces_index(id.hash, result)?;
@@ -143,7 +143,9 @@ impl Spaced {
                         }
                     }
                     BlockEvent::Waiting(bitcoind_height) => {
-                        if self.enable_pruning && last_idle_prune.elapsed() >= Duration::from_secs(60) {
+                        if self.enable_pruning
+                            && last_idle_prune.elapsed() >= Duration::from_secs(60)
+                        {
                             self.prune(&source, bitcoind_height);
                             last_idle_prune = std::time::Instant::now();
                         }
@@ -155,7 +157,7 @@ impl Spaced {
                             self.prune(&source, id.height);
                         }
                     }
-                    BlockEvent::Error(e) if matches!(e, BlockFetchError::BlockMismatch) => {
+                    BlockEvent::Error(BlockFetchError::BlockMismatch) => {
                         if let Err(e) = self.restore(&source) {
                             if e.downcast_ref::<BitcoinRpcError>().is_none() {
                                 return Err(e);
@@ -177,7 +179,7 @@ impl Spaced {
                         fetcher.restart(new_tip, &receiver);
                     }
                 },
-                Err(e) if matches!(e, std::sync::mpsc::TryRecvError::Empty) => {
+                Err(std::sync::mpsc::TryRecvError::Empty) => {
                     std::thread::sleep(Duration::from_millis(10));
                 }
                 Err(_) => {
diff --git a/client/src/store/chain.rs b/client/src/store/chain.rs
index 3c963a2..f5d355a 100644
--- a/client/src/store/chain.rs
+++ b/client/src/store/chain.rs
@@ -1,25 +1,30 @@
-use std::path::Path;
-use std::sync::Arc;
-use anyhow::{anyhow, Context};
+use crate::client::{BlockMeta, NumBlockMeta};
+use crate::rpc::{BlockMetaWithHash, NumBlockMetaWithHash};
+use crate::store::index::SqliteIndex;
+use crate::store::ptrs::{NumChainState, NumLiveStore, NumStore};
+use crate::store::spaces::{
+    RolloutEntry, RolloutIterator, SpLiveStore, SpStore, SpStoreUtils, SpacesState,
+};
+use crate::store::{EncodableOutpoint, ReadTx, Sha256};
+use anyhow::{Context, anyhow};
 use log::info;
 use spacedb::Hash;
-use spaces_protocol::bitcoin::{BlockHash, OutPoint};
+use spaces_nums::num_id::NumId;
+use spaces_nums::snumeric::SNumeric;
+use spaces_nums::{
+    Commitment, CommitmentKey, CommitmentTipKey, DelegatorKey, FullNumOut, NumOut, NumOutpointKey,
+    NumSource, RootAnchor,
+};
 use spaces_protocol::bitcoin::hashes::Hash as HashUtil;
+use spaces_protocol::bitcoin::{BlockHash, OutPoint};
 use spaces_protocol::constants::ChainAnchor;
 use spaces_protocol::hasher::{BidKey, OutpointKey, SpaceKey};
 use spaces_protocol::prepare::SpacesSource;
-use spaces_protocol::{FullSpaceOut, SpaceOut};
 use spaces_protocol::slabel::SLabel;
-use spaces_nums::{Commitment, CommitmentKey, FullNumOut, NumOut, NumSource, CommitmentTipKey, DelegatorKey, NumOutpointKey, RootAnchor};
-use spaces_nums::num_id::NumId;
-use spaces_nums::snumeric::SNumeric;
+use spaces_protocol::{FullSpaceOut, SpaceOut};
 use spaces_wallet::bitcoin::Network;
-use crate::client::{BlockMeta, NumBlockMeta};
-use crate::rpc::{BlockMetaWithHash, NumBlockMetaWithHash};
-use crate::store::{EncodableOutpoint, ReadTx, Sha256};
-use crate::store::index::SqliteIndex;
-use crate::store::ptrs::{NumChainState, NumLiveStore, NumStore};
-use crate::store::spaces::{RolloutEntry, RolloutIterator, SpLiveStore, SpStore, SpStoreUtils, SpacesState};
+use std::path::Path;
+use std::sync::Arc;
 
 pub const ROOT_ANCHORS_COUNT: u32 = 120;
 pub const COMMIT_BLOCK_INTERVAL: u32 = 36;
@@ -34,11 +39,10 @@ macro_rules! const_assert {
 }
 
 const_assert!(
-    spaces_protocol::constants::ROLLOUT_BLOCK_INTERVAL % COMMIT_BLOCK_INTERVAL == 0,
+    spaces_protocol::constants::ROLLOUT_BLOCK_INTERVAL.is_multiple_of(COMMIT_BLOCK_INTERVAL),
     "commit and rollout intervals must be aligned"
 );
 
-
 pub struct CachedSnapshot {
     pub height: u32,
     pub spaces: ReadTx,
@@ -76,45 +80,70 @@ pub struct LiveIndex {
 }
 
 impl SpacesSource for Chain {
-    fn get_space_outpoint(&mut self, space_hash: &SpaceKey) -> spaces_protocol::errors::Result<Option<OutPoint>> {
+    fn get_space_outpoint(
+        &mut self,
+        space_hash: &SpaceKey,
+    ) -> spaces_protocol::errors::Result<Option<OutPoint>> {
         self.db.sp.state.get_space_outpoint(space_hash)
     }
 
-    fn get_spaceout(&mut self, outpoint: &OutPoint) -> spaces_protocol::errors::Result<Option<SpaceOut>> {
+    fn get_spaceout(
+        &mut self,
+        outpoint: &OutPoint,
+    ) -> spaces_protocol::errors::Result<Option<SpaceOut>> {
         self.db.sp.state.get_spaceout(outpoint)
     }
 }
 
 impl NumSource for Chain {
-    fn get_num_outpoint_by_id(&mut self, space_hash: &NumId) -> spaces_protocol::errors::Result<Option<OutPoint>> {
+    fn get_num_outpoint_by_id(
+        &mut self,
+        space_hash: &NumId,
+    ) -> spaces_protocol::errors::Result<Option<OutPoint>> {
         self.db.num.state.get_num_outpoint_by_id(space_hash)
     }
 
-    fn get_commitment(&mut self, key: &CommitmentKey) -> spaces_protocol::errors::Result<Option<Commitment>> {
+    fn get_commitment(
+        &mut self,
+        key: &CommitmentKey,
+    ) -> spaces_protocol::errors::Result<Option<Commitment>> {
         self.db.num.state.get_commitment(key)
     }
 
-    fn get_delegator(&mut self, key: &DelegatorKey) -> spaces_protocol::errors::Result<Option<SLabel>> {
+    fn get_delegator(
+        &mut self,
+        key: &DelegatorKey,
+    ) -> spaces_protocol::errors::Result<Option<SLabel>> {
         self.db.num.state.get_delegator(key)
     }
 
-    fn get_commitments_tip(&mut self, key: &CommitmentTipKey) -> spaces_protocol::errors::Result<Option<Hash>> {
+    fn get_commitments_tip(
+        &mut self,
+        key: &CommitmentTipKey,
+    ) -> spaces_protocol::errors::Result<Option<Hash>> {
         self.db.num.state.get_commitments_tip(key)
     }
 
-    fn get_numout(&mut self, outpoint: &OutPoint) -> spaces_protocol::errors::Result<Option<NumOut>> {
+    fn get_numout(
+        &mut self,
+        outpoint: &OutPoint,
+    ) -> spaces_protocol::errors::Result<Option<NumOut>> {
         self.db.num.state.get_numout(outpoint)
     }
 
     fn get_num_id(&mut self, snum: &SNumeric) -> spaces_protocol::errors::Result<Option<NumId>> {
-        self.idx.db.get_snumeric(snum).map_err(|e| {
-            spaces_protocol::errors::Error::IO(format!("get_num_id: {}", e))
-        })
+        self.idx
+            .db
+            .get_snumeric(snum)
+            .map_err(|e| spaces_protocol::errors::Error::IO(format!("get_num_id: {}", e)))
     }
 }
 
 impl Chain {
-    pub fn get_space_info(&mut self, space_hash: &SpaceKey) -> anyhow::Result<Option<FullSpaceOut>> {
+    pub fn get_space_info(
+        &mut self,
+        space_hash: &SpaceKey,
+    ) -> anyhow::Result<Option<FullSpaceOut>> {
         self.db.sp.state.get_space_info(space_hash)
     }
 
@@ -123,16 +152,26 @@ impl Chain {
     }
 
     pub fn snapshot_at(&mut self, target_height: u32) -> anyhow::Result<&mut CachedSnapshot> {
-        if self.cached_snapshot.as_ref()
+        if self
+            .cached_snapshot
+            .as_ref()
             .is_some_and(|c| c.height > self.tip().height)
         {
             self.cached_snapshot = None;
         }
 
-        if !self.cached_snapshot.as_ref().is_some_and(|c| c.height == target_height) {
+        if self
+            .cached_snapshot
+            .as_ref()
+            .is_none_or(|c| c.height != target_height)
+        {
             let spaces = self.db.sp.state.read_at(target_height)?;
             let ptrs = self.db.num.state.read_at(target_height)?;
-            self.cached_snapshot = Some(CachedSnapshot { height: target_height, spaces, nums: ptrs });
+            self.cached_snapshot = Some(CachedSnapshot {
+                height: target_height,
+                spaces,
+                nums: ptrs,
+            });
         }
 
         Ok(self.cached_snapshot.as_mut().unwrap())
@@ -177,14 +216,16 @@ impl Chain {
 
         // If spaces synced past the ptrs point, reset the tip
         if initial_num_sync {
-            let sp_tip = chain.db.sp.state.tip.read().expect("tip").clone();
+            let sp_tip = *chain.db.sp.state.tip.read().expect("tip");
             if sp_tip.height > nums_genesis.height {
-                info!("spaces tip = {} > nums genesis = {} - rescanning to index nums",
+                info!(
+                    "spaces tip = {} > nums genesis = {} - rescanning to index nums",
                     sp_tip.height, nums_genesis.height
                 );
-                chain.restore_spaces(|_| {
-                    return Ok(BlockHash::from_slice(&[0u8; 32]).expect("hash"));
-                }, Some(nums_genesis.height))?;
+                chain.restore_spaces(
+                    |_| Ok(BlockHash::from_slice(&[0u8; 32]).expect("hash")),
+                    Some(nums_genesis.height),
+                )?;
             }
         }
 
@@ -192,7 +233,7 @@ impl Chain {
     }
 
     pub fn tip(&self) -> ChainAnchor {
-        self.db.sp.state.tip.read().expect("read").clone()
+        *self.db.sp.state.tip.read().expect("read")
     }
 
     pub fn apply_block_to_spaces_index(
@@ -201,7 +242,9 @@ impl Chain {
         block: BlockMeta,
     ) -> anyhow::Result<()> {
         if self.idx.block_index {
-            self.idx.db.insert_spaces_block(block_hash, block.height, block);
+            self.idx
+                .db
+                .insert_spaces_block(block_hash, block.height, block);
         }
         Ok(())
     }
@@ -212,21 +255,23 @@ impl Chain {
         block: NumBlockMeta,
     ) -> anyhow::Result<()> {
         if self.idx.block_index {
-            self.idx.db.insert_nums_block(block_hash, block.height, block);
+            self.idx
+                .db
+                .insert_nums_block(block_hash, block.height, block);
         }
         Ok(())
     }
 
     pub fn maybe_commit(&self, checkpoint: ChainAnchor) -> anyhow::Result<bool> {
-        if checkpoint.height % COMMIT_BLOCK_INTERVAL != 0 {
+        if !checkpoint.height.is_multiple_of(COMMIT_BLOCK_INTERVAL) {
             return Ok(false);
         }
 
         let spaces_batch = self.db.sp.store.write().expect("write handle");
         let ptrs_batch = self.db.num.store.write().expect("write handle");
 
-        self.db.sp.state.commit(checkpoint.clone(), spaces_batch)?;
-        self.db.num.state.commit(checkpoint.clone(), ptrs_batch)?;
+        self.db.sp.state.commit(checkpoint, spaces_batch)?;
+        self.db.num.state.commit(checkpoint, ptrs_batch)?;
 
         self.idx.db.commit()?;
 
@@ -299,8 +344,7 @@ impl Chain {
     }
 
     pub fn update_spaces_tip(&self, height: u32, block_hash: BlockHash) {
-        let mut tip = self.db.sp.state.tip.write().
-            expect("write tip");
+        let mut tip = self.db.sp.state.tip.write().expect("write tip");
         tip.height = height;
         tip.hash = block_hash;
     }
@@ -367,18 +411,30 @@ impl Chain {
         if !self.idx.block_index {
             return Err(anyhow!("spaces index must be enabled"));
         }
-        let block = self.idx.db.get_spaces_block(&hash)
+        let block = self
+            .idx
+            .db
+            .get_spaces_block(&hash)
             .context("could not retrieve block meta")?;
-        Ok(block.map(|b| BlockMetaWithHash { hash, block_meta: b }))
+        Ok(block.map(|b| BlockMetaWithHash {
+            hash,
+            block_meta: b,
+        }))
     }
 
     pub fn get_nums_block(&self, hash: BlockHash) -> anyhow::Result<Option<NumBlockMetaWithHash>> {
         if !self.idx.block_index {
             return Err(anyhow!("ptrs index must be enabled"));
         }
-        let block = self.idx.db.get_nums_block(&hash)
+        let block = self
+            .idx
+            .db
+            .get_nums_block(&hash)
             .context("could not retrieve num block meta")?;
-        Ok(block.map(|b| NumBlockMetaWithHash { hash, block_meta: b }))
+        Ok(block.map(|b| NumBlockMetaWithHash {
+            hash,
+            block_meta: b,
+        }))
     }
 
     pub fn restore<F>(&self, get_block_hash: F) -> anyhow::Result<()>
@@ -393,7 +449,7 @@ impl Chain {
         let iter = self.db.num.store.iter();
 
         let mut restore_point = None;
-        for (_idx, snapshot) in iter.enumerate() {
+        for snapshot in iter {
             let snapshot = snapshot?;
             let anchor: ChainAnchor = snapshot.metadata().try_into()?;
             if anchor == required_checkpoint {
@@ -403,11 +459,19 @@ impl Chain {
         }
 
         let snapshot = match restore_point {
-            None => return Err(anyhow!("Could not restore nums to height = {}", required_checkpoint.height)),
+            None => {
+                return Err(anyhow!(
+                    "Could not restore nums to height = {}",
+                    required_checkpoint.height
+                ));
+            }
             Some(s) => s,
         };
 
-        info!("Restoring nums block={} height={}", required_checkpoint.hash, required_checkpoint.height);
+        info!(
+            "Restoring nums block={} height={}",
+            required_checkpoint.hash, required_checkpoint.height
+        );
 
         snapshot
             .rollback()
@@ -418,12 +482,16 @@ impl Chain {
         Ok(())
     }
 
-    pub fn restore_spaces<F>(&self, get_block_hash: F, nums_genesis_height: Option<u32>) -> anyhow::Result<ChainAnchor>
+    pub fn restore_spaces<F>(
+        &self,
+        get_block_hash: F,
+        nums_genesis_height: Option<u32>,
+    ) -> anyhow::Result<ChainAnchor>
     where
         F: Fn(u32) -> anyhow::Result<BlockHash>,
     {
         let chain_iter = self.db.sp.store.iter();
-        for (_snapshot_index, snapshot) in chain_iter.enumerate() {
+        for snapshot in chain_iter {
             let chain_snapshot = snapshot?;
             let chain_checkpoint: ChainAnchor = chain_snapshot.metadata().try_into()?;
             if let Some(max_height) = nums_genesis_height {
@@ -450,7 +518,7 @@ impl Chain {
                 .rollback()
                 .context("could not rollback chain snapshot")?;
 
-            self.db.sp.state.restore(chain_checkpoint.clone());
+            self.db.sp.state.restore(chain_checkpoint);
             self.idx.db.restore(chain_checkpoint.height)?;
             return Ok(chain_checkpoint);
         }
@@ -487,13 +555,11 @@ impl Chain {
 
             // Check if we can get PTR snapshot at the same height
             let mut ptrs_root = None;
-            if let Some(pt_snap) = pt_iter.next() {
-                if let Ok(mut pt_snap) = pt_snap {
-                    let pt_anchor: ChainAnchor = pt_snap.metadata().try_into()?;
-                    // Only include PTR root if it matches the same block
-                    if pt_anchor.height == anchor.height && pt_anchor.hash == anchor.hash {
-                        ptrs_root = Some(pt_snap.compute_root()?);
-                    }
+            if let Some(Ok(mut pt_snap)) = pt_iter.next() {
+                let pt_anchor: ChainAnchor = pt_snap.metadata().try_into()?;
+                // Only include PTR root if it matches the same block
+                if pt_anchor.height == anchor.height && pt_anchor.hash == anchor.hash {
+                    ptrs_root = Some(pt_snap.compute_root()?);
                 }
             }
 
@@ -502,7 +568,7 @@ impl Chain {
                 let updated_anchor = RootAnchor {
                     spaces_root: existing.spaces_root,
                     nums_root: ptrs_root.or(existing.nums_root),
-                    block: existing.block.clone(),
+                    block: existing.block,
                 };
                 anchors.push(updated_anchor);
             } else {
@@ -522,7 +588,11 @@ impl Chain {
             info!(
                 "Latest root anchor spaces={} ptrs={} (height: {})",
                 hex::encode(result.spaces_root),
-                result.nums_root.as_ref().map(hex::encode).unwrap_or_else(|| "none".to_string()),
+                result
+                    .nums_root
+                    .as_ref()
+                    .map(hex::encode)
+                    .unwrap_or_else(|| "none".to_string()),
                 result.block.height
             );
         }
@@ -530,5 +600,3 @@ impl Chain {
         Ok(())
     }
 }
-
-
diff --git a/client/src/store/index.rs b/client/src/store/index.rs
index c2b8880..94ca62b 100644
--- a/client/src/store/index.rs
+++ b/client/src/store/index.rs
@@ -1,11 +1,11 @@
-use std::path::Path;
-use std::sync::{Mutex, RwLock};
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use borsh::BorshDeserialize;
-use rusqlite::{params, Connection};
+use rusqlite::{Connection, params};
 use spaces_nums::num_id::NumId;
 use spaces_nums::snumeric::SNumeric;
 use spaces_protocol::bitcoin::BlockHash;
+use std::path::Path;
+use std::sync::{Mutex, RwLock};
 
 use crate::client::{BlockMeta, NumBlockMeta};
 
@@ -89,7 +89,7 @@ impl SqliteIndex {
         let conn = self.conn.lock().unwrap();
         let mut stmt =
             conn.prepare_cached("SELECT data FROM spaces_blocks WHERE block_hash = ?1")?;
-        let result = stmt.query_row(params![<BlockHash as AsRef<[u8]>>::as_ref(&hash)], |row| {
+        let result = stmt.query_row(params![<BlockHash as AsRef<[u8]>>::as_ref(hash)], |row| {
             let data: Vec<u8> = row.get(0)?;
             Ok(data)
         });
@@ -125,9 +125,8 @@ impl SqliteIndex {
         }
         // Fall back to sqlite
         let conn = self.conn.lock().unwrap();
-        let mut stmt =
-            conn.prepare_cached("SELECT data FROM nums_blocks WHERE block_hash = ?1")?;
-        let result = stmt.query_row(params![<BlockHash as AsRef<[u8]>>::as_ref(&hash)], |row| {
+        let mut stmt = conn.prepare_cached("SELECT data FROM nums_blocks WHERE block_hash = ?1")?;
+        let result = stmt.query_row(params![<BlockHash as AsRef<[u8]>>::as_ref(hash)], |row| {
             let data: Vec<u8> = row.get(0)?;
             Ok(data)
         });
@@ -144,12 +143,11 @@ impl SqliteIndex {
     // --- SNumeric index ---
 
     pub fn insert_snumeric(&self, snum: &SNumeric, id: NumId) {
-        self.staged.write().unwrap().snumeric.push((
-            snum.block(),
-            snum.tx_pos(),
-            snum.vout(),
-            id,
-        ));
+        self.staged
+            .write()
+            .unwrap()
+            .snumeric
+            .push((snum.block(), snum.tx_pos(), snum.vout(), id));
     }
 
     pub fn get_snumeric(&self, snum: &SNumeric) -> Result<Option<NumId>> {
@@ -203,7 +201,11 @@ impl SqliteIndex {
             )?;
             for (hash, height, meta) in staged.spaces_blocks.drain(..) {
                 let data = borsh::to_vec(&meta)?;
-                stmt.execute(params![height, <BlockHash as AsRef<[u8]>>::as_ref(&hash), data])?;
+                stmt.execute(params![
+                    height,
+                    <BlockHash as AsRef<[u8]>>::as_ref(&hash),
+                    data
+                ])?;
             }
         }
 
@@ -213,7 +215,11 @@ impl SqliteIndex {
             )?;
             for (hash, height, meta) in staged.nums_blocks.drain(..) {
                 let data = borsh::to_vec(&meta)?;
-                stmt.execute(params![height, <BlockHash as AsRef<[u8]>>::as_ref(&hash), data])?;
+                stmt.execute(params![
+                    height,
+                    <BlockHash as AsRef<[u8]>>::as_ref(&hash),
+                    data
+                ])?;
             }
         }
 
@@ -222,7 +228,12 @@ impl SqliteIndex {
                 "INSERT OR REPLACE INTO snumeric (block_height, tx_pos, vout, num_id) VALUES (?1, ?2, ?3, ?4)",
             )?;
             for (block_height, tx_pos, vout, id) in staged.snumeric.drain(..) {
-                stmt.execute(params![block_height, tx_pos as u32, vout as u32, id.as_slice()])?;
+                stmt.execute(params![
+                    block_height,
+                    tx_pos as u32,
+                    vout as u32,
+                    id.as_slice()
+                ])?;
             }
         }
 
@@ -248,4 +259,4 @@ impl SqliteIndex {
         )?;
         Ok(())
     }
-}
\ No newline at end of file
+}
diff --git a/client/src/store/mod.rs b/client/src/store/mod.rs
index a90e596..7aec309 100644
--- a/client/src/store/mod.rs
+++ b/client/src/store/mod.rs
@@ -1,18 +1,18 @@
-use std::collections::BTreeMap;
-use std::path::PathBuf;
+use crate::store::chain::ROOT_ANCHORS_COUNT;
 use borsh::{BorshDeserialize, BorshSerialize};
 use spacedb::db::Database;
-use spacedb::{Configuration, Hash, NodeHasher, Sha256Hasher};
 use spacedb::tx::{ReadTransaction, WriteTransaction};
+use spacedb::{Configuration, Hash, NodeHasher, Sha256Hasher};
 use spaces_protocol::bitcoin::OutPoint;
-use crate::store::chain::ROOT_ANCHORS_COUNT;
+use std::collections::BTreeMap;
+use std::path::PathBuf;
 
 const DEFAULT_CACHE_SIZE: usize = 50 * 1024 * 1024; /* 50MB */
 
-pub mod spaces;
-pub mod ptrs;
 pub mod chain;
 pub mod index;
+pub mod ptrs;
+pub mod spaces;
 
 type SpaceDb = Database<Sha256Hasher>;
 type ReadTx = ReadTransaction<Sha256Hasher>;
@@ -21,14 +21,13 @@ type WriteMemory = BTreeMap<Hash, Option<Vec<u8>>>;
 
 pub struct Sha256;
 
-
 #[derive(BorshSerialize, BorshDeserialize)]
 pub struct EncodableOutpoint(
     #[borsh(
         serialize_with = "borsh_utils::serialize_outpoint",
         deserialize_with = "borsh_utils::deserialize_outpoint"
     )]
-    pub OutPoint
+    pub OutPoint,
 );
 
 impl From<OutPoint> for EncodableOutpoint {
@@ -49,11 +48,18 @@ impl spaces_protocol::hasher::KeyHasher for Sha256 {
     }
 }
 
-fn open_db(path_buf: PathBuf, auto_hash_index: bool, cache_size: Option<usize>) -> anyhow::Result<Database<Sha256Hasher>> {
-    let  config = Configuration::standard()
+fn open_db(
+    path_buf: PathBuf,
+    auto_hash_index: bool,
+    cache_size: Option<usize>,
+) -> anyhow::Result<Database<Sha256Hasher>> {
+    let config = Configuration::standard()
         .with_auto_hash_index(auto_hash_index)
         .with_hash_index_pruning(Some(ROOT_ANCHORS_COUNT as _))
         .with_cache_size(cache_size.unwrap_or(DEFAULT_CACHE_SIZE));
 
-    Ok(Database::open_with_config(path_buf.to_str().unwrap(), config)?)
+    Ok(Database::open_with_config(
+        path_buf.to_str().unwrap(),
+        config,
+    )?)
 }
diff --git a/client/src/store/ptrs.rs b/client/src/store/ptrs.rs
index 46b9091..0268957 100644
--- a/client/src/store/ptrs.rs
+++ b/client/src/store/ptrs.rs
@@ -1,29 +1,30 @@
 use std::{
-    collections::{BTreeMap},
-    io,
-    io::ErrorKind,
-    mem,
-    path::{PathBuf},
+    collections::BTreeMap,
+    io, mem,
+    path::PathBuf,
     sync::{Arc, RwLock},
 };
 
-use anyhow::{anyhow, Context, Result};
+use crate::store::{EncodableOutpoint, Sha256, open_db};
+use anyhow::{Context, Result, anyhow};
 use borsh::{BorshDeserialize, BorshSerialize};
 use spacedb::{
+    Hash, Sha256Hasher,
     db::{Database, SnapshotIterator},
     tx::{ReadTransaction, WriteTransaction},
-    Hash, Sha256Hasher,
 };
+use spaces_nums::num_id::NumId;
+use spaces_nums::snumeric::SNumeric;
+use spaces_nums::{
+    Commitment, CommitmentKey, CommitmentTipKey, DelegatorKey, FullNumOut, NumOut, NumOutpointKey,
+    NumSource,
+};
+use spaces_protocol::slabel::SLabel;
 use spaces_protocol::{
     bitcoin::{BlockHash, OutPoint},
-    constants::{ChainAnchor},
-    hasher::{KeyHash},
+    constants::ChainAnchor,
+    hasher::KeyHash,
 };
-use spaces_protocol::slabel::SLabel;
-use spaces_nums::{Commitment, CommitmentKey, FullNumOut, NumOut, NumSource, CommitmentTipKey, DelegatorKey, NumOutpointKey};
-use spaces_nums::snumeric::SNumeric;
-use spaces_nums::num_id::NumId;
-use crate::store::{open_db, EncodableOutpoint, Sha256};
 
 type SpaceDb = Database<Sha256Hasher>;
 type ReadTx = ReadTransaction<Sha256Hasher>;
@@ -66,7 +67,7 @@ impl NumStore {
     }
 
     pub fn iter(&self) -> SnapshotIterator<'_, Sha256Hasher> {
-        return self.0.iter();
+        self.0.iter()
     }
 
     pub fn write(&self) -> Result<WriteTx<'_>> {
@@ -75,8 +76,8 @@ impl NumStore {
 
     pub fn begin(&self, genesis_block: &ChainAnchor) -> Result<NumLiveSnapshot> {
         let snapshot = self.0.begin_read()?;
-        let anchor: ChainAnchor = if snapshot.metadata().len() == 0 {
-            genesis_block.clone()
+        let anchor: ChainAnchor = if snapshot.metadata().is_empty() {
+            *genesis_block
         } else {
             snapshot.metadata().try_into()?
         };
@@ -105,10 +106,7 @@ pub trait NumChainState {
     fn insert_num_outpoint(&self, key: NumId, outpoint: EncodableOutpoint);
 
     #[allow(dead_code)]
-    fn get_num_info(
-        &mut self,
-        id: &NumId,
-    ) -> Result<Option<FullNumOut>>;
+    fn get_num_info(&mut self, id: &NumId) -> Result<Option<FullNumOut>>;
 }
 
 impl NumChainState for NumLiveSnapshot {
@@ -154,7 +152,7 @@ impl NumChainState for NumLiveSnapshot {
 impl NumLiveSnapshot {
     #[inline]
     pub fn is_dirty(&self) -> bool {
-        self.staged.read().expect("read").memory.len() > 0
+        !self.staged.read().expect("read").memory.is_empty()
     }
 
     pub fn restore(&self, checkpoint: ChainAnchor) {
@@ -171,11 +169,13 @@ impl NumLiveSnapshot {
     }
 
     pub fn read_at(&self, block_height: u32) -> anyhow::Result<ReadTx> {
-        self.db.iter()
+        self.db
+            .iter()
             .filter_map(|s| s.ok())
             .find(|s| {
-                s.metadata().try_into()
-                    .map_or(false, |a: ChainAnchor| a.height == block_height)
+                s.metadata()
+                    .try_into()
+                    .is_ok_and(|a: ChainAnchor| a.height == block_height)
             })
             .ok_or_else(|| anyhow!("Snapshot at block {} not found", block_height))
     }
@@ -203,9 +203,7 @@ impl NumLiveSnapshot {
         match self.get_raw(&key.into())? {
             Some(value) => {
                 let decoded: T = borsh::from_slice(&value)
-                    .map_err(|e| {
-                        spacedb::Error::IO(io::Error::new(ErrorKind::Other, e.to_string()))
-                    })?;
+                    .map_err(|e| spacedb::Error::IO(io::Error::other(e.to_string())))?;
                 Ok(Some(decoded))
             }
             None => Ok(None),
@@ -237,9 +235,12 @@ impl NumLiveSnapshot {
     fn update_snapshot(&mut self, version: BlockHash) -> Result<()> {
         if self.snapshot.0 != version {
             self.snapshot.1 = self.db.begin_read().context("could not read snapshot")?;
-            let anchor: ChainAnchor = self.snapshot.1.metadata().try_into().map_err(|_| {
-                std::io::Error::new(std::io::ErrorKind::Other, "could not parse metdata")
-            })?;
+            let anchor: ChainAnchor = self
+                .snapshot
+                .1
+                .metadata()
+                .try_into()
+                .map_err(|_| std::io::Error::other("could not parse metdata"))?;
 
             assert_eq!(version, anchor.hash, "inconsistent db state");
             self.snapshot.0 = version;
@@ -260,9 +261,8 @@ impl NumLiveSnapshot {
         let version = rlock.snapshot_version;
         drop(rlock);
 
-        self.update_snapshot(version).map_err(|error| {
-            spacedb::Error::IO(std::io::Error::new(std::io::ErrorKind::Other, error))
-        })?;
+        self.update_snapshot(version)
+            .map_err(|error| spacedb::Error::IO(std::io::Error::other(error)))?;
         self.snapshot.1.get(key)
     }
 
@@ -278,11 +278,7 @@ impl NumLiveSnapshot {
 
         for (key, value) in changes.memory {
             match value {
-                None => {
-                    _ = {
-                        tx = tx.delete(key)?;
-                    }
-                }
+                None => tx = tx.delete(key)?,
                 Some(value) => tx = tx.insert(key, value)?,
             }
         }
@@ -300,29 +296,38 @@ impl NumSource for NumLiveSnapshot {
         id: &NumId,
     ) -> spaces_protocol::errors::Result<Option<OutPoint>> {
         let result: Option<EncodableOutpoint> = self.get(*id).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getnumoutpoint: {}", err.to_string()))
+            spaces_protocol::errors::Error::IO(format!("getnumoutpoint: {}", err))
         })?;
         Ok(result.map(|out| out.into()))
     }
 
-    fn get_commitment(&mut self, key: &CommitmentKey) -> spaces_protocol::errors::Result<Option<Commitment>> {
-        let result = self.get(*key).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getcommitment: {}", err.to_string()))
-        })?;
+    fn get_commitment(
+        &mut self,
+        key: &CommitmentKey,
+    ) -> spaces_protocol::errors::Result<Option<Commitment>> {
+        let result = self
+            .get(*key)
+            .map_err(|err| spaces_protocol::errors::Error::IO(format!("getcommitment: {}", err)))?;
         Ok(result)
     }
 
-    fn get_delegator(&mut self, key: &DelegatorKey) -> spaces_protocol::errors::Result<Option<SLabel>> {
-        let result = self.get(*key).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getdelegate: {}", err.to_string()))
-        })?;
+    fn get_delegator(
+        &mut self,
+        key: &DelegatorKey,
+    ) -> spaces_protocol::errors::Result<Option<SLabel>> {
+        let result = self
+            .get(*key)
+            .map_err(|err| spaces_protocol::errors::Error::IO(format!("getdelegate: {}", err)))?;
         Ok(result)
     }
 
-    fn get_commitments_tip(&mut self, key: &CommitmentTipKey) -> spaces_protocol::errors::Result<Option<Hash>> {
-        let result = self.get(*key).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getregistry: {}", err.to_string()))
-        })?;
+    fn get_commitments_tip(
+        &mut self,
+        key: &CommitmentTipKey,
+    ) -> spaces_protocol::errors::Result<Option<Hash>> {
+        let result = self
+            .get(*key)
+            .map_err(|err| spaces_protocol::errors::Error::IO(format!("getregistry: {}", err)))?;
         Ok(result)
     }
 
@@ -331,9 +336,9 @@ impl NumSource for NumLiveSnapshot {
         outpoint: &OutPoint,
     ) -> spaces_protocol::errors::Result<Option<NumOut>> {
         let h = NumOutpointKey::from_outpoint::<Sha256>(*outpoint);
-        let result = self.get(h).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getptrout: {}", err.to_string()))
-        })?;
+        let result = self
+            .get(h)
+            .map_err(|err| spaces_protocol::errors::Error::IO(format!("getptrout: {}", err)))?;
         Ok(result)
     }
 
diff --git a/client/src/store/spaces.rs b/client/src/store/spaces.rs
index 413c9b5..656b95e 100644
--- a/client/src/store/spaces.rs
+++ b/client/src/store/spaces.rs
@@ -1,31 +1,28 @@
 use std::{
     collections::{BTreeMap, BTreeSet, HashMap},
-    fs,
-    io,
-    io::ErrorKind,
-    mem,
+    fs, io, mem,
     path::{Path, PathBuf},
     sync::{Arc, RwLock},
 };
 
-use anyhow::{anyhow, Context, Result};
+use crate::store::{EncodableOutpoint, ReadTx, Sha256, SpaceDb, WriteMemory, WriteTx, open_db};
+use anyhow::{Context, Result, anyhow};
 use borsh::{BorshDeserialize, BorshSerialize};
 use jsonrpsee::core::Serialize;
 use serde::Deserialize;
 use spacedb::{
+    Hash, Sha256Hasher,
     db::{Database, SnapshotIterator},
     tx::KeyIterator,
-    Hash, Sha256Hasher,
 };
+use spaces_nums::RootAnchor;
 use spaces_protocol::{
+    Covenant, FullSpaceOut, SpaceOut,
     bitcoin::{BlockHash, OutPoint},
     constants::{ChainAnchor, ROLLOUT_BATCH_SIZE},
     hasher::{BidKey, KeyHash, OutpointKey, SpaceKey},
     prepare::SpacesSource,
-    Covenant, FullSpaceOut, SpaceOut,
 };
-use spaces_nums::RootAnchor;
-use crate::store::{open_db, EncodableOutpoint, ReadTx, Sha256, SpaceDb, WriteMemory, WriteTx};
 
 #[derive(Clone)]
 pub struct SpStore(SpaceDb);
@@ -69,7 +66,7 @@ impl SpStore {
     }
 
     pub fn iter(&self) -> SnapshotIterator<'_, Sha256Hasher> {
-        return self.0.iter();
+        self.0.iter()
     }
 
     pub fn write(&self) -> Result<WriteTx<'_>> {
@@ -111,8 +108,8 @@ impl SpStore {
 
     pub fn begin(&self, genesis_block: &ChainAnchor) -> Result<SpLiveSnapshot> {
         let snapshot = self.0.begin_read()?;
-        let anchor: ChainAnchor = if snapshot.metadata().len() == 0 {
-            genesis_block.clone()
+        let anchor: ChainAnchor = if snapshot.metadata().is_empty() {
+            *genesis_block
         } else {
             snapshot.metadata().try_into()?
         };
@@ -195,7 +192,7 @@ impl SpacesState for SpLiveSnapshot {
 impl SpLiveSnapshot {
     #[inline]
     pub fn is_dirty(&self) -> bool {
-        self.staged.read().expect("read").memory.len() > 0
+        !self.staged.read().expect("read").memory.is_empty()
     }
 
     pub fn restore(&self, checkpoint: ChainAnchor) {
@@ -212,11 +209,13 @@ impl SpLiveSnapshot {
     }
 
     pub fn read_at(&self, block_height: u32) -> anyhow::Result<ReadTx> {
-        self.db.iter()
+        self.db
+            .iter()
             .filter_map(|s| s.ok())
             .find(|s| {
-                s.metadata().try_into()
-                    .map_or(false, |a: ChainAnchor| a.height == block_height)
+                s.metadata()
+                    .try_into()
+                    .is_ok_and(|a: ChainAnchor| a.height == block_height)
             })
             .ok_or_else(|| anyhow!("Snapshot at block {} not found", block_height))
     }
@@ -244,9 +243,7 @@ impl SpLiveSnapshot {
         match self.get_raw(&key.into())? {
             Some(value) => {
                 let decoded: T = borsh::from_slice(&value)
-                    .map_err(|e| {
-                    spacedb::Error::IO(io::Error::new(ErrorKind::Other, e.to_string()))
-                })?;
+                    .map_err(|e| spacedb::Error::IO(io::Error::other(e.to_string())))?;
                 Ok(Some(decoded))
             }
             None => Ok(None),
@@ -278,9 +275,12 @@ impl SpLiveSnapshot {
     fn update_snapshot(&mut self, version: BlockHash) -> Result<()> {
         if self.snapshot.0 != version {
             self.snapshot.1 = self.db.begin_read().context("could not read snapshot")?;
-            let anchor: ChainAnchor = self.snapshot.1.metadata().try_into().map_err(|_| {
-                std::io::Error::new(std::io::ErrorKind::Other, "could not parse metdata")
-            })?;
+            let anchor: ChainAnchor = self
+                .snapshot
+                .1
+                .metadata()
+                .try_into()
+                .map_err(|_| std::io::Error::other("could not parse metdata"))?;
 
             assert_eq!(version, anchor.hash, "inconsistent db state");
             self.snapshot.0 = version;
@@ -301,9 +301,8 @@ impl SpLiveSnapshot {
         let version = rlock.snapshot_version;
         drop(rlock);
 
-        self.update_snapshot(version).map_err(|error| {
-            spacedb::Error::IO(std::io::Error::new(std::io::ErrorKind::Other, error))
-        })?;
+        self.update_snapshot(version)
+            .map_err(|error| spacedb::Error::IO(std::io::Error::other(error)))?;
         self.snapshot.1.get(key)
     }
 
@@ -319,11 +318,7 @@ impl SpLiveSnapshot {
 
         for (key, value) in changes.memory {
             match value {
-                None => {
-                    _ = {
-                        tx = tx.delete(key)?;
-                    }
-                }
+                None => tx = tx.delete(key)?,
                 Some(value) => tx = tx.insert(key, value)?,
             }
         }
@@ -349,16 +344,16 @@ impl SpLiveSnapshot {
         let mut spaceouts = Vec::with_capacity(rollouts.len());
         for (priority, spacehash) in rollouts {
             let outpoint = self.get_space_outpoint(&spacehash)?;
-            if let Some(outpoint) = outpoint {
-                if let Some(spaceout) = self.get_spaceout(&outpoint)? {
-                    spaceouts.push((
-                        priority,
-                        FullSpaceOut {
-                            txid: outpoint.txid,
-                            spaceout,
-                        },
-                    ));
-                }
+            if let Some(outpoint) = outpoint
+                && let Some(spaceout) = self.get_spaceout(&outpoint)?
+            {
+                spaceouts.push((
+                    priority,
+                    FullSpaceOut {
+                        txid: outpoint.txid,
+                        spaceout,
+                    },
+                ));
             }
         }
 
@@ -404,7 +399,7 @@ impl SpLiveSnapshot {
                     None
                 }
             })
-            .map(|x| Ok(x))
+            .map(Ok)
             .collect();
 
         drop(rlock);
@@ -440,7 +435,7 @@ impl SpacesSource for SpLiveSnapshot {
         space_hash: &SpaceKey,
     ) -> spaces_protocol::errors::Result<Option<OutPoint>> {
         let result: Option<EncodableOutpoint> = self.get(*space_hash).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getspaceoutpoint: {}", err.to_string()))
+            spaces_protocol::errors::Error::IO(format!("getspaceoutpoint: {}", err))
         })?;
         Ok(result.map(|out| out.into()))
     }
@@ -450,15 +445,13 @@ impl SpacesSource for SpLiveSnapshot {
         outpoint: &OutPoint,
     ) -> spaces_protocol::errors::Result<Option<SpaceOut>> {
         let h = OutpointKey::from_outpoint::<Sha256>(*outpoint);
-        let result = self.get(h).map_err(|err| {
-            spaces_protocol::errors::Error::IO(format!("getspaceout: {}", err.to_string()))
-        })?;
+        let result = self
+            .get(h)
+            .map_err(|err| spaces_protocol::errors::Error::IO(format!("getspaceout: {}", err)))?;
         Ok(result)
     }
 }
 
-
-
 pub struct RolloutIterator {
     inner: KeyIterator<Sha256Hasher>,
     n: usize,
@@ -493,7 +486,7 @@ struct KeyRolloutIterator {
 impl Iterator for KeyRolloutIterator {
     type Item = anyhow::Result<(BidKey, SpaceKey)>;
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(result) = self.iter.next() {
+        for result in self.iter.by_ref() {
             match result {
                 Ok((key, value)) if BidKey::is_valid(&key) => {
                     let spacehash = SpaceKey::from_slice_unchecked(value.as_slice());
diff --git a/client/src/wallets.rs b/client/src/wallets.rs
index cb927dd..7839cf9 100644
--- a/client/src/wallets.rs
+++ b/client/src/wallets.rs
@@ -1,38 +1,38 @@
 use anyhow::anyhow;
 use clap::ValueEnum;
-use futures::{stream::FuturesUnordered, StreamExt};
+use futures::{StreamExt, stream::FuturesUnordered};
 use log::{info, warn};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use spaces_protocol::{
+    FullSpaceOut, SpaceOut,
     bitcoin::Txid,
     constants::ChainAnchor,
     hasher::{KeyHasher, SpaceKey},
     slabel::SLabel,
-    FullSpaceOut, SpaceOut,
 };
 use std::collections::{HashMap, HashSet};
 use std::fmt::{Display, Formatter};
 use std::{collections::BTreeMap, fmt, str::FromStr, time::Duration};
 
 use spaces_wallet::{
+    Balance, DoubleUtxo, Listing, SpacesWallet, Subject, WalletInfo, WalletOutput,
     address::SpaceAddress,
     bdk_wallet::{
-        chain::{local_chain::CheckPoint, BlockId, ChainPosition},
         KeychainKind,
+        chain::{BlockId, ChainPosition, local_chain::CheckPoint},
     },
     bitcoin,
-    bitcoin::{secp256k1::schnorr, Address, Amount, FeeRate, OutPoint},
+    bitcoin::{Address, Amount, FeeRate, OutPoint, secp256k1::schnorr},
     builder::{CoinTransfer, SpaceTransfer, SpacesAwareCoinSelection},
     tx_event::{TxEvent, TxEventKind, TxRecord},
-    Balance, DoubleUtxo, Listing, SpacesWallet, Subject, WalletInfo, WalletOutput,
 };
 
 use crate::cbf::CompactFilterSync;
-use crate::rpc::{CommitParams};
+use crate::rpc::CommitParams;
 use crate::spaces::Spaced;
-use crate::store::chain::Chain;
 use crate::store::Sha256;
+use crate::store::chain::Chain;
 use crate::{
     calc_progress,
     checker::TxChecker,
@@ -40,13 +40,14 @@ use crate::{
     config::ExtendedNetwork,
     rpc::{RpcWalletRequest, RpcWalletTxBuilder, WalletLoadRequest},
     source::{
-        BestChain, BitcoinBlockSource, BitcoinRpc, BitcoinRpcError, BlockEvent, BlockFetchError, BlockFetcher,
+        BestChain, BitcoinBlockSource, BitcoinRpc, BitcoinRpcError, BlockEvent, BlockFetchError,
+        BlockFetcher,
     },
     std_wait,
 };
-use spaces_nums::num_id::{NumId, NumIdParseError, NUM_HRP};
-use spaces_nums::snumeric::SNumeric;
 use spaces_nums::FullNumOut;
+use spaces_nums::num_id::{NUM_HRP, NumId, NumIdParseError};
+use spaces_nums::snumeric::SNumeric;
 use spaces_nums::{DelegatorKey, NumOut, NumSource};
 use spaces_protocol::bitcoin::address::ParseError;
 use spaces_protocol::bitcoin::{Network, ScriptBuf};
@@ -259,19 +260,10 @@ fn display_fee(fee: &Option<Amount>) -> String {
     }
 }
 
-fn display_events(events: &Vec<TxEvent>) -> String {
+fn display_events(events: &[TxEvent]) -> String {
     events
         .iter()
-        .map(|e| {
-            format!(
-                "{} {}",
-                e.kind,
-                e.space
-                    .as_ref()
-                    .map(|s| s.clone())
-                    .unwrap_or("".to_string())
-            )
-        })
+        .map(|e| format!("{} {}", e.kind, e.space.clone().unwrap_or("".to_string())))
         .collect::<Vec<String>>()
         .join("\n")
 }
@@ -373,10 +365,7 @@ impl spaces_wallet::Mempool for MempoolChecker<'_> {
     }
 }
 
-fn resolve_subject_to_num_id<H: KeyHasher>(
-    chain: &mut Chain,
-    subject: &Subject,
-) -> anyhow::Result<NumId> {
+fn resolve_subject_to_num_id(chain: &mut Chain, subject: &Subject) -> anyhow::Result<NumId> {
     match subject {
         Subject::NumId(id) => Ok(*id),
         Subject::Label(label) if label.is_numeric() => {
@@ -450,12 +439,11 @@ impl RpcWallet {
         if let Ok(res) = source
             .rpc
             .send_json_blocking::<serde_json::Value>(&source.client, &estimate_req)
+            && let Some(fee_rate) = res["feerate"].as_f64()
         {
-            if let Some(fee_rate) = res["feerate"].as_f64() {
-                // Convert BTC/kB to sat/vB
-                let fee_rate_sat_vb = (fee_rate * 100_000.0).ceil() as u64;
-                return FeeRate::from_sat_per_vb(fee_rate_sat_vb);
-            }
+            // Convert BTC/kB to sat/vB
+            let fee_rate_sat_vb = (fee_rate * 100_000.0).ceil() as u64;
+            return FeeRate::from_sat_per_vb(fee_rate_sat_vb);
         }
 
         None
@@ -474,7 +462,7 @@ impl RpcWallet {
                 None => return Err(anyhow!("could not estimate fee rate")),
                 Some(r) => r,
             },
-            Some(r) => r.clone(),
+            Some(r) => *r,
         };
         info!("Using fee rate: {} sat/vB", fee_rate.to_sat_per_vb_ceil());
 
@@ -579,7 +567,7 @@ impl RpcWallet {
     fn wallet_handle_commands(
         network: ExtendedNetwork,
         source: &BitcoinBlockSource,
-        mut chain: &mut Chain,
+        chain: &mut Chain,
         wallet: &mut SpacesWallet,
         command: WalletCommand,
         progress_update: WalletProgressUpdate,
@@ -609,7 +597,7 @@ impl RpcWallet {
                     _ = resp.send(Err(anyhow::anyhow!("Wallet is syncing")));
                     return Ok(());
                 }
-                let batch_result = Self::batch_tx(network, &source, wallet, chain, request);
+                let batch_result = Self::batch_tx(network, source, wallet, chain, request);
                 _ = resp.send(batch_result);
             }
             WalletCommand::BumpFee {
@@ -622,14 +610,8 @@ impl RpcWallet {
                     _ = resp.send(Err(anyhow::anyhow!("Wallet is syncing")));
                     return Ok(());
                 }
-                let result = Self::handle_fee_bump(
-                    source,
-                    &mut chain,
-                    wallet,
-                    txid,
-                    skip_tx_check,
-                    fee_rate,
-                );
+                let result =
+                    Self::handle_fee_bump(source, chain, wallet, txid, skip_tx_check, fee_rate);
                 _ = resp.send(result);
             }
             WalletCommand::ForceSpendOutput {
@@ -855,6 +837,7 @@ impl RpcWallet {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn wallet_sync(
         network: ExtendedNetwork,
         source: BitcoinBlockSource,
@@ -965,7 +948,7 @@ impl RpcWallet {
                         }
                     }
                     BlockEvent::Waiting(_) => {}
-                    BlockEvent::Error(e) if matches!(e, BlockFetchError::BlockMismatch) => {
+                    BlockEvent::Error(BlockFetchError::BlockMismatch) => {
                         let mut checkpoint_in_chain = None;
                         let best_chain = match source
                             .get_best_chain(Some(wallet_tip.height), network.fallback_network())
@@ -1047,21 +1030,22 @@ impl RpcWallet {
                 continue;
             }
 
-            if synced_at_least_once && last_mempool_check.elapsed() > MEMPOOL_CHECK_INTERVAL {
-                if let Some(common_tip) = Self::all_synced(&source, &mut chain, &wallet, None) {
-                    let mem = MempoolChecker(&source);
-                    match wallet.update_unconfirmed_bids(mem, common_tip.height, &mut chain) {
-                        Ok(txids) => {
-                            for txid in txids {
-                                info!("Dropped {} - no longer in the mempool", txid);
-                            }
-                        }
-                        Err(err) => {
-                            warn!("Could not check for unconfirmed bids in mempool: {}", err)
+            if synced_at_least_once
+                && last_mempool_check.elapsed() > MEMPOOL_CHECK_INTERVAL
+                && let Some(common_tip) = Self::all_synced(&source, &mut chain, &wallet, None)
+            {
+                let mem = MempoolChecker(&source);
+                match wallet.update_unconfirmed_bids(mem, common_tip.height, &mut chain) {
+                    Ok(txids) => {
+                        for txid in txids {
+                            info!("Dropped {} - no longer in the mempool", txid);
                         }
                     }
-                    last_mempool_check = Instant::now();
+                    Err(err) => {
+                        warn!("Could not check for unconfirmed bids in mempool: {}", err)
+                    }
                 }
+                last_mempool_check = Instant::now();
             }
 
             std::thread::sleep(Duration::from_millis(10));
@@ -1089,14 +1073,19 @@ impl RpcWallet {
         Ok(ListNumsResponse { nums })
     }
 
-    fn list_external_nums(wallet: &mut SpacesWallet, chain: &mut Chain) -> anyhow::Result<ListNumsResponse> {
+    fn list_external_nums(
+        wallet: &mut SpacesWallet,
+        chain: &mut Chain,
+    ) -> anyhow::Result<ListNumsResponse> {
         use spaces_wallet::tx_event::CreateNumEventDetails;
 
         let mut nums: Vec<NumEntry> = Vec::new();
         let mut seen = std::collections::HashSet::new();
 
         for event in wallet.list_create_num_events()? {
-            let Some(details) = event.details else { continue };
+            let Some(details) = event.details else {
+                continue;
+            };
             let Ok(create) = serde_json::from_value::<CreateNumEventDetails>(details) else {
                 continue;
             };
@@ -1239,7 +1228,7 @@ impl RpcWallet {
                     ChainPosition::Unconfirmed { .. } => None,
                 };
                 let tx = ctx.tx_node.tx.clone();
-                let txid = ctx.tx_node.txid.clone();
+                let txid = ctx.tx_node.txid;
                 let (sent, received) = wallet.sent_and_received(&tx);
                 let fee = wallet.calculate_fee(&tx).ok();
                 TxInfo {
@@ -1259,9 +1248,8 @@ impl RpcWallet {
                 let conn = wallet.connection.transaction()?;
                 let mut events = TxEvent::all(&conn, tx.txid).expect("tx event");
                 for event in events.iter_mut() {
-                    match event.kind {
-                        TxEventKind::Commit => event.details = None,
-                        _ => {}
+                    if event.kind == TxEventKind::Commit {
+                        event.details = None;
                     }
                 }
                 events
@@ -1337,15 +1325,15 @@ impl RpcWallet {
     ) -> anyhow::Result<WalletResponse> {
         let tip_height = wallet.local_chain().tip().height();
 
-        if let Some(dust) = tx.dust {
-            if dust > SpacesAwareCoinSelection::DUST_THRESHOLD {
-                // Allowing higher dust may space outs to be accidentally
-                // spent during coin selection
-                return Err(anyhow!(
-                    "dust cannot be higher than {}",
-                    SpacesAwareCoinSelection::DUST_THRESHOLD
-                ));
-            }
+        if let Some(dust) = tx.dust
+            && dust > SpacesAwareCoinSelection::DUST_THRESHOLD
+        {
+            // Allowing higher dust may space outs to be accidentally
+            // spent during coin selection
+            return Err(anyhow!(
+                "dust cannot be higher than {}",
+                SpacesAwareCoinSelection::DUST_THRESHOLD
+            ));
         }
 
         let fee_rate = match tx.fee_rate.as_ref() {
@@ -1353,15 +1341,15 @@ impl RpcWallet {
                 None => return Err(anyhow!("could not estimate fee rate")),
                 Some(r) => r,
             },
-            Some(r) => r.clone(),
+            Some(r) => *r,
         };
         info!("Using fee rate: {} sat/vB", fee_rate.to_sat_per_vb_ceil());
 
         let mut builder = spaces_wallet::builder::Builder::new();
         builder = builder.fee_rate(fee_rate);
 
-        if tx.bidouts.is_some() {
-            builder = builder.bidouts(tx.bidouts.unwrap());
+        if let Some(bidouts) = tx.bidouts {
+            builder = builder.bidouts(bidouts);
         }
 
         builder = builder.force(tx.force);
@@ -1382,8 +1370,8 @@ impl RpcWallet {
                 RpcWalletRequest::Transfer(params) => {
                     let secret: Option<[u8; 32]> = match &params.secret {
                         Some(hex) => {
-                            let bytes = hex::decode(hex)
-                                .map_err(|_| anyhow!("invalid hex secret key"))?;
+                            let bytes =
+                                hex::decode(hex).map_err(|_| anyhow!("invalid hex secret key"))?;
                             if bytes.len() != 32 {
                                 return Err(anyhow!("secret key must be 32 bytes"));
                             }
@@ -1407,15 +1395,32 @@ impl RpcWallet {
                         match item {
                             Subject::NumId(id) => {
                                 let num = match chain.get_num_info(id)? {
-                                    None => return Err(anyhow!("transfer: num '{}' not found", id)),
-                                    Some(full) if secret.is_none() && !wallet.is_mine(full.numout.script_pubkey.clone()) => {
-                                        return Err(anyhow!("transfer: you don't own num '{}'", id))
+                                    None => {
+                                        return Err(anyhow!("transfer: num '{}' not found", id));
+                                    }
+                                    Some(full)
+                                        if secret.is_none()
+                                            && !wallet
+                                                .is_mine(full.numout.script_pubkey.clone()) =>
+                                    {
+                                        return Err(anyhow!(
+                                            "transfer: you don't own num '{}'",
+                                            id
+                                        ));
                                     }
-                                    Some(full) if secret.is_none() && wallet.get_utxo(OutPoint::new(full.txid, full.numout.n as u32)).is_none() => {
+                                    Some(full)
+                                        if secret.is_none()
+                                            && wallet
+                                                .get_utxo(OutPoint::new(
+                                                    full.txid,
+                                                    full.numout.n as u32,
+                                                ))
+                                                .is_none() =>
+                                    {
                                         return Err(anyhow!(
                                             "transfer '{}': wallet already has a pending tx for this num",
                                             id
-                                        ))
+                                        ));
                                     }
                                     Some(full) => full,
                                 };
@@ -1438,15 +1443,32 @@ impl RpcWallet {
                                     anyhow!("transfer: numeric '{}' not found", numeric)
                                 })?;
                                 let num = match chain.get_num_info(&id)? {
-                                    None => return Err(anyhow!("transfer: num '{}' not found", id)),
-                                    Some(full) if secret.is_none() && !wallet.is_mine(full.numout.script_pubkey.clone()) => {
-                                        return Err(anyhow!("transfer: you don't own num '{}'", id))
+                                    None => {
+                                        return Err(anyhow!("transfer: num '{}' not found", id));
                                     }
-                                    Some(full) if secret.is_none() && wallet.get_utxo(OutPoint::new(full.txid, full.numout.n as u32)).is_none() => {
+                                    Some(full)
+                                        if secret.is_none()
+                                            && !wallet
+                                                .is_mine(full.numout.script_pubkey.clone()) =>
+                                    {
+                                        return Err(anyhow!(
+                                            "transfer: you don't own num '{}'",
+                                            id
+                                        ));
+                                    }
+                                    Some(full)
+                                        if secret.is_none()
+                                            && wallet
+                                                .get_utxo(OutPoint::new(
+                                                    full.txid,
+                                                    full.numout.n as u32,
+                                                ))
+                                                .is_none() =>
+                                    {
                                         return Err(anyhow!(
                                             "transfer '{}': wallet already has a pending tx for this num",
                                             id
-                                        ))
+                                        ));
                                     }
                                     Some(full) => full,
                                 };
@@ -1468,7 +1490,7 @@ impl RpcWallet {
                                 let spacehash = SpaceKey::from(Sha256::hash(space.as_ref()));
                                 match chain.get_space_info(&spacehash)? {
                                     None => {
-                                        return Err(anyhow!("transfer: you don't own `{}`", space))
+                                        return Err(anyhow!("transfer: you don't own `{}`", space));
                                     }
                                     Some(full)
                                         if full.spaceout.space.is_none()
@@ -1538,17 +1560,13 @@ impl RpcWallet {
                         // Warn if already exists
                         let spacehash = SpaceKey::from(Sha256::hash(name.as_ref()));
                         let full = chain.get_space_info(&spacehash)?;
-                        if let Some(full) = full {
-                            if !full
+                        if let Some(full) = full
+                            && !full
                                 .spaceout
                                 .space
                                 .is_some_and(|s| s.is_expired(tip_height))
-                            {
-                                return Err(anyhow!(
-                                    "open '{}': space already exists",
-                                    params.name
-                                ));
-                            }
+                        {
+                            return Err(anyhow!("open '{}': space already exists", params.name));
                         }
                     }
 
@@ -1651,15 +1669,15 @@ impl RpcWallet {
                     match &params.subject {
                         Subject::Label(label) if label.is_numeric() => {
                             let numeric: SNumeric = label.clone().try_into().unwrap();
-                            let id = chain.get_num_id(&numeric)?.ok_or_else(|| {
-                                anyhow!("operate: numeric '{}' not found", label)
-                            })?;
+                            let id = chain
+                                .get_num_id(&numeric)?
+                                .ok_or_else(|| anyhow!("operate: numeric '{}' not found", label))?;
                             let num = match chain.get_num_info(&id)? {
                                 None => return Err(anyhow!("operate: num '{}' not found", id)),
                                 Some(full)
                                     if !wallet.is_mine(full.numout.script_pubkey.clone()) =>
                                 {
-                                    return Err(anyhow!("operate: you don't own '{}'", label))
+                                    return Err(anyhow!("operate: you don't own '{}'", label));
                                 }
                                 Some(full)
                                     if wallet
@@ -1669,7 +1687,7 @@ impl RpcWallet {
                                     return Err(anyhow!(
                                         "operate '{}': wallet already has a pending tx",
                                         label
-                                    ))
+                                    ));
                                 }
                                 Some(full) => full,
                             };
@@ -1684,7 +1702,7 @@ impl RpcWallet {
                                 Some(full)
                                     if !wallet.is_mine(full.numout.script_pubkey.clone()) =>
                                 {
-                                    return Err(anyhow!("operate: you don't own '{}'", id))
+                                    return Err(anyhow!("operate: you don't own '{}'", id));
                                 }
                                 Some(full)
                                     if wallet
@@ -1694,7 +1712,7 @@ impl RpcWallet {
                                     return Err(anyhow!(
                                         "operate '{}': wallet already has a pending tx",
                                         id
-                                    ))
+                                    ));
                                 }
                                 Some(full) => full,
                             };
@@ -1708,20 +1726,20 @@ impl RpcWallet {
 
                             let full = match chain.get_space_info(&spacehash)? {
                                 None => {
-                                    return Err(anyhow!("operate: space '{}' not found", label))
+                                    return Err(anyhow!("operate: space '{}' not found", label));
                                 }
                                 Some(full)
                                     if full.spaceout.space.is_none()
                                         || !full.spaceout.space.as_ref().unwrap().is_owned()
                                         || !wallet.is_mine(full.spaceout.script_pubkey.clone()) =>
                                 {
-                                    return Err(anyhow!("operate: you don't own '{}'", label))
+                                    return Err(anyhow!("operate: you don't own '{}'", label));
                                 }
                                 Some(full) if wallet.get_utxo(full.outpoint()).is_none() => {
                                     return Err(anyhow!(
                                         "operate '{}': wallet already has a pending tx",
                                         label
-                                    ))
+                                    ));
                                 }
                                 Some(full) => full,
                             };
@@ -1778,24 +1796,24 @@ impl RpcWallet {
                             .add_data(params.data);
                     }
                     _ => {
-                        let id = resolve_subject_to_num_id::<Sha256>(chain, &params.subject)?;
+                        let id = resolve_subject_to_num_id(chain, &params.subject)?;
                         let num_info = match chain.get_num_info(&id)? {
-                                None => return Err(anyhow!("setfallback: num '{}' not found", id)),
-                                Some(num) if !wallet.is_mine(num.numout.script_pubkey.clone()) => {
-                                    return Err(anyhow!("setfallback: you don't own '{}'", id))
-                                }
-                                Some(num)
-                                    if wallet
-                                        .get_utxo(OutPoint::new(num.txid, num.numout.n as u32))
-                                        .is_none() =>
-                                {
-                                    return Err(anyhow!(
-                                        "setfallback '{}': wallet already has a pending tx for this num",
-                                        id
-                                    ))
-                                }
-                                Some(num) => num,
-                            };
+                            None => return Err(anyhow!("setfallback: num '{}' not found", id)),
+                            Some(num) if !wallet.is_mine(num.numout.script_pubkey.clone()) => {
+                                return Err(anyhow!("setfallback: you don't own '{}'", id));
+                            }
+                            Some(num)
+                                if wallet
+                                    .get_utxo(OutPoint::new(num.txid, num.numout.n as u32))
+                                    .is_none() =>
+                            {
+                                return Err(anyhow!(
+                                    "setfallback '{}': wallet already has a pending tx for this num",
+                                    id
+                                ));
+                            }
+                            Some(num) => num,
+                        };
                         let recipient = SpaceAddress(
                             Address::from_script(
                                 num_info.numout.script_pubkey.as_script(),
@@ -2104,7 +2122,9 @@ impl RpcWallet {
 
     pub async fn send_list_nums(&self, external: bool) -> anyhow::Result<ListNumsResponse> {
         let (resp, resp_rx) = oneshot::channel();
-        self.sender.send(WalletCommand::ListPtrs { external, resp }).await?;
+        self.sender
+            .send(WalletCommand::ListPtrs { external, resp })
+            .await?;
         resp_rx.await?
     }
 
@@ -2207,18 +2227,14 @@ fn advance_address_to_unique_num_spk(
     }
 }
 
-
 fn find_delegate_utxo(chain: &mut Chain, subject: &Subject) -> anyhow::Result<FullNumOut> {
     let num_id = match &subject {
-        Subject::NumId(id) => Some(id.clone()),
+        Subject::NumId(id) => Some(*id),
         Subject::Label(label) if label.is_numeric() => {
-            let numeric: SNumeric = label
-                .clone()
-                .try_into()
-                .expect("valid numeric");
-            let id = chain.get_num_id(&numeric)?.ok_or_else(|| {
-                anyhow!("delegate: numeric '{}' not found", label)
-            })?;
+            let numeric: SNumeric = label.clone().try_into().expect("valid numeric");
+            let id = chain
+                .get_num_id(&numeric)?
+                .ok_or_else(|| anyhow!("delegate: numeric '{}' not found", label))?;
             Some(id)
         }
         Subject::Label(_) => None,
@@ -2231,28 +2247,39 @@ fn find_delegate_utxo(chain: &mut Chain, subject: &Subject) -> anyhow::Result<Fu
 
         let target = NumId::from_spk::<Sha256>(num_utxo.numout.script_pubkey);
         if target == num_id {
-            return Err(anyhow!("delegate: num has no separate operator - call operate first"))
+            return Err(anyhow!(
+                "delegate: num has no separate operator - call operate first"
+            ));
         }
 
         let dk = DelegatorKey::from_id::<Sha256>(target);
         let Some(delegator) = chain.get_delegator(&dk)? else {
-            return Err(anyhow!("delegate: num {} is not operated - call operate first", subject));
+            return Err(anyhow!(
+                "delegate: num {} is not operated - call operate first",
+                subject
+            ));
         };
         if !delegator.is_numeric() {
-            return Err(anyhow!("delegate: num {} is delegated to {} - call operate to switch",
-                subject, delegator));
+            return Err(anyhow!(
+                "delegate: num {} is delegated to {} - call operate to switch",
+                subject,
+                delegator
+            ));
         }
-        let numeric : SNumeric = delegator.clone().try_into().expect("valid numeric");
+        let numeric: SNumeric = delegator.clone().try_into().expect("valid numeric");
 
         if numeric != num_utxo.numout.num.name {
-            return Err(anyhow!("delegate: num {} is delegated to {} - call operate to switch",
-                subject, delegator));
+            return Err(anyhow!(
+                "delegate: num {} is delegated to {} - call operate to switch",
+                subject,
+                delegator
+            ));
         }
 
         target
     } else {
         let Subject::Label(label) = subject else {
-            return Err(anyhow!("delegate: expected a space, got {}", subject))
+            return Err(anyhow!("delegate: expected a space, got {}", subject));
         };
 
         let space_utxo = chain
@@ -2265,20 +2292,28 @@ fn find_delegate_utxo(chain: &mut Chain, subject: &Subject) -> anyhow::Result<Fu
         let target = NumId::from_spk::<Sha256>(space_utxo.spaceout.script_pubkey);
         let dk = DelegatorKey::from_id::<Sha256>(target);
         let Some(delegator) = chain.get_delegator(&dk)? else {
-            return Err(anyhow!("delegate: space {} is not operated - call operate first", subject));
+            return Err(anyhow!(
+                "delegate: space {} is not operated - call operate first",
+                subject
+            ));
         };
 
         if delegator != space.name {
-            return Err(anyhow!("delegate: num {} is delegated to {} - call operate to switch",
-            target, delegator)
-            );
+            return Err(anyhow!(
+                "delegate: num {} is delegated to {} - call operate to switch",
+                target,
+                delegator
+            ));
         }
 
         target
     };
 
     let Some(num_utxo) = chain.get_num_info(&target)? else {
-        return Err(anyhow!("delegate: target '{}' not found - call operate first", target));
+        return Err(anyhow!(
+            "delegate: target '{}' not found - call operate first",
+            target
+        ));
     };
 
     Ok(num_utxo)
diff --git a/client/tests/fetcher_tests.rs b/client/tests/fetcher_tests.rs
index ceefa7a..df8f048 100644
--- a/client/tests/fetcher_tests.rs
+++ b/client/tests/fetcher_tests.rs
@@ -7,8 +7,8 @@ use anyhow::Result;
 use spaces_client::source::{
     BitcoinBlockSource, BitcoinRpc, BitcoinRpcAuth, BlockEvent, BlockFetcher,
 };
-use spaces_protocol::{bitcoin::BlockHash, constants::ChainAnchor};
 use spaces_protocol::bitcoin::Network;
+use spaces_protocol::{bitcoin::BlockHash, constants::ChainAnchor};
 use spaces_testutil::TestRig;
 
 async fn setup(blocks: u64) -> Result<(TestRig, u64, BlockHash)> {
@@ -28,7 +28,7 @@ fn test_block_fetching_from_bitcoin_rpc() -> Result<()> {
     let fetcher_rpc = BitcoinBlockSource::new(BitcoinRpc::new(
         &rig.bitcoind.rpc_url(),
         BitcoinRpcAuth::UserPass("user".to_string(), "password".to_string()),
-        true
+        true,
     ));
     let (fetcher, receiver) = BlockFetcher::new(Network::Regtest, fetcher_rpc.clone(), 8);
     fetcher.start(ChainAnchor { hash, height: 0 });
diff --git a/client/tests/integration_tests.rs b/client/tests/integration_tests.rs
index 7cfe71d..5d5172d 100644
--- a/client/tests/integration_tests.rs
+++ b/client/tests/integration_tests.rs
@@ -2,19 +2,19 @@ use std::{path::PathBuf, str::FromStr};
 
 use spaces_client::{
     rpc::{
-        BidParams, OpenParams, RegisterParams, RpcClient, RpcWalletRequest,
-        RpcWalletTxBuilder, Subject, TransferSpacesParams,
+        BidParams, OpenParams, RegisterParams, RpcClient, RpcWalletRequest, RpcWalletTxBuilder,
+        Subject, TransferSpacesParams,
     },
     store::chain::{CACHED_SNAPSHOT_LOOKBACK, COMMIT_BLOCK_INTERVAL},
     wallets::{AddressKind, WalletResponse},
 };
+use spaces_nums::ChainProofRequest;
 use spaces_protocol::{
+    Bytes, Covenant,
     bitcoin::{Amount, FeeRate},
     constants::RENEWAL_INTERVAL,
     slabel::SLabel,
-    Bytes, Covenant,
 };
-use spaces_nums::ChainProofRequest;
 use spaces_testutil::TestRig;
 use spaces_wallet::{export::WalletExport, tx_event::TxEventKind};
 
@@ -47,12 +47,21 @@ async fn it_should_open_a_space_for_auction(rig: &TestRig) -> anyhow::Result<()>
     }
     assert_eq!(response.result.len(), 2, "must be 2 transactions");
     let alices_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    assert!(alices_spaces.pending.first().is_some_and(|s| s.to_string() == TEST_SPACE), "must be a pending space");
+    assert!(
+        alices_spaces
+            .pending
+            .first()
+            .is_some_and(|s| s.to_string() == TEST_SPACE),
+        "must be a pending space"
+    );
 
     rig.mine_blocks(1, None).await?;
     rig.wait_until_synced().await?;
     let alices_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    assert!(alices_spaces.pending.is_empty(), "must have no pending spaces");
+    assert!(
+        alices_spaces.pending.is_empty(),
+        "must have no pending spaces"
+    );
 
     let fullspaceout = rig.spaced.client.get_space(TEST_SPACE).await?;
     let fullspaceout = fullspaceout.expect("a fullspace out");
@@ -104,7 +113,13 @@ async fn it_should_allow_outbidding(rig: &TestRig) -> anyhow::Result<()> {
     println!("{}", serde_json::to_string_pretty(&result).unwrap());
 
     let bob_spaces_updated = rig.spaced.client.wallet_list_spaces(BOB).await?;
-    assert!(bob_spaces_updated.pending.first().is_some_and(|s| s.to_string() == TEST_SPACE), "must be a pending space");
+    assert!(
+        bob_spaces_updated
+            .pending
+            .first()
+            .is_some_and(|s| s.to_string() == TEST_SPACE),
+        "must be a pending space"
+    );
 
     rig.mine_blocks(1, None).await?;
     rig.wait_until_synced().await?;
@@ -134,7 +149,10 @@ async fn it_should_allow_outbidding(rig: &TestRig) -> anyhow::Result<()> {
         alices_balance.balance + Amount::from_sat(TEST_INITIAL_BID + 662),
         "alice must be refunded this exact amount"
     );
-    assert!(bob_spaces_updated.pending.is_empty(), "must have no pending spaces");
+    assert!(
+        bob_spaces_updated.pending.is_empty(),
+        "must have no pending spaces"
+    );
 
     let fullspaceout = rig.spaced.client.get_space(TEST_SPACE).await?;
     let fullspaceout = fullspaceout.expect("a fullspace out");
@@ -175,8 +193,7 @@ async fn it_should_insert_txout_for_bids(rig: &TestRig) -> anyhow::Result<()> {
         .wallet_list_transactions(BOB, 10, 0)
         .await?
         .iter()
-        .filter(|tx| tx.events.iter().any(|event| event.kind == TxEventKind::Bid))
-        .next()
+        .find(|tx| tx.events.iter().any(|event| event.kind == TxEventKind::Bid))
         .expect("a bid")
         .clone();
 
@@ -390,7 +407,8 @@ async fn it_should_allow_batch_transfers_refreshing_expire_height(
     let result = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: registered_spaces.clone(),
             to: Some(space_address),
             data: None,
@@ -415,16 +433,13 @@ async fn it_should_allow_batch_transfers_refreshing_expire_height(
         "must be equal"
     );
 
-    let _ = all_spaces_2.owned.iter().for_each(|s| {
+    all_spaces_2.owned.iter().for_each(|s| {
         let space = s.spaceout.space.as_ref().expect("space");
-        match space.covenant {
-            Covenant::Transfer { expire_height, .. } => {
-                assert_eq!(
-                    expire_height, expected_expire_height,
-                    "must refresh expire height"
-                );
-            }
-            _ => {}
+        if let Covenant::Transfer { expire_height, .. } = space.covenant {
+            assert_eq!(
+                expire_height, expected_expire_height,
+                "must refresh expire height"
+            );
         }
     });
 
@@ -457,7 +472,8 @@ async fn it_should_allow_applying_script_in_batch(rig: &TestRig) -> anyhow::Resu
         ALICE,
         vec![
             // Transfer spaces to self with data (replaces Execute)
-            RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+            RpcWalletRequest::Transfer(TransferSpacesParams {
+                secret: None,
                 spaces: registered_spaces.clone(),
                 to: None, // None = renew to self
                 data: Some(vec![0xDE, 0xAD, 0xBE, 0xEF]),
@@ -490,23 +506,21 @@ async fn it_should_allow_applying_script_in_batch(rig: &TestRig) -> anyhow::Resu
 
     all_spaces_2.owned.iter().for_each(|s| {
         let space = s.spaceout.space.as_ref().expect("space");
-        match &space.covenant {
-            Covenant::Transfer {
-                expire_height,
-                data,
-            } => {
-                assert_eq!(
-                    *expire_height, expected_expire_height,
-                    "must refresh expire height"
-                );
-                assert!(data.is_some(), "must be data set");
-                assert_eq!(
-                    data.clone().unwrap().to_vec(),
-                    vec![0xDE, 0xAD, 0xBE, 0xEF],
-                    "must set correct data"
-                );
-            }
-            _ => {}
+        if let Covenant::Transfer {
+            expire_height,
+            data,
+        } = &space.covenant
+        {
+            assert_eq!(
+                *expire_height, expected_expire_height,
+                "must refresh expire height"
+            );
+            assert!(data.is_some(), "must be data set");
+            assert_eq!(
+                data.clone().unwrap().to_vec(),
+                vec![0xDE, 0xAD, 0xBE, 0xEF],
+                "must set correct data"
+            );
         }
     });
     Ok(())
@@ -868,7 +882,8 @@ async fn it_should_not_allow_register_or_transfer_to_same_space_multiple_times(
     let response = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(SLabel::from_str(&transfer).expect("valid"))],
             to: Some(bob_address.clone()),
             data: None,
@@ -886,7 +901,8 @@ async fn it_should_not_allow_register_or_transfer_to_same_space_multiple_times(
     wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(SLabel::from_str(&transfer).expect("valid"))],
             to: Some(bob_address),
             data: None,
@@ -900,7 +916,8 @@ async fn it_should_not_allow_register_or_transfer_to_same_space_multiple_times(
     let response = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(SLabel::from_str(&setdata).expect("valid"))],
             to: None,
             data: Some(vec![0xAA, 0xAA]),
@@ -917,7 +934,8 @@ async fn it_should_not_allow_register_or_transfer_to_same_space_multiple_times(
     wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(SLabel::from_str(&setdata).expect("valid"))],
             to: None,
             data: Some(vec![0xDE, 0xAD]),
@@ -968,8 +986,11 @@ async fn it_can_batch_txs(rig: &TestRig) -> anyhow::Result<()> {
         rig,
         ALICE,
         vec![
-            RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
-                spaces: vec![Subject::Label(SLabel::from_str("@test9996").expect("valid"))],
+            RpcWalletRequest::Transfer(TransferSpacesParams {
+                secret: None,
+                spaces: vec![Subject::Label(
+                    SLabel::from_str("@test9996").expect("valid"),
+                )],
                 to: Some(bob_address),
                 data: None,
             }),
@@ -986,7 +1007,8 @@ async fn it_can_batch_txs(rig: &TestRig) -> anyhow::Result<()> {
                 amount: 1000,
             }),
             // Transfer spaces to self with data (replaces Execute)
-            RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+            RpcWalletRequest::Transfer(TransferSpacesParams {
+                secret: None,
                 spaces: vec![
                     Subject::Label(SLabel::from_str("@test10000").expect("valid")),
                     Subject::Label(SLabel::from_str("@test9999").expect("valid")),
@@ -1023,15 +1045,11 @@ async fn it_can_batch_txs(rig: &TestRig) -> anyhow::Result<()> {
         .await
         .expect("bob spaces");
     assert!(
-        bob_spaces
-            .owned
-            .iter()
-            .find(|output| output
-                .spaceout
-                .space
-                .as_ref()
-                .is_some_and(|s| s.name.to_string() == "@test9996"))
-            .is_some(),
+        bob_spaces.owned.iter().any(|output| output
+            .spaceout
+            .space
+            .as_ref()
+            .is_some_and(|s| s.name.to_string() == "@test9996")),
         "expected bob to own the space name"
     );
 
@@ -1085,7 +1103,7 @@ async fn it_can_batch_txs(rig: &TestRig) -> anyhow::Result<()> {
         _ => panic!("must be a bid"),
     }
 
-    for space in vec![
+    for space in [
         "@test10000".to_string(),
         "@test9999".to_string(),
         "@test9998".to_string(),
@@ -1197,8 +1215,7 @@ async fn it_should_allow_buy_sell(rig: &TestRig) -> anyhow::Result<()> {
         bob_spaces
             .owned
             .iter()
-            .find(|s| s.spaceout.space.as_ref().unwrap().name.to_string() == space_name)
-            .is_some(),
+            .any(|s| s.spaceout.space.as_ref().unwrap().name.to_string() == space_name),
         "bob should own it now"
     );
 
@@ -1222,7 +1239,9 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
 
     // Get a space that Alice owns
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let owned_space = alice_spaces.owned.first()
+    let owned_space = alice_spaces
+        .owned
+        .first()
         .expect("Alice should own at least one space");
     let space = owned_space.spaceout.space.as_ref().expect("space");
     let space_name = space.name.to_string();
@@ -1232,8 +1251,14 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
 
     // Use debug RPC to set expire_height to current height (making it expired)
     let new_expire_height = current_height;
-    println!("Setting expire_height to {} to expire the space...", new_expire_height);
-    rig.spaced.client.debug_set_expire_height(&space_name, new_expire_height).await?;
+    println!(
+        "Setting expire_height to {} to expire the space...",
+        new_expire_height
+    );
+    rig.spaced
+        .client
+        .debug_set_expire_height(&space_name, new_expire_height)
+        .await?;
 
     // Mine one block to trigger expiration check
     rig.mine_blocks(1, None).await?;
@@ -1241,7 +1266,10 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
 
     let new_height = rig.get_block_count().await? as u32;
     println!("New height: {}, space should now be expired", new_height);
-    assert!(new_height > new_expire_height, "should have passed expire_height");
+    assert!(
+        new_height > new_expire_height,
+        "should have passed expire_height"
+    );
 
     // Test 1: Try to renew/transfer the expired space - should fail
     println!("Attempting to renew expired space (should fail)...");
@@ -1250,25 +1278,37 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
     let renew_result = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(
-                SLabel::from_str(&space_name).expect("valid")
+                SLabel::from_str(&space_name).expect("valid"),
             )],
             to: None, // renew to self
             data: None,
         })],
         false,
-    ).await;
+    )
+    .await;
 
     // The transfer should fail since the space is expired
-    assert!(renew_result.is_err() || renew_result.as_ref().unwrap().result.iter().any(|r| r.error.is_some()),
-        "renewing an expired space should fail");
+    assert!(
+        renew_result.is_err()
+            || renew_result
+                .as_ref()
+                .unwrap()
+                .result
+                .iter()
+                .any(|r| r.error.is_some()),
+        "renewing an expired space should fail"
+    );
     println!("✓ Renewing expired space correctly failed");
 
     // Verify the space is no longer in Alice's owned list (it was revoked)
     rig.wait_until_wallet_synced(ALICE).await?;
     let alice_spaces_after = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let _still_owns = alice_spaces_after.owned.iter()
+    let _still_owns = alice_spaces_after
+        .owned
+        .iter()
         .any(|s| s.spaceout.space.as_ref().unwrap().name.to_string() == space_name);
 
     // Test 2: Open the expired space for auction - should succeed
@@ -1281,11 +1321,16 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
             amount: 1000,
         })],
         false,
-    ).await?;
+    )
+    .await?;
 
     // Check that the open succeeded
     let has_error = open_result.result.iter().any(|r| r.error.is_some());
-    assert!(!has_error, "opening an expired space should succeed: {:?}", open_result);
+    assert!(
+        !has_error,
+        "opening an expired space should succeed: {:?}",
+        open_result
+    );
     println!("✓ Opening expired space for auction succeeded");
 
     rig.mine_blocks(1, None).await?;
@@ -1294,18 +1339,22 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
     // Verify the space is now in auction (BOB's winning list)
     rig.wait_until_wallet_synced(BOB).await?;
     let bob_spaces = rig.spaced.client.wallet_list_spaces(BOB).await?;
-    let bob_winning = bob_spaces.winning.iter()
+    let bob_winning = bob_spaces
+        .winning
+        .iter()
         .any(|s| s.spaceout.space.as_ref().unwrap().name.to_string() == space_name);
     assert!(bob_winning, "BOB should be winning the reopened auction");
     println!("✓ Expired space is now back in auction");
-    
+
     // ========== Test Case 2: Expire second space, force renew, then open ==========
     println!("\n=== Test Case 2: Force renew expired space ===");
 
     // Get a second space that Alice owns
     rig.wait_until_wallet_synced(ALICE).await?;
     let alice_spaces_2 = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let owned_space_2 = alice_spaces_2.owned.get(1)
+    let owned_space_2 = alice_spaces_2
+        .owned
+        .get(1)
         .expect("Alice should own at least two spaces");
     let space_2 = owned_space_2.spaceout.space.as_ref().expect("space");
     let space_name_2 = space_2.name.to_string();
@@ -1314,8 +1363,14 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
 
     // Expire the second space
     let current_height_2 = rig.get_block_count().await? as u32;
-    rig.spaced.client.debug_set_expire_height(&space_name_2, current_height_2).await?;
-    println!("Set expire_height to {} for {}", current_height_2, space_name_2);
+    rig.spaced
+        .client
+        .debug_set_expire_height(&space_name_2, current_height_2)
+        .await?;
+    println!(
+        "Set expire_height to {} for {}",
+        current_height_2, space_name_2
+    );
 
     // Mine one block to pass the expire height
     rig.mine_blocks(1, None).await?;
@@ -1327,20 +1382,33 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
     let force_renew_result = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(
-                SLabel::from_str(&space_name_2).expect("valid")
+                SLabel::from_str(&space_name_2).expect("valid"),
             )],
             to: None,
             data: None,
         })],
         true, // force=true
-    ).await;
+    )
+    .await;
 
     // With force=true, the wallet should create the tx (even though it will be revoked on-chain)
-    assert!(force_renew_result.is_ok(), "force renew should allow tx creation: {:?}", force_renew_result);
+    assert!(
+        force_renew_result.is_ok(),
+        "force renew should allow tx creation: {:?}",
+        force_renew_result
+    );
     let force_result = force_renew_result.unwrap();
-    println!("Force renew result: {:?}", force_result.result.iter().map(|r| &r.error).collect::<Vec<_>>());
+    println!(
+        "Force renew result: {:?}",
+        force_result
+            .result
+            .iter()
+            .map(|r| &r.error)
+            .collect::<Vec<_>>()
+    );
 
     // Mine the block - the transfer will be revoked because the space is expired
     rig.mine_blocks(1, None).await?;
@@ -1349,9 +1417,14 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
 
     // The space should be revoked (not in Alice's owned list anymore)
     let alice_spaces_after_force = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let still_owns_2 = alice_spaces_after_force.owned.iter()
+    let still_owns_2 = alice_spaces_after_force
+        .owned
+        .iter()
         .any(|s| s.spaceout.space.as_ref().unwrap().name.to_string() == space_name_2);
-    assert!(!still_owns_2, "Space should be revoked after forced renewal of expired space");
+    assert!(
+        !still_owns_2,
+        "Space should be revoked after forced renewal of expired space"
+    );
     println!("✓ Space correctly revoked after forced renewal");
 
     // Now open the expired space for auction
@@ -1364,10 +1437,15 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
             amount: 1000,
         })],
         false,
-    ).await?;
+    )
+    .await?;
 
     let has_error_2 = open_result_2.result.iter().any(|r| r.error.is_some());
-    assert!(!has_error_2, "opening expired space should succeed: {:?}", open_result_2);
+    assert!(
+        !has_error_2,
+        "opening expired space should succeed: {:?}",
+        open_result_2
+    );
     println!("✓ Opening second expired space for auction succeeded");
 
     rig.mine_blocks(1, None).await?;
@@ -1376,9 +1454,14 @@ async fn it_should_handle_expired_spaces(rig: &TestRig) -> anyhow::Result<()> {
     // Verify BOB is winning the second auction too
     rig.wait_until_wallet_synced(BOB).await?;
     let bob_spaces_2 = rig.spaced.client.wallet_list_spaces(BOB).await?;
-    let bob_winning_2 = bob_spaces_2.winning.iter()
+    let bob_winning_2 = bob_spaces_2
+        .winning
+        .iter()
         .any(|s| s.spaceout.space.as_ref().unwrap().name.to_string() == space_name_2);
-    assert!(bob_winning_2, "BOB should be winning the second reopened auction");
+    assert!(
+        bob_winning_2,
+        "BOB should be winning the second reopened auction"
+    );
     println!("✓ Second expired space is now back in auction");
 
     Ok(())
@@ -1388,7 +1471,10 @@ async fn it_should_sign_and_verify_schnorr(rig: &TestRig) -> anyhow::Result<()>
     rig.wait_until_wallet_synced(BOB).await?;
 
     let spaces = rig.spaced.client.wallet_list_spaces(BOB).await?;
-    let space = spaces.owned.first().expect("bob should have at least 1 space");
+    let space = spaces
+        .owned
+        .first()
+        .expect("bob should have at least 1 space");
     let space_name = space.spaceout.space.as_ref().unwrap().name.to_string();
     let subject = Subject::Label(SLabel::from_str(&space_name).unwrap());
 
@@ -1424,24 +1510,29 @@ async fn it_should_build_chain_proof_with_snapshot_caching(rig: &TestRig) -> any
     // last_update = expire_height - RENEWAL_INTERVAL, so setting expire_height
     // to RENEWAL_INTERVAL + 1 makes last_update = 1 (very old)
     let old_expire_height = RENEWAL_INTERVAL + 1;
-    rig.spaced.client.debug_set_expire_height(&space_name, old_expire_height).await?;
+    rig.spaced
+        .client
+        .debug_set_expire_height(&space_name, old_expire_height)
+        .await?;
 
     // Mine to next commit boundary so the change is committed
     let tip = rig.get_block_count().await? as u32;
     let remaining = tip % COMMIT_BLOCK_INTERVAL;
     if remaining > 0 {
-        rig.mine_blocks((COMMIT_BLOCK_INTERVAL - remaining) as usize, None).await?;
+        rig.mine_blocks((COMMIT_BLOCK_INTERVAL - remaining) as usize, None)
+            .await?;
     }
     rig.wait_until_synced().await?;
 
     let tip = rig.get_block_count().await? as u32;
-    let cached_height = (tip - tip % COMMIT_BLOCK_INTERVAL)
-        .saturating_sub(CACHED_SNAPSHOT_LOOKBACK);
+    let cached_height =
+        (tip - tip % COMMIT_BLOCK_INTERVAL).saturating_sub(CACHED_SNAPSHOT_LOOKBACK);
     let last_update = old_expire_height.saturating_sub(RENEWAL_INTERVAL);
     assert!(
         last_update <= cached_height,
         "last_update ({}) should be <= cached_height ({})",
-        last_update, cached_height
+        last_update,
+        cached_height
     );
 
     // Prove the space - last_update=1 <= cached_height, should use cached snapshot
@@ -1466,13 +1557,17 @@ async fn it_should_build_chain_proof_with_snapshot_caching(rig: &TestRig) -> any
 
     // Now set expire_height so last_update is recent (above cached_height)
     let recent_expire_height = tip + RENEWAL_INTERVAL;
-    rig.spaced.client.debug_set_expire_height(&space_name, recent_expire_height).await?;
+    rig.spaced
+        .client
+        .debug_set_expire_height(&space_name, recent_expire_height)
+        .await?;
 
     // Mine to next commit boundary
     let tip2 = rig.get_block_count().await? as u32;
     let remaining = tip2 % COMMIT_BLOCK_INTERVAL;
     if remaining > 0 {
-        rig.mine_blocks((COMMIT_BLOCK_INTERVAL - remaining) as usize, None).await?;
+        rig.mine_blocks((COMMIT_BLOCK_INTERVAL - remaining) as usize, None)
+            .await?;
     }
     rig.wait_until_synced().await?;
 
@@ -1490,8 +1585,8 @@ async fn it_should_build_chain_proof_with_snapshot_caching(rig: &TestRig) -> any
         .await?;
 
     let tip3 = rig.get_block_count().await? as u32;
-    let cached_height2 = (tip3 - tip3 % COMMIT_BLOCK_INTERVAL)
-        .saturating_sub(CACHED_SNAPSHOT_LOOKBACK);
+    let cached_height2 =
+        (tip3 - tip3 % COMMIT_BLOCK_INTERVAL).saturating_sub(CACHED_SNAPSHOT_LOOKBACK);
     assert!(!proof2.spaces_proof.is_empty(), "proof should not be empty");
     assert!(
         proof2.block.height > cached_height2,
@@ -1578,7 +1673,6 @@ async fn run_auction_tests() -> anyhow::Result<()> {
         .await
         .expect("should handle reorgs wallet");
 
-
     Ok(())
 }
 
diff --git a/client/tests/ptr_tests.rs b/client/tests/ptr_tests.rs
index 6cda94f..67ae492 100644
--- a/client/tests/ptr_tests.rs
+++ b/client/tests/ptr_tests.rs
@@ -1,20 +1,19 @@
-use std::{path::PathBuf, str::FromStr};
 use anyhow::anyhow;
+use spaces_client::rpc::{
+    CommitParams, CreateNumParams, OperateParams, SetFallbackParams, Subject, TransferSpacesParams,
+};
+use spaces_client::store::Sha256;
 use spaces_client::{
-    rpc::{
-        RpcClient, RpcWalletRequest,
-        RpcWalletTxBuilder,
-    },
+    rpc::{RpcClient, RpcWalletRequest, RpcWalletTxBuilder},
     wallets::{AddressKind, WalletResponse},
 };
-use spaces_client::rpc::{CommitParams, CreateNumParams, OperateParams, SetFallbackParams, Subject, TransferSpacesParams};
-use spaces_client::store::Sha256;
-use spaces_protocol::{bitcoin, bitcoin::{FeeRate}};
-use spaces_protocol::bitcoin::hashes::{sha256, Hash};
 use spaces_nums::num_id::NumId;
+use spaces_protocol::bitcoin::hashes::{Hash, sha256};
+use spaces_protocol::{bitcoin, bitcoin::FeeRate};
 use spaces_testutil::TestRig;
-use spaces_wallet::{export::WalletExport};
 use spaces_wallet::address::SpaceAddress;
+use spaces_wallet::export::WalletExport;
+use std::{path::PathBuf, str::FromStr};
 
 const ALICE: &str = "wallet_99";
 const BOB: &str = "wallet_98";
@@ -25,7 +24,8 @@ const EVE: &str = "wallet_93";
 fn wallet_res_err(res: &WalletResponse) -> anyhow::Result<()> {
     for tx in &res.result {
         if let Some(e) = tx.error.as_ref() {
-            let s = e.iter()
+            let s = e
+                .iter()
                 .map(|(k, v)| format!("{k}:{v}"))
                 .collect::<Vec<_>>()
                 .join(", ");
@@ -86,17 +86,29 @@ async fn it_should_create_nums(rig: &TestRig) -> anyhow::Result<()> {
     rig.wait_until_wallet_synced(ALICE).await?;
 
     // Create ptr bound to addr0
-    let addr0 = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
+    let addr0 = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Coin)
+        .await?;
     let addr0_spk = bitcoin::address::Address::from_str(&addr0)
-        .expect("valid").assume_checked()
+        .expect("valid")
+        .assume_checked()
         .script_pubkey();
     let create0 = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: Some(addr0_spk.clone()) })],
+        vec![RpcWalletRequest::CreateNum(CreateNumParams {
+            bind_spk: Some(addr0_spk.clone()),
+        })],
         false,
-    ).await.expect("CreatePtr addr0");
-    assert!(wallet_res_err(&create0).is_ok(), "CreatePtr(addr0) must not error");
+    )
+    .await
+    .expect("CreatePtr addr0");
+    assert!(
+        wallet_res_err(&create0).is_ok(),
+        "CreatePtr(addr0) must not error"
+    );
 
     mine_and_sync(rig, 1).await?;
 
@@ -106,22 +118,33 @@ async fn it_should_create_nums(rig: &TestRig) -> anyhow::Result<()> {
         .script_pubkey();
     let id0 = NumId::from_spk::<Sha256>(spk0.clone());
 
-    let ptr0 = rig.spaced.client.get_num(Subject::NumId(id0)).await?
+    let ptr0 = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id0))
+        .await?
         .expect("ptr must exist after first CreatePtr");
     let bound_spk_before = ptr0.numout.script_pubkey.clone();
 
     // Transfer ptr to addr1 (binding should change)
-    let addr1 = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
+    let addr1 = rig
+        .spaced
+        .client
+        .wallet_get_new_address(BOB, AddressKind::Space)
+        .await?;
     let xfer = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::NumId(id0)],
             to: Some(addr1.clone()),
             data: None,
         })],
         false,
-    ).await.expect("Transfer PTR to addr1");
+    )
+    .await
+    .expect("Transfer PTR to addr1");
     assert!(wallet_res_err(&xfer).is_ok(), "Transfer PTR must not error");
 
     mine_and_sync(rig, 1).await?;
@@ -130,25 +153,46 @@ async fn it_should_create_nums(rig: &TestRig) -> anyhow::Result<()> {
         .expect("valid addr1")
         .script_pubkey();
 
-    let ptr_after_xfer = rig.spaced.client.get_num(Subject::NumId(id0)).await?
+    let ptr_after_xfer = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id0))
+        .await?
         .expect("ptr must still resolve after transfer");
     let bound_spk_after = ptr_after_xfer.numout.script_pubkey.clone();
 
-    assert_ne!(bound_spk_before, bound_spk_after, "binding must change after transfer");
-    assert_eq!(bound_spk_after, spk1, "binding must equal new destination spk");
+    assert_ne!(
+        bound_spk_before, bound_spk_after,
+        "binding must change after transfer"
+    );
+    assert_eq!(
+        bound_spk_after, spk1,
+        "binding must equal new destination spk"
+    );
 
     // Duplicate CreatePtr on ORIGINAL addr0 → should be ignored
     let dup = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: Some(addr0_spk.clone()) })],
+        vec![RpcWalletRequest::CreateNum(CreateNumParams {
+            bind_spk: Some(addr0_spk.clone()),
+        })],
         true,
-    ).await.expect("duplicate CreatePtr(addr0)");
-    assert!(wallet_res_err(&dup).is_ok(), "duplicate CreatePtr should not error");
+    )
+    .await
+    .expect("duplicate CreatePtr(addr0)");
+    assert!(
+        wallet_res_err(&dup).is_ok(),
+        "duplicate CreatePtr should not error"
+    );
 
     mine_and_sync(rig, 1).await?;
 
-    let ptr_after_dup = rig.spaced.client.get_num(Subject::NumId(id0)).await?
+    let ptr_after_dup = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id0))
+        .await?
         .expect("ptr must still resolve after duplicate");
     let bound_spk_final = ptr_after_dup.numout.script_pubkey.clone();
 
@@ -165,10 +209,18 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
 
     // Get a space that Alice owns
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let owned = alice_spaces.owned.first().cloned()
+    let owned = alice_spaces
+        .owned
+        .first()
+        .cloned()
         .expect("Alice should own at least one space");
-    let space_name = owned.spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
+    let space_name = owned
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
 
     // Setup: Delegate the space to establish Num Id
     let delegate = wallet_do(
@@ -178,12 +230,16 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
             subject: space_name.clone().into(),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&delegate).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify delegation is set up
-    rig.spaced.client.get_delegation(space_name.clone().into()).await?
+    rig.spaced
+        .client
+        .get_delegation(space_name.clone().into())
+        .await?
         .expect("delegation should be established");
 
     // Test 1: Make initial commitment [1u8;32]
@@ -193,16 +249,21 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
         ALICE,
         vec![RpcWalletRequest::Commit(CommitParams {
             subject: space_name.clone().into(),
-            root: Some(sha256::Hash::from_slice(&[1u8;32]).expect("valid")),
+            root: Some(sha256::Hash::from_slice(&[1u8; 32]).expect("valid")),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&commit1).is_ok());
     mine_and_sync(rig, 1).await?;
 
-    let tip = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+    let tip = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?
         .expect("commitment should exist");
-    assert_eq!(tip.state_root, [1u8;32]);
+    assert_eq!(tip.state_root, [1u8; 32]);
     assert_eq!(tip.prev_root, None);
 
     // Test 2: Rollback pending commitment
@@ -215,11 +276,16 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
             root: None, // None = rollback
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&rollback).is_ok());
     mine_and_sync(rig, 1).await?;
 
-    let tip_after_rollback = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?;
+    let tip_after_rollback = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?;
     assert_eq!(tip_after_rollback, None, "commitment should be rolled back");
 
     // Test 3: Create new commitment and finalize it
@@ -229,10 +295,11 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
         ALICE,
         vec![RpcWalletRequest::Commit(CommitParams {
             subject: space_name.clone().into(),
-            root: Some(sha256::Hash::from_slice(&[2u8;32]).expect("valid")),
+            root: Some(sha256::Hash::from_slice(&[2u8; 32]).expect("valid")),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&commit2).is_ok());
     mine_and_sync(rig, 1).await?;
 
@@ -250,14 +317,21 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
             root: None, // Rollback attempt
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&rollback_finalized).is_ok());
     mine_and_sync(rig, 1).await?;
 
-    let tip_after_failed_rollback = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+    let tip_after_failed_rollback = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?
         .expect("finalized commitment should still exist");
-    assert_eq!(tip_after_failed_rollback.state_root, [2u8;32],
-               "finalized commitment should not be rolled back");
+    assert_eq!(
+        tip_after_failed_rollback.state_root, [2u8; 32],
+        "finalized commitment should not be rolled back"
+    );
 
     // Test 5: Add new commitment on top of finalized
     println!("Adding [3u8;32] on top of finalized [2u8;32]...");
@@ -266,24 +340,34 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
         ALICE,
         vec![RpcWalletRequest::Commit(CommitParams {
             subject: space_name.clone().into(),
-            root: Some(sha256::Hash::from_slice(&[3u8;32]).expect("valid")),
+            root: Some(sha256::Hash::from_slice(&[3u8; 32]).expect("valid")),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&commit3).is_ok());
     mine_and_sync(rig, 1).await?;
 
-    let tip_final = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+    let tip_final = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?
         .expect("new commitment should exist");
-    assert_eq!(tip_final.state_root, [3u8;32]);
-    assert_eq!(tip_final.prev_root, Some([2u8;32]));
+    assert_eq!(tip_final.state_root, [3u8; 32]);
+    assert_eq!(tip_final.prev_root, Some([2u8; 32]));
 
     // Verify finalized [2u8;32] still exists
-    let finalized = rig.spaced.client.get_commitment(
-        space_name.clone().into(),
-        Some(sha256::Hash::from_slice(&[2u8;32]).expect("valid"))
-    ).await?.expect("finalized commitment should be preserved");
-    assert_eq!(finalized.state_root, [2u8;32]);
+    let finalized = rig
+        .spaced
+        .client
+        .get_commitment(
+            space_name.clone().into(),
+            Some(sha256::Hash::from_slice(&[2u8; 32]).expect("valid")),
+        )
+        .await?
+        .expect("finalized commitment should be preserved");
+    assert_eq!(finalized.state_root, [2u8; 32]);
 
     // Test 6: Rollback pending [3u8;32] and verify registry points back to [2u8;32]
     println!("Rolling back pending [3u8;32]...");
@@ -295,14 +379,21 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
             root: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&rollback3).is_ok());
     mine_and_sync(rig, 1).await?;
 
-    let tip_after_rollback = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+    let tip_after_rollback = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?
         .expect("should still have finalized commitment after rollback");
-    assert_eq!(tip_after_rollback.state_root, [2u8;32],
-        "registry should point back to finalized [2u8;32] after rolling back pending");
+    assert_eq!(
+        tip_after_rollback.state_root, [2u8; 32],
+        "registry should point back to finalized [2u8;32] after rolling back pending"
+    );
     println!("✓ Registry correctly updated to [2u8;32] after rollback");
 
     Ok(())
@@ -315,12 +406,25 @@ async fn it_should_handle_multiple_commitments(rig: &TestRig) -> anyhow::Result<
 
     // Get two spaces that Alice owns
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    assert!(alice_spaces.owned.len() >= 2, "Alice needs at least 2 spaces for this test");
+    assert!(
+        alice_spaces.owned.len() >= 2,
+        "Alice needs at least 2 spaces for this test"
+    );
 
-    let space1_name = alice_spaces.owned[0].spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
-    let space2_name = alice_spaces.owned[1].spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
+    let space1_name = alice_spaces.owned[0]
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
+    let space2_name = alice_spaces.owned[1]
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
 
     // Setup: Delegate both spaces to establish Num Ids
     for space_name in [&space1_name, &space2_name] {
@@ -331,29 +435,53 @@ async fn it_should_handle_multiple_commitments(rig: &TestRig) -> anyhow::Result<
                 subject: space_name.clone().into(),
             })],
             false,
-        ).await?;
+        )
+        .await?;
         assert!(wallet_res_err(&delegate).is_ok());
     }
     mine_and_sync(rig, 1).await?;
 
     // Verify both delegations exist
-    let id1 = rig.spaced.client.get_delegation(space1_name.clone().into()).await?
+    let id1 = rig
+        .spaced
+        .client
+        .get_delegation(space1_name.clone().into())
+        .await?
         .expect("space1 should have delegation");
-    let id2 = rig.spaced.client.get_delegation(space2_name.clone().into()).await?
+    let id2 = rig
+        .spaced
+        .client
+        .get_delegation(space2_name.clone().into())
+        .await?
         .expect("space2 should have delegation");
 
     println!("Space 1: {} -> Num Id: {}", space1_name, id1);
     println!("Space 2: {} -> Num Id: {}", space2_name, id2);
 
     // Verify delegations match delegator
-    let delegator1 = rig.spaced.client.get_delegator(Subject::NumId(id1)).await?
+    let delegator1 = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(id1))
+        .await?
         .expect("id1 delegator should exist");
-    let delegator2 = rig.spaced.client.get_delegator(Subject::NumId(id2)).await?
+    let delegator2 = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(id2))
+        .await?
         .expect("id2 delegator should exist");
 
-    assert_eq!(delegator1.to_string(), space1_name.to_string(), "space 1 delegators dont match");
-    assert_eq!(delegator2.to_string(), space2_name.to_string(), "space 2 delegators dont match");
-
+    assert_eq!(
+        delegator1.to_string(),
+        space1_name.to_string(),
+        "space 1 delegators dont match"
+    );
+    assert_eq!(
+        delegator2.to_string(),
+        space2_name.to_string(),
+        "space 2 delegators dont match"
+    );
 
     // Test 1: Submit two commitments in one transaction
     println!("Submitting 2 commitments in single transaction...");
@@ -363,27 +491,35 @@ async fn it_should_handle_multiple_commitments(rig: &TestRig) -> anyhow::Result<
         vec![
             RpcWalletRequest::Commit(CommitParams {
                 subject: space1_name.clone().into(),
-                root: Some(sha256::Hash::from_slice(&[10u8;32]).expect("valid")),
+                root: Some(sha256::Hash::from_slice(&[10u8; 32]).expect("valid")),
             }),
             RpcWalletRequest::Commit(CommitParams {
                 subject: space2_name.clone().into(),
-                root: Some(sha256::Hash::from_slice(&[20u8;32]).expect("valid")),
+                root: Some(sha256::Hash::from_slice(&[20u8; 32]).expect("valid")),
             }),
         ],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&multi_commit).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify both commitments were created
-    let commit2 = rig.spaced.client.get_commitment(space2_name.clone().into(), None).await?
+    let commit2 = rig
+        .spaced
+        .client
+        .get_commitment(space2_name.clone().into(), None)
+        .await?
         .expect("space2 should have commitment");
-    let commit1 = rig.spaced.client.get_commitment(space1_name.clone().into(), None).await?
+    let commit1 = rig
+        .spaced
+        .client
+        .get_commitment(space1_name.clone().into(), None)
+        .await?
         .expect("space1 should have commitment");
 
-
-    assert_eq!(commit1.state_root, [10u8;32], "space1 commitment");
-    assert_eq!(commit2.state_root, [20u8;32], "space2 commitment");
+    assert_eq!(commit1.state_root, [10u8; 32], "space1 commitment");
+    assert_eq!(commit2.state_root, [20u8; 32], "space2 commitment");
 
     // Test 2: Rollback both in single transaction
     println!("Rolling back both commitments in single transaction...");
@@ -401,13 +537,22 @@ async fn it_should_handle_multiple_commitments(rig: &TestRig) -> anyhow::Result<
             }),
         ],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&multi_rollback).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify both were rolled back
-    let commit1_after = rig.spaced.client.get_commitment(space1_name.clone().into(), None).await?;
-    let commit2_after = rig.spaced.client.get_commitment(space2_name.clone().into(), None).await?;
+    let commit1_after = rig
+        .spaced
+        .client
+        .get_commitment(space1_name.clone().into(), None)
+        .await?;
+    let commit2_after = rig
+        .spaced
+        .client
+        .get_commitment(space2_name.clone().into(), None)
+        .await?;
 
     assert_eq!(commit1_after, None, "space1 should be rolled back");
     assert_eq!(commit2_after, None, "space2 should be rolled back");
@@ -417,22 +562,29 @@ async fn it_should_handle_multiple_commitments(rig: &TestRig) -> anyhow::Result<
     let mixed = wallet_do(
         rig,
         ALICE,
-        vec![
-            RpcWalletRequest::Commit(CommitParams {
-                subject: space1_name.clone().into(),
-                root: Some(sha256::Hash::from_slice(&[30u8;32]).expect("valid")),
-            }),
-        ],
+        vec![RpcWalletRequest::Commit(CommitParams {
+            subject: space1_name.clone().into(),
+            root: Some(sha256::Hash::from_slice(&[30u8; 32]).expect("valid")),
+        })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&mixed).is_ok());
     mine_and_sync(rig, 1).await?;
 
-    let commit1_final = rig.spaced.client.get_commitment(space1_name.clone().into(), None).await?
+    let commit1_final = rig
+        .spaced
+        .client
+        .get_commitment(space1_name.clone().into(), None)
+        .await?
         .expect("space1 should have new commitment");
-    let commit2_final = rig.spaced.client.get_commitment(space2_name.clone().into(), None).await?;
+    let commit2_final = rig
+        .spaced
+        .client
+        .get_commitment(space2_name.clone().into(), None)
+        .await?;
 
-    assert_eq!(commit1_final.state_root, [30u8;32], "space1 updated");
+    assert_eq!(commit1_final.state_root, [30u8; 32], "space1 updated");
     assert_eq!(commit2_final, None, "space2 unchanged");
 
     Ok(())
@@ -444,8 +596,13 @@ async fn it_should_override_pending_commitments(rig: &TestRig) -> anyhow::Result
     sync_all(rig).await?;
 
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let space_name = alice_spaces.owned[0].spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
+    let space_name = alice_spaces.owned[0]
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
 
     // Setup: Delegate the space to establish Num Id
     let delegate = wallet_do(
@@ -455,7 +612,8 @@ async fn it_should_override_pending_commitments(rig: &TestRig) -> anyhow::Result
             subject: space_name.clone().into(),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&delegate).is_ok());
     mine_and_sync(rig, 1).await?;
 
@@ -466,10 +624,11 @@ async fn it_should_override_pending_commitments(rig: &TestRig) -> anyhow::Result
         ALICE,
         vec![RpcWalletRequest::Commit(CommitParams {
             subject: space_name.clone().into(),
-            root: Some(sha256::Hash::from_slice(&[1u8;32]).expect("valid")),
+            root: Some(sha256::Hash::from_slice(&[1u8; 32]).expect("valid")),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&commit1).is_ok());
     mine_and_sync(rig, 1).await?;
 
@@ -480,24 +639,36 @@ async fn it_should_override_pending_commitments(rig: &TestRig) -> anyhow::Result
         ALICE,
         vec![RpcWalletRequest::Commit(CommitParams {
             subject: space_name.clone().into(),
-            root: Some(sha256::Hash::from_slice(&[2u8;32]).expect("valid")),
+            root: Some(sha256::Hash::from_slice(&[2u8; 32]).expect("valid")),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&commit2).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify [1u8;32] is gone, [2u8;32] is tip
-    let old_commit = rig.spaced.client.get_commitment(
-        space_name.clone().into(),
-        Some(sha256::Hash::from_slice(&[1u8;32]).expect("valid"))
-    ).await?;
+    let old_commit = rig
+        .spaced
+        .client
+        .get_commitment(
+            space_name.clone().into(),
+            Some(sha256::Hash::from_slice(&[1u8; 32]).expect("valid")),
+        )
+        .await?;
     assert_eq!(old_commit, None, "[1u8;32] should be overridden");
 
-    let tip = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+    let tip = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?
         .expect("tip should exist");
-    assert_eq!(tip.state_root, [2u8;32]);
-    assert_eq!(tip.prev_root, None, "no previous since [1u8;32] was overridden");
+    assert_eq!(tip.state_root, [2u8; 32]);
+    assert_eq!(
+        tip.prev_root, None,
+        "no previous since [1u8;32] was overridden"
+    );
 
     // Finalize [2u8;32]
     println!("Finalizing [2u8;32]...");
@@ -510,24 +681,34 @@ async fn it_should_override_pending_commitments(rig: &TestRig) -> anyhow::Result
         ALICE,
         vec![RpcWalletRequest::Commit(CommitParams {
             subject: space_name.clone().into(),
-            root: Some(sha256::Hash::from_slice(&[3u8;32]).expect("valid")),
+            root: Some(sha256::Hash::from_slice(&[3u8; 32]).expect("valid")),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&commit3).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify [2u8;32] still exists and [3u8;32] chains from it
-    let finalized = rig.spaced.client.get_commitment(
-        space_name.clone().into(),
-        Some(sha256::Hash::from_slice(&[2u8;32]).expect("valid"))
-    ).await?.expect("[2u8;32] should still exist");
-    assert_eq!(finalized.state_root, [2u8;32]);
+    let finalized = rig
+        .spaced
+        .client
+        .get_commitment(
+            space_name.clone().into(),
+            Some(sha256::Hash::from_slice(&[2u8; 32]).expect("valid")),
+        )
+        .await?
+        .expect("[2u8;32] should still exist");
+    assert_eq!(finalized.state_root, [2u8; 32]);
 
-    let new_tip = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+    let new_tip = rig
+        .spaced
+        .client
+        .get_commitment(space_name.clone().into(), None)
+        .await?
         .expect("new tip should exist");
-    assert_eq!(new_tip.state_root, [3u8;32]);
-    assert_eq!(new_tip.prev_root, Some([2u8;32]));
+    assert_eq!(new_tip.state_root, [3u8; 32]);
+    assert_eq!(new_tip.prev_root, Some([2u8; 32]));
 
     Ok(())
 }
@@ -537,17 +718,37 @@ async fn it_should_reject_duplicate_num_id_delegations(rig: &TestRig) -> anyhow:
 
     // Get two spaces that Alice owns
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    assert!(alice_spaces.owned.len() >= 2, "Alice needs at least 2 spaces for this test");
-
-    let space1_name = alice_spaces.owned[0].spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
-    let space2_name = alice_spaces.owned[1].spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
+    assert!(
+        alice_spaces.owned.len() >= 2,
+        "Alice needs at least 2 spaces for this test"
+    );
 
-    println!("Testing Num Id uniqueness with {} and {}", space1_name, space2_name);
+    let space1_name = alice_spaces.owned[0]
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
+    let space2_name = alice_spaces.owned[1]
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
+
+    println!(
+        "Testing Num Id uniqueness with {} and {}",
+        space1_name, space2_name
+    );
 
     // Get a common address to create the same Num Id
-    let common_addr = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Space).await?;
+    let common_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Space)
+        .await?;
     let common_spk = SpaceAddress::from_str(&common_addr)
         .expect("valid space address")
         .script_pubkey();
@@ -561,71 +762,108 @@ async fn it_should_reject_duplicate_num_id_delegations(rig: &TestRig) -> anyhow:
     let transfer1 = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space1_name.clone())],
             to: Some(common_addr.clone()),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&transfer1).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify the reverse mapping: Num Id -> space1
-    let delegator1 = rig.spaced.client.get_delegator(Subject::NumId(common_id)).await?
+    let delegator1 = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(common_id))
+        .await?
         .expect("common Num Id should have delegator");
-    assert_eq!(delegator1, space1_name, "common Num Id should point to space1");
+    assert_eq!(
+        delegator1, space1_name,
+        "common Num Id should point to space1"
+    );
 
-    println!("✓ Space1 successfully claimed Num Id {} (reverse mapping: {} -> {})",
-        common_id, common_id, space1_name);
+    println!(
+        "✓ Space1 successfully claimed Num Id {} (reverse mapping: {} -> {})",
+        common_id, common_id, space1_name
+    );
 
     // Transfer space2 to the SAME address (same Num Id)
-    println!("Transferring {} to the same address (attempting to claim same Num Id)...", space2_name);
+    println!(
+        "Transferring {} to the same address (attempting to claim same Num Id)...",
+        space2_name
+    );
     let transfer2 = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space2_name.clone())],
             to: Some(common_addr.clone()),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&transfer2).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Key test: Verify the reverse mapping was NOT overwritten
     // The Num Id should still point to space1, not space2
-    let delegator_after = rig.spaced.client.get_delegator(Subject::NumId(common_id)).await?
+    let delegator_after = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(common_id))
+        .await?
         .expect("common Num Id should still have delegator");
-    assert_eq!(delegator_after, space1_name,
-        "CRITICAL: common Num Id should still point to space1 (not overwritten by space2)");
+    assert_eq!(
+        delegator_after, space1_name,
+        "CRITICAL: common Num Id should still point to space1 (not overwritten by space2)"
+    );
 
-    println!("✓ Space2 correctly rejected - reverse mapping preserved ({} -> {})",
-        common_id, space1_name);
+    println!(
+        "✓ Space2 correctly rejected - reverse mapping preserved ({} -> {})",
+        common_id, space1_name
+    );
 
     // Note: get_delegation for both spaces will return Some(common_id) because
     // both are at the same address, but only space1 actually owns the delegation
 
     // Transfer space1 away to free up the Num Id
     println!("Moving {} away to free up Num Id...", space1_name);
-    let new_addr = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Space).await?;
+    let new_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Space)
+        .await?;
     let transfer_away = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space1_name.clone())],
             to: Some(new_addr),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&transfer_away).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify common_id is now free (reverse mapping removed)
-    let delegator_freed = rig.spaced.client.get_delegator(Subject::NumId(common_id)).await?;
-    assert_eq!(delegator_freed, None, "common Num Id should be free (no reverse mapping) after space1 moved");
+    let delegator_freed = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(common_id))
+        .await?;
+    assert_eq!(
+        delegator_freed, None,
+        "common Num Id should be free (no reverse mapping) after space1 moved"
+    );
 
     println!("✓ Num Id freed - reverse mapping removed");
 
@@ -634,24 +872,34 @@ async fn it_should_reject_duplicate_num_id_delegations(rig: &TestRig) -> anyhow:
     let transfer2_retry = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space2_name.clone())],
             to: Some(common_addr),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&transfer2_retry).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify space2 now owns the reverse mapping
-    let delegator2_retry = rig.spaced.client.get_delegator(Subject::NumId(common_id)).await?
+    let delegator2_retry = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(common_id))
+        .await?
         .expect("common Num Id should have delegator");
-    assert_eq!(delegator2_retry, space2_name,
-        "common Num Id should now point to space2 (reverse mapping updated)");
+    assert_eq!(
+        delegator2_retry, space2_name,
+        "common Num Id should now point to space2 (reverse mapping updated)"
+    );
 
-    println!("✓ Space2 successfully claimed Num Id after it was freed ({} -> {})",
-        common_id, space2_name);
+    println!(
+        "✓ Space2 successfully claimed Num Id after it was freed ({} -> {})",
+        common_id, space2_name
+    );
 
     Ok(())
 }
@@ -663,7 +911,11 @@ async fn it_should_restore_delegation_when_transferring_back(rig: &TestRig) -> a
     sync_all(rig).await?;
 
     // Step 1: Get a fresh address and transfer a space to it first to establish baseline
-    let original_addr = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Space).await?;
+    let original_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Space)
+        .await?;
     let original_spk = SpaceAddress::from_str(&original_addr)
         .expect("valid space address")
         .script_pubkey();
@@ -671,38 +923,61 @@ async fn it_should_restore_delegation_when_transferring_back(rig: &TestRig) -> a
 
     // Get a space that Alice owns
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let space = alice_spaces.owned.iter()
+    let space = alice_spaces
+        .owned
+        .iter()
         .find(|s| s.spaceout.space.is_some())
         .expect("Alice needs at least 1 space for this test");
 
-    let space_name = space.spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
+    let space_name = space
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
 
     println!("Testing transfer-away-and-back with space: {}", space_name);
 
     // Transfer space to original_addr first to establish the delegation
-    println!("\nStep 1: Transferring {} to original address to establish delegation...", space_name);
+    println!(
+        "\nStep 1: Transferring {} to original address to establish delegation...",
+        space_name
+    );
     let setup_transfer = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space_name.clone())],
             to: Some(original_addr.clone()),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&setup_transfer).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify initial delegation is established
-    let initial_delegator = rig.spaced.client.get_delegator(Subject::NumId(original_id)).await?
+    let initial_delegator = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(original_id))
+        .await?
         .expect("Original Num Id should have delegation after setup");
     assert_eq!(initial_delegator, space_name);
-    println!("✓ Initial delegation established: {} -> {}", original_id, space_name);
+    println!(
+        "✓ Initial delegation established: {} -> {}",
+        original_id, space_name
+    );
 
     // Step 2: Transfer space to a NEW address (different Num Id)
-    let new_addr = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Space).await?;
+    let new_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Space)
+        .await?;
     let new_spk = SpaceAddress::from_str(&new_addr)
         .expect("valid space address")
         .script_pubkey();
@@ -714,61 +989,104 @@ async fn it_should_restore_delegation_when_transferring_back(rig: &TestRig) -> a
     let transfer1 = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space_name.clone())],
             to: Some(new_addr.clone()),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&transfer1).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // Verify: original Num Id should have NO delegation now
-    let delegator_after_transfer1 = rig.spaced.client.get_delegator(Subject::NumId(original_id)).await?;
-    assert_eq!(delegator_after_transfer1, None,
-        "Original Num Id should have no delegation after space was transferred away");
-    println!("✓ Original Num Id delegation revoked: {:?}", delegator_after_transfer1);
+    let delegator_after_transfer1 = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(original_id))
+        .await?;
+    assert_eq!(
+        delegator_after_transfer1, None,
+        "Original Num Id should have no delegation after space was transferred away"
+    );
+    println!(
+        "✓ Original Num Id delegation revoked: {:?}",
+        delegator_after_transfer1
+    );
 
     // Verify: new Num Id should have the delegation
-    let delegator_new = rig.spaced.client.get_delegator(Subject::NumId(new_id)).await?
+    let delegator_new = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(new_id))
+        .await?
         .expect("New Num Id should have delegation");
-    assert_eq!(delegator_new, space_name,
-        "New Num Id should point to the space");
-    println!("✓ New Num Id has delegation: {} -> {}", new_id, delegator_new);
+    assert_eq!(
+        delegator_new, space_name,
+        "New Num Id should point to the space"
+    );
+    println!(
+        "✓ New Num Id has delegation: {} -> {}",
+        new_id, delegator_new
+    );
 
     // Step 3: Transfer space BACK to original address
-    println!("\nStep 3: Transferring {} BACK to original address...", space_name);
+    println!(
+        "\nStep 3: Transferring {} BACK to original address...",
+        space_name
+    );
     println!("Original address: {}", original_addr);
 
     let transfer2 = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space_name.clone())],
             to: Some(original_addr.clone()),
             data: None,
         })],
         false,
-    ).await?;
+    )
+    .await?;
     assert!(wallet_res_err(&transfer2).is_ok());
     mine_and_sync(rig, 1).await?;
 
     // KEY TEST: Original Num Id should have delegation RESTORED
-    let delegator_restored = rig.spaced.client.get_delegator(Subject::NumId(original_id)).await?;
+    let delegator_restored = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(original_id))
+        .await?;
     println!("Delegation after transfer back: {:?}", delegator_restored);
 
-    assert!(delegator_restored.is_some(),
-        "Original Num Id should have delegation restored after transferring back!");
-    assert_eq!(delegator_restored.unwrap(), space_name,
-        "Original Num Id should point to the space again");
+    assert!(
+        delegator_restored.is_some(),
+        "Original Num Id should have delegation restored after transferring back!"
+    );
+    assert_eq!(
+        delegator_restored.unwrap(),
+        space_name,
+        "Original Num Id should point to the space again"
+    );
 
-    println!("✓ Original Num Id delegation RESTORED: {} -> {}", original_id, space_name);
+    println!(
+        "✓ Original Num Id delegation RESTORED: {} -> {}",
+        original_id, space_name
+    );
 
     // Verify: new Num Id should have NO delegation now
-    let delegator_new_after = rig.spaced.client.get_delegator(Subject::NumId(new_id)).await?;
-    assert_eq!(delegator_new_after, None,
-        "New Num Id should have no delegation after space was transferred back");
+    let delegator_new_after = rig
+        .spaced
+        .client
+        .get_delegator(Subject::NumId(new_id))
+        .await?;
+    assert_eq!(
+        delegator_new_after, None,
+        "New Num Id should have no delegation after space was transferred back"
+    );
     println!("✓ New Num Id delegation revoked");
 
     println!("\n✓ Transfer-back delegation restoration working correctly!");
@@ -782,7 +1100,11 @@ async fn it_should_set_and_persist_ptr_data(rig: &TestRig) -> anyhow::Result<()>
 
     // Test 1: Create a PTR
     println!("Test 1: Create PTR");
-    let addr0 = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
+    let addr0 = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Coin)
+        .await?;
     let addr0_spk = bitcoin::address::Address::from_str(&addr0)?
         .assume_checked()
         .script_pubkey();
@@ -793,16 +1115,24 @@ async fn it_should_set_and_persist_ptr_data(rig: &TestRig) -> anyhow::Result<()>
             bind_spk: Some(addr0_spk.clone()),
         })],
         false,
-    ).await?;
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
     let id = NumId::from_spk::<Sha256>(addr0_spk.clone());
     println!("Num id created: {}", id);
 
     // Verify PTR exists with no data
-    let ptr_initial = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let ptr_initial = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("ptr should exist");
-    assert_eq!(ptr_initial.numout.num.data, None, "PTR should have no data initially");
+    assert_eq!(
+        ptr_initial.numout.num.data, None,
+        "PTR should have no data initially"
+    );
 
     // Test 2: Set data on the PTR
     println!("\nTest 2: Set data on PTR");
@@ -815,37 +1145,68 @@ async fn it_should_set_and_persist_ptr_data(rig: &TestRig) -> anyhow::Result<()>
             data: test_data.clone(),
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&set_data).is_ok(), "SetFallback should succeed");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&set_data).is_ok(),
+        "SetFallback should succeed"
+    );
     mine_and_sync(rig, 1).await?;
 
     use spaces_protocol::Bytes;
     // Verify data was set
-    let ptr_with_data = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let ptr_with_data = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("ptr should exist");
-    assert_eq!(ptr_with_data.numout.num.data, Some(Bytes::new(test_data.clone())), "PTR data should be set");
-    println!("✓ PTR data set successfully: {:?}", String::from_utf8_lossy(&test_data));
+    assert_eq!(
+        ptr_with_data.numout.num.data,
+        Some(Bytes::new(test_data.clone())),
+        "PTR data should be set"
+    );
+    println!(
+        "✓ PTR data set successfully: {:?}",
+        String::from_utf8_lossy(&test_data)
+    );
 
     // Test 3: Transfer PTR without data - data should persist
     println!("\nTest 3: Transfer PTR without setting new data - data should persist");
-    let bob_addr = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
+    let bob_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(BOB, AddressKind::Space)
+        .await?;
     let transfer = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::NumId(id)],
             to: Some(bob_addr.clone()),
             data: None,
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&transfer).is_ok(), "Transfer PTR should succeed");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&transfer).is_ok(),
+        "Transfer PTR should succeed"
+    );
     mine_and_sync(rig, 1).await?;
 
-    let ptr_after_transfer = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let ptr_after_transfer = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("ptr should exist after transfer");
-    assert_eq!(ptr_after_transfer.numout.num.data, Some(Bytes::new(test_data.clone())),
-               "PTR data should persist after transfer without new data");
+    assert_eq!(
+        ptr_after_transfer.numout.num.data,
+        Some(Bytes::new(test_data.clone())),
+        "PTR data should persist after transfer without new data"
+    );
     println!("✓ PTR data persisted after transfer");
 
     // Test 4: Update data with new value
@@ -859,14 +1220,29 @@ async fn it_should_set_and_persist_ptr_data(rig: &TestRig) -> anyhow::Result<()>
             data: new_data.clone(),
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&update_data).is_ok(), "SetFallback should succeed");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&update_data).is_ok(),
+        "SetFallback should succeed"
+    );
     mine_and_sync(rig, 1).await?;
 
-    let ptr_updated = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let ptr_updated = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("ptr should exist");
-    assert_eq!(ptr_updated.numout.num.data, Some(Bytes::new(new_data.clone())), "PTR data should be updated");
-    println!("✓ PTR data updated successfully: {:?}", String::from_utf8_lossy(&new_data));
+    assert_eq!(
+        ptr_updated.numout.num.data,
+        Some(Bytes::new(new_data.clone())),
+        "PTR data should be updated"
+    );
+    println!(
+        "✓ PTR data updated successfully: {:?}",
+        String::from_utf8_lossy(&new_data)
+    );
 
     // Test 5: Set empty data
     println!("\nTest 5: Set empty data");
@@ -879,13 +1255,25 @@ async fn it_should_set_and_persist_ptr_data(rig: &TestRig) -> anyhow::Result<()>
             data: empty_data.clone(),
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&set_empty).is_ok(), "SetFallback with empty data should succeed");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&set_empty).is_ok(),
+        "SetFallback with empty data should succeed"
+    );
     mine_and_sync(rig, 1).await?;
 
-    let ptr_empty = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let ptr_empty = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("ptr should exist");
-    assert_eq!(ptr_empty.numout.num.data, Some(Bytes::new(empty_data)), "PTR data should be set to empty");
+    assert_eq!(
+        ptr_empty.numout.num.data,
+        Some(Bytes::new(empty_data)),
+        "PTR data should be set to empty"
+    );
     println!("✓ PTR data set to empty successfully");
 
     Ok(())
@@ -897,21 +1285,36 @@ async fn it_should_set_and_get_space_fallback(rig: &TestRig) -> anyhow::Result<(
     sync_all(rig).await?;
 
     let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-    let owned = alice_spaces.owned.first().cloned()
+    let owned = alice_spaces
+        .owned
+        .first()
+        .cloned()
         .expect("Alice should own at least one space");
-    let space_name = owned.spaceout.space.as_ref()
-        .expect("space must exist").name.clone();
+    let space_name = owned
+        .spaceout
+        .space
+        .as_ref()
+        .expect("space must exist")
+        .name
+        .clone();
     let space_str = space_name.to_string();
 
     // Record the outpoint and script_pubkey before setfallback
-    let space_before = rig.spaced.client.get_space(&space_str).await?
+    let space_before = rig
+        .spaced
+        .client
+        .get_space(&space_str)
+        .await?
         .expect("space should exist");
     let spk_before = space_before.spaceout.script_pubkey.clone();
 
     // Verify no fallback data initially via getfallback
     let subject = Subject::Label(space_name.clone());
     let fallback_before = rig.spaced.client.get_fallback(subject.clone()).await?;
-    assert!(fallback_before.is_none(), "space should have no fallback data initially");
+    assert!(
+        fallback_before.is_none(),
+        "space should have no fallback data initially"
+    );
     println!("✓ No fallback data initially");
 
     // Test 1: Set SIP-7 fallback data on the space
@@ -919,7 +1322,8 @@ async fn it_should_set_and_get_space_fallback(rig: &TestRig) -> anyhow::Result<(
     let records = sip7::RecordSet::pack(vec![
         sip7::Record::txt("btc", &["bc1qtest"]),
         sip7::Record::txt("nostr", &["npub1abc"]),
-    ]).unwrap();
+    ])
+    .unwrap();
     let wire_data = records.as_slice().to_vec();
 
     let set_result = wallet_do(
@@ -930,32 +1334,51 @@ async fn it_should_set_and_get_space_fallback(rig: &TestRig) -> anyhow::Result<(
             data: wire_data.clone(),
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&set_result).is_ok(), "SetFallback on space should succeed");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&set_result).is_ok(),
+        "SetFallback on space should succeed"
+    );
     mine_and_sync(rig, 1).await?;
 
     // Verify space still exists and is still owned by Alice
-    let space_after = rig.spaced.client.get_space(&space_str).await?
+    let space_after = rig
+        .spaced
+        .client
+        .get_space(&space_str)
+        .await?
         .expect("space should still exist after setfallback");
-    assert!(space_after.spaceout.space.as_ref().unwrap().is_owned(),
-        "space should still be owned after setfallback");
-    assert_eq!(space_after.spaceout.script_pubkey, spk_before,
-        "space script_pubkey should not change after setfallback");
+    assert!(
+        space_after.spaceout.space.as_ref().unwrap().is_owned(),
+        "space should still be owned after setfallback"
+    );
+    assert_eq!(
+        space_after.spaceout.script_pubkey, spk_before,
+        "space script_pubkey should not change after setfallback"
+    );
     println!("✓ Space still owned by Alice at same address");
 
     // Verify data was set on the covenant
     use spaces_protocol::Covenant;
     match &space_after.spaceout.space.as_ref().unwrap().covenant {
         Covenant::Transfer { data, .. } => {
-            assert_eq!(data.as_ref().map(|b| b.clone().to_vec()), Some(wire_data.clone()),
-                "covenant data should match");
+            assert_eq!(
+                data.as_ref().map(|b| b.clone().to_vec()),
+                Some(wire_data.clone()),
+                "covenant data should match"
+            );
         }
         _ => panic!("space should be in Transfer covenant"),
     }
     println!("✓ Covenant data matches wire-encoded SIP-7 records");
 
     // Verify via getfallback RPC
-    let fallback = rig.spaced.client.get_fallback(subject.clone()).await?
+    let fallback = rig
+        .spaced
+        .client
+        .get_fallback(subject.clone())
+        .await?
         .expect("getfallback should return data");
     let parsed = fallback.records.expect("should parse as SIP-7 records");
     assert_eq!(parsed.unpack().unwrap().len(), 2, "should have 2 records");
@@ -963,31 +1386,46 @@ async fn it_should_set_and_get_space_fallback(rig: &TestRig) -> anyhow::Result<(
 
     // Test 2: Alice can still transfer the space after setfallback
     println!("\nTest 2: Transfer space after setfallback");
-    let bob_addr = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
+    let bob_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(BOB, AddressKind::Space)
+        .await?;
     let transfer = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::Label(space_name.clone())],
             to: Some(bob_addr),
             data: None,
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&transfer).is_ok(), "should be able to transfer space after setfallback");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&transfer).is_ok(),
+        "should be able to transfer space after setfallback"
+    );
     mine_and_sync(rig, 1).await?;
 
     // Data should persist after transfer
-    let fallback_after_transfer = rig.spaced.client.get_fallback(subject.clone()).await?
+    let fallback_after_transfer = rig
+        .spaced
+        .client
+        .get_fallback(subject.clone())
+        .await?
         .expect("fallback data should persist after transfer");
-    assert!(fallback_after_transfer.records.is_some(), "SIP-7 records should still parse");
+    assert!(
+        fallback_after_transfer.records.is_some(),
+        "SIP-7 records should still parse"
+    );
     println!("✓ Fallback data persists after transfer");
 
     // Test 3: Bob can overwrite the fallback data
     println!("\nTest 3: Bob overwrites fallback data");
-    let new_records = sip7::RecordSet::pack(vec![
-        sip7::Record::txt("eth", &["0xdeadbeef"]),
-    ]).unwrap();
+    let new_records =
+        sip7::RecordSet::pack(vec![sip7::Record::txt("eth", &["0xdeadbeef"])]).unwrap();
     let new_wire = new_records.as_slice().to_vec();
 
     let bob_set = wallet_do(
@@ -998,14 +1436,26 @@ async fn it_should_set_and_get_space_fallback(rig: &TestRig) -> anyhow::Result<(
             data: new_wire.clone(),
         })],
         false,
-    ).await?;
-    assert!(wallet_res_err(&bob_set).is_ok(), "Bob should be able to setfallback on his space");
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&bob_set).is_ok(),
+        "Bob should be able to setfallback on his space"
+    );
     mine_and_sync(rig, 1).await?;
 
-    let fallback_bob = rig.spaced.client.get_fallback(subject).await?
+    let fallback_bob = rig
+        .spaced
+        .client
+        .get_fallback(subject)
+        .await?
         .expect("should have fallback data");
     let bob_parsed = fallback_bob.records.expect("should parse as SIP-7");
-    assert_eq!(bob_parsed.unpack().unwrap().len(), 1, "should have 1 record now");
+    assert_eq!(
+        bob_parsed.unpack().unwrap().len(),
+        1,
+        "should have 1 record now"
+    );
     println!("✓ Bob successfully overwrote fallback data");
 
     Ok(())
@@ -1070,10 +1520,10 @@ async fn run_ptr_tests() -> anyhow::Result<()> {
 }
 
 fn gen_p2tr_keypair() -> (bitcoin::ScriptBuf, [u8; 32]) {
-    use bitcoin::secp256k1::{Secp256k1, Keypair};
     use bitcoin::key::TapTweak;
-    use bitcoin::script::Builder;
     use bitcoin::opcodes::all::OP_PUSHNUM_1;
+    use bitcoin::script::Builder;
+    use bitcoin::secp256k1::{Keypair, Secp256k1};
 
     let secp = Secp256k1::new();
     let (secret_key, _) = secp.generate_keypair(&mut rand::thread_rng());
@@ -1096,87 +1546,159 @@ async fn it_should_transfer_foreign_num_with_secret(rig: &TestRig) -> anyhow::Re
     // Generate a keypair not owned by any wallet
     let (spk, secret) = gen_p2tr_keypair();
     let num_id = NumId::from_spk::<Sha256>(spk.clone());
-    println!("Test 1: Create num bound to external key (num_id={})", num_id);
+    println!(
+        "Test 1: Create num bound to external key (num_id={})",
+        num_id
+    );
 
     // Create a num bound to the external spk
-    wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::CreateNum(CreateNumParams {
+    wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::CreateNum(CreateNumParams {
             bind_spk: Some(spk.clone()),
-        }),
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
     // Verify the num exists
-    let num_info = rig.spaced.client.get_num(Subject::NumId(num_id)).await?
+    let num_info = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(num_id))
+        .await?
         .expect("num should exist");
-    assert_eq!(num_info.numout.script_pubkey, spk, "num should be bound to external spk");
-    println!("  Num created: {} (id={})", num_info.numout.num.name, num_id);
+    assert_eq!(
+        num_info.numout.script_pubkey, spk,
+        "num should be bound to external spk"
+    );
+    println!(
+        "  Num created: {} (id={})",
+        num_info.numout.num.name, num_id
+    );
 
     // Before transfer: num should appear in external list, not owned list
     rig.wait_until_wallet_synced(ALICE).await?;
     let owned_before = rig.spaced.client.wallet_list_nums(ALICE, None).await?;
-    let external_before = rig.spaced.client.wallet_list_nums(ALICE, Some("external".to_string())).await?;
-    assert!(!owned_before.nums.iter().any(|n| n.numout.num.id == num_id),
-        "num should NOT be in owned list before transfer");
-    assert!(external_before.nums.iter().any(|n| n.numout.num.id == num_id),
-        "num should be in external list before transfer");
+    let external_before = rig
+        .spaced
+        .client
+        .wallet_list_nums(ALICE, Some("external".to_string()))
+        .await?;
+    assert!(
+        !owned_before.nums.iter().any(|n| n.numout.num.id == num_id),
+        "num should NOT be in owned list before transfer"
+    );
+    assert!(
+        external_before
+            .nums
+            .iter()
+            .any(|n| n.numout.num.id == num_id),
+        "num should be in external list before transfer"
+    );
     println!("✓ Num correctly listed as external before transfer");
 
     // Test 1: Transfer the foreign num to ALICE's wallet using the secret
     println!("\nTest 2: Transfer foreign num to wallet using secret key");
     let secret_hex = hex::encode(secret);
-    let result = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Transfer(TransferSpacesParams {
+    let result = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
             secret: Some(secret_hex.clone()),
             spaces: vec![Subject::NumId(num_id)],
             to: None, // transfer to self (wallet's own address)
             data: None,
-        }),
-    ], false).await?;
-    assert!(wallet_res_err(&result).is_ok(), "transfer with secret should succeed");
+        })],
+        false,
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&result).is_ok(),
+        "transfer with secret should succeed"
+    );
     mine_and_sync(rig, 1).await?;
     rig.wait_until_wallet_synced(ALICE).await?;
 
     // Verify ALICE's wallet now lists the num as owned, not external
     let owned_after = rig.spaced.client.wallet_list_nums(ALICE, None).await?;
-    let external_after = rig.spaced.client.wallet_list_nums(ALICE, Some("external".to_string())).await?;
-    assert!(owned_after.nums.iter().any(|n| n.numout.num.id == num_id),
-        "num should be in owned list after transfer");
-    assert!(!external_after.nums.iter().any(|n| n.numout.num.id == num_id),
-        "num should NOT be in external list after transfer");
+    let external_after = rig
+        .spaced
+        .client
+        .wallet_list_nums(ALICE, Some("external".to_string()))
+        .await?;
+    assert!(
+        owned_after.nums.iter().any(|n| n.numout.num.id == num_id),
+        "num should be in owned list after transfer"
+    );
+    assert!(
+        !external_after
+            .nums
+            .iter()
+            .any(|n| n.numout.num.id == num_id),
+        "num should NOT be in external list after transfer"
+    );
     println!("✓ Foreign num transferred to wallet, correctly moved from external to owned");
 
     // Test 2: Generate a second keypair, transfer using secret to that external address
     println!("\nTest 3: Transfer num from wallet to a new external key using wallet ownership");
     let (spk2, _secret2) = gen_p2tr_keypair();
-    let addr2 = SpaceAddress(bitcoin::Address::from_script(&spk2, bitcoin::Network::Regtest)
-        .expect("valid address"));
+    let addr2 = SpaceAddress(
+        bitcoin::Address::from_script(&spk2, bitcoin::Network::Regtest).expect("valid address"),
+    );
 
-    let result2 = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Transfer(TransferSpacesParams {
+    let result2 = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
             secret: None, // ALICE owns it now, no secret needed
             spaces: vec![Subject::NumId(num_id)],
             to: Some(addr2.to_string()),
             data: None,
-        }),
-    ], false).await?;
-    assert!(wallet_res_err(&result2).is_ok(), "transfer to external address should succeed");
+        })],
+        false,
+    )
+    .await?;
+    assert!(
+        wallet_res_err(&result2).is_ok(),
+        "transfer to external address should succeed"
+    );
     mine_and_sync(rig, 1).await?;
 
     // Verify the num is now at the new spk
-    let num_after = rig.spaced.client.get_num(Subject::NumId(num_id)).await?
+    let num_after = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(num_id))
+        .await?
         .expect("num should still exist");
-    assert_eq!(num_after.numout.script_pubkey, spk2, "num should be at new external spk");
+    assert_eq!(
+        num_after.numout.script_pubkey, spk2,
+        "num should be at new external spk"
+    );
     println!("✓ Num transferred to new external address");
 
     // After transferring out: should be back in external list, not owned
     rig.wait_until_wallet_synced(ALICE).await?;
     let owned_final = rig.spaced.client.wallet_list_nums(ALICE, None).await?;
-    let external_final = rig.spaced.client.wallet_list_nums(ALICE, Some("external".to_string())).await?;
-    assert!(!owned_final.nums.iter().any(|n| n.numout.num.id == num_id),
-        "num should NOT be in owned list after transferring out");
-    assert!(external_final.nums.iter().any(|n| n.numout.num.id == num_id),
-        "num should be back in external list after transferring out");
+    let external_final = rig
+        .spaced
+        .client
+        .wallet_list_nums(ALICE, Some("external".to_string()))
+        .await?;
+    assert!(
+        !owned_final.nums.iter().any(|n| n.numout.num.id == num_id),
+        "num should NOT be in owned list after transferring out"
+    );
+    assert!(
+        external_final
+            .nums
+            .iter()
+            .any(|n| n.numout.num.id == num_id),
+        "num should be back in external list after transferring out"
+    );
     println!("✓ Num correctly back in external list after transferring out");
 
     Ok(())
@@ -1191,33 +1713,70 @@ async fn it_should_transfer_ptr_with_n_to_n_rule(rig: &TestRig) -> anyhow::Resul
     println!("Test 1: n→n transfer (same value)");
     {
         // Create a PTR
-        let addr0 = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
-        let addr0_spk = bitcoin::address::Address::from_str(&addr0)?.assume_checked().script_pubkey();
-        wallet_do(rig, ALICE, vec![
-            RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: Some(addr0_spk.clone()) })
-        ], false).await?;
+        let addr0 = rig
+            .spaced
+            .client
+            .wallet_get_new_address(ALICE, AddressKind::Coin)
+            .await?;
+        let addr0_spk = bitcoin::address::Address::from_str(&addr0)?
+            .assume_checked()
+            .script_pubkey();
+        wallet_do(
+            rig,
+            ALICE,
+            vec![RpcWalletRequest::CreateNum(CreateNumParams {
+                bind_spk: Some(addr0_spk.clone()),
+            })],
+            false,
+        )
+        .await?;
         mine_and_sync(rig, 1).await?;
 
         let id = NumId::from_spk::<Sha256>(addr0_spk.clone());
-        let ptr_before = rig.spaced.client.get_num(Subject::NumId(id)).await?.expect("ptr must exist");
+        let ptr_before = rig
+            .spaced
+            .client
+            .get_num(Subject::NumId(id))
+            .await?
+            .expect("ptr must exist");
         let value_before = ptr_before.numout.value;
 
         // Transfer to addr1 with SAME value (should use n→n rule)
-        let addr1 = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
-        wallet_do(rig, ALICE, vec![
-            RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+        let addr1 = rig
+            .spaced
+            .client
+            .wallet_get_new_address(BOB, AddressKind::Space)
+            .await?;
+        wallet_do(
+            rig,
+            ALICE,
+            vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+                secret: None,
                 spaces: vec![Subject::NumId(id)],
                 to: Some(addr1.clone()),
                 data: None,
-            })
-        ], false).await?;
+            })],
+            false,
+        )
+        .await?;
         mine_and_sync(rig, 1).await?;
 
-        let ptr_after = rig.spaced.client.get_num(Subject::NumId(id)).await?.expect("ptr must still exist");
+        let ptr_after = rig
+            .spaced
+            .client
+            .get_num(Subject::NumId(id))
+            .await?
+            .expect("ptr must still exist");
         let spk1 = SpaceAddress::from_str(&addr1)?.script_pubkey();
 
-        assert_eq!(ptr_after.numout.script_pubkey, spk1, "PTR should transfer to new address");
-        assert_eq!(ptr_after.numout.value, value_before, "PTR value should remain same (n→n)");
+        assert_eq!(
+            ptr_after.numout.script_pubkey, spk1,
+            "PTR should transfer to new address"
+        );
+        assert_eq!(
+            ptr_after.numout.value, value_before,
+            "PTR value should remain same (n→n)"
+        );
         println!("✓ n→n transfer successful (same value preserved)");
     }
 
@@ -1225,45 +1784,99 @@ async fn it_should_transfer_ptr_with_n_to_n_rule(rig: &TestRig) -> anyhow::Resul
     println!("\nTest 2: Multiple PTR transfers in same tx");
     {
         // Create two PTRs
-        let addr_a = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
-        let addr_b = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
-        let spk_a = bitcoin::address::Address::from_str(&addr_a)?.assume_checked().script_pubkey();
-        let spk_b = bitcoin::address::Address::from_str(&addr_b)?.assume_checked().script_pubkey();
-
-        wallet_do(rig, ALICE, vec![
-            RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: Some(spk_a.clone()) }),
-            RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: Some(spk_b.clone()) }),
-        ], false).await?;
+        let addr_a = rig
+            .spaced
+            .client
+            .wallet_get_new_address(ALICE, AddressKind::Coin)
+            .await?;
+        let addr_b = rig
+            .spaced
+            .client
+            .wallet_get_new_address(ALICE, AddressKind::Coin)
+            .await?;
+        let spk_a = bitcoin::address::Address::from_str(&addr_a)?
+            .assume_checked()
+            .script_pubkey();
+        let spk_b = bitcoin::address::Address::from_str(&addr_b)?
+            .assume_checked()
+            .script_pubkey();
+
+        wallet_do(
+            rig,
+            ALICE,
+            vec![
+                RpcWalletRequest::CreateNum(CreateNumParams {
+                    bind_spk: Some(spk_a.clone()),
+                }),
+                RpcWalletRequest::CreateNum(CreateNumParams {
+                    bind_spk: Some(spk_b.clone()),
+                }),
+            ],
+            false,
+        )
+        .await?;
         mine_and_sync(rig, 1).await?;
 
         let id_a = NumId::from_spk::<Sha256>(spk_a.clone());
         let id_b = NumId::from_spk::<Sha256>(spk_b.clone());
 
         // Transfer both to different addresses
-        let dest_a = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
-        let dest_b = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
-
-        wallet_do(rig, ALICE, vec![
-            RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
-                spaces: vec![Subject::NumId(id_a)],
-                to: Some(dest_a.clone()),
-                data: None,
-            }),
-            RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
-                spaces: vec![Subject::NumId(id_b)],
-                to: Some(dest_b.clone()),
-                data: None,
-            }),
-        ], false).await?;
+        let dest_a = rig
+            .spaced
+            .client
+            .wallet_get_new_address(BOB, AddressKind::Space)
+            .await?;
+        let dest_b = rig
+            .spaced
+            .client
+            .wallet_get_new_address(BOB, AddressKind::Space)
+            .await?;
+
+        wallet_do(
+            rig,
+            ALICE,
+            vec![
+                RpcWalletRequest::Transfer(TransferSpacesParams {
+                    secret: None,
+                    spaces: vec![Subject::NumId(id_a)],
+                    to: Some(dest_a.clone()),
+                    data: None,
+                }),
+                RpcWalletRequest::Transfer(TransferSpacesParams {
+                    secret: None,
+                    spaces: vec![Subject::NumId(id_b)],
+                    to: Some(dest_b.clone()),
+                    data: None,
+                }),
+            ],
+            false,
+        )
+        .await?;
         mine_and_sync(rig, 1).await?;
 
-        let ptr_a_after = rig.spaced.client.get_num(Subject::NumId(id_a)).await?.expect("ptr_a must exist");
-        let ptr_b_after = rig.spaced.client.get_num(Subject::NumId(id_b)).await?.expect("ptr_b must exist");
+        let ptr_a_after = rig
+            .spaced
+            .client
+            .get_num(Subject::NumId(id_a))
+            .await?
+            .expect("ptr_a must exist");
+        let ptr_b_after = rig
+            .spaced
+            .client
+            .get_num(Subject::NumId(id_b))
+            .await?
+            .expect("ptr_b must exist");
         let spk_dest_a = SpaceAddress::from_str(&dest_a)?.script_pubkey();
         let spk_dest_b = SpaceAddress::from_str(&dest_b)?.script_pubkey();
 
-        assert_eq!(ptr_a_after.numout.script_pubkey, spk_dest_a, "PTR A should transfer correctly");
-        assert_eq!(ptr_b_after.numout.script_pubkey, spk_dest_b, "PTR B should transfer correctly");
+        assert_eq!(
+            ptr_a_after.numout.script_pubkey, spk_dest_a,
+            "PTR A should transfer correctly"
+        );
+        assert_eq!(
+            ptr_b_after.numout.script_pubkey, spk_dest_b,
+            "PTR B should transfer correctly"
+        );
         println!("✓ Multiple PTR transfers handled correctly");
     }
 
@@ -1272,39 +1885,80 @@ async fn it_should_transfer_ptr_with_n_to_n_rule(rig: &TestRig) -> anyhow::Resul
     {
         // Get a space and delegate it
         let alice_spaces = rig.spaced.client.wallet_list_spaces(ALICE).await?;
-        let space = alice_spaces.owned.first().expect("Alice should own a space").clone();
+        let space = alice_spaces
+            .owned
+            .first()
+            .expect("Alice should own a space")
+            .clone();
         let space_name = space.spaceout.space.as_ref().expect("space").name.clone();
 
         // Delegate to create PTR
-        wallet_do(rig, ALICE, vec![
-            RpcWalletRequest::Operate(OperateParams { subject: space_name.clone().into() })
-        ], false).await?;
+        wallet_do(
+            rig,
+            ALICE,
+            vec![RpcWalletRequest::Operate(OperateParams {
+                subject: space_name.clone().into(),
+            })],
+            false,
+        )
+        .await?;
         mine_and_sync(rig, 1).await?;
 
-        let id = rig.spaced.client.get_delegation(space_name.clone().into()).await?
+        let id = rig
+            .spaced
+            .client
+            .get_delegation(space_name.clone().into())
+            .await?
             .expect("delegation should exist");
-        let ptr_before_commit = rig.spaced.client.get_num(Subject::NumId(id)).await?.expect("ptr must exist");
+        let ptr_before_commit = rig
+            .spaced
+            .client
+            .get_num(Subject::NumId(id))
+            .await?
+            .expect("ptr must exist");
         let value_before = ptr_before_commit.numout.value;
         let spk_before = ptr_before_commit.numout.script_pubkey.clone();
 
         // Make a commitment (should preserve value via n→n)
-        wallet_do(rig, ALICE, vec![
-            RpcWalletRequest::Commit(CommitParams {
+        wallet_do(
+            rig,
+            ALICE,
+            vec![RpcWalletRequest::Commit(CommitParams {
                 subject: space_name.clone().into(),
                 root: Some(sha256::Hash::from_slice(&[1u8; 32])?),
-            })
-        ], false).await?;
+            })],
+            false,
+        )
+        .await?;
         mine_and_sync(rig, 1).await?;
 
-        let ptr_after_commit = rig.spaced.client.get_num(Subject::NumId(id)).await?.expect("ptr must exist after commit");
-
-        assert_eq!(ptr_after_commit.numout.value, value_before, "Commitment should preserve PTR value (n→n)");
-        assert_eq!(ptr_after_commit.numout.script_pubkey, spk_before, "Commitment should keep same address");
+        let ptr_after_commit = rig
+            .spaced
+            .client
+            .get_num(Subject::NumId(id))
+            .await?
+            .expect("ptr must exist after commit");
+
+        assert_eq!(
+            ptr_after_commit.numout.value, value_before,
+            "Commitment should preserve PTR value (n→n)"
+        );
+        assert_eq!(
+            ptr_after_commit.numout.script_pubkey, spk_before,
+            "Commitment should keep same address"
+        );
 
         // Verify commitment was created
-        let commitment = rig.spaced.client.get_commitment(space_name.clone().into(), None).await?
+        let commitment = rig
+            .spaced
+            .client
+            .get_commitment(space_name.clone().into(), None)
+            .await?
             .expect("commitment should exist");
-        assert_eq!(commitment.state_root, [1u8; 32], "Commitment root should match");
+        assert_eq!(
+            commitment.state_root, [1u8; 32],
+            "Commitment root should match"
+        );
         println!("✓ Commitment preserves PTR value and address (n→n rule)");
     }
 
@@ -1318,88 +1972,148 @@ async fn it_should_delegate_and_commit_numeric(rig: &TestRig) -> anyhow::Result<
 
     // Create a num
     println!("Test 1: Create and delegate a numeric");
-    let addr = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
-    let spk = bitcoin::address::Address::from_str(&addr)?.assume_checked().script_pubkey();
-    wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: Some(spk.clone()) })
-    ], false).await?;
+    let addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(ALICE, AddressKind::Coin)
+        .await?;
+    let spk = bitcoin::address::Address::from_str(&addr)?
+        .assume_checked()
+        .script_pubkey();
+    wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::CreateNum(CreateNumParams {
+            bind_spk: Some(spk.clone()),
+        })],
+        false,
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
     let id = NumId::from_spk::<Sha256>(spk);
-    let num_info = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let num_info = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("num must exist");
     let numeric = num_info.numout.num.name;
     let numeric_label = numeric.to_slabel();
     println!("  Created numeric: {}", numeric);
 
     // Verify no delegation exists yet
-    let delegation_before = rig.spaced.client
-        .get_delegation(Subject::Label(numeric_label.clone())).await?;
+    let delegation_before = rig
+        .spaced
+        .client
+        .get_delegation(Subject::Label(numeric_label.clone()))
+        .await?;
     assert!(delegation_before.is_none(), "no delegation before delegate");
 
     // Delegate the numeric
-    let delegate_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Operate(OperateParams {
+    let delegate_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Operate(OperateParams {
             subject: Subject::Label(numeric_label.clone()),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&delegate_res)?;
     mine_and_sync(rig, 1).await?;
 
     // Verify delegation exists
-    let delegation = rig.spaced.client
-        .get_delegation(Subject::Label(numeric_label.clone())).await?
+    let delegation = rig
+        .spaced
+        .client
+        .get_delegation(Subject::Label(numeric_label.clone()))
+        .await?
         .expect("delegation should exist after delegate");
     println!("  Delegation established, delegator: {}", delegation);
 
     // Verify the num now has delegate dust value
-    let num_after = rig.spaced.client.get_num(Subject::NumId(id)).await?
+    let num_after = rig
+        .spaced
+        .client
+        .get_num(Subject::NumId(id))
+        .await?
         .expect("num must still exist after delegate");
     assert_eq!(
-        num_after.numout.value.to_sat() % 10, 8,
+        num_after.numout.value.to_sat() % 10,
+        8,
         "num should have delegate dust signaling (value % 10 == 8)"
     );
 
     // Verify can_operate works for numeric subjects
-    let can_op = rig.spaced.client
-        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone())).await?;
+    let can_op = rig
+        .spaced
+        .client
+        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone()))
+        .await?;
     assert!(can_op, "owner should be able to operate delegated numeric");
-    let can_op_bob = rig.spaced.client
-        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone())).await?;
-    assert!(!can_op_bob, "non-owner should not be able to operate delegated numeric");
+    let can_op_bob = rig
+        .spaced
+        .client
+        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        !can_op_bob,
+        "non-owner should not be able to operate delegated numeric"
+    );
     println!("✓ Numeric delegation and can_operate successful");
 
     // Test 2: Commit to the numeric
     println!("\nTest 2: Commit to delegated numeric");
-    let commit_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Commit(CommitParams {
+    let commit_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Commit(CommitParams {
             subject: Subject::Label(numeric_label.clone()),
             root: Some(sha256::Hash::from_slice(&[42u8; 32])?),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&commit_res)?;
     mine_and_sync(rig, 1).await?;
 
-    let commitment = rig.spaced.client
-        .get_commitment(Subject::Label(numeric_label.clone()), None).await?
+    let commitment = rig
+        .spaced
+        .client
+        .get_commitment(Subject::Label(numeric_label.clone()), None)
+        .await?
         .expect("commitment should exist");
-    assert_eq!(commitment.state_root, [42u8; 32], "commitment root should match");
+    assert_eq!(
+        commitment.state_root, [42u8; 32],
+        "commitment root should match"
+    );
     println!("✓ Numeric commitment successful");
 
     // Test 3: Rollback the commitment
     println!("\nTest 3: Rollback numeric commitment");
-    let rollback_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Commit(CommitParams {
+    let rollback_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Commit(CommitParams {
             subject: Subject::Label(numeric_label.clone()),
             root: None,
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&rollback_res)?;
     mine_and_sync(rig, 1).await?;
 
-    let after_rollback = rig.spaced.client
-        .get_commitment(Subject::Label(numeric_label.clone()), None).await?;
-    assert!(after_rollback.is_none(), "commitment tip should be gone after rollback");
+    let after_rollback = rig
+        .spaced
+        .client
+        .get_commitment(Subject::Label(numeric_label.clone()), None)
+        .await?;
+    assert!(
+        after_rollback.is_none(),
+        "commitment tip should be gone after rollback"
+    );
     println!("✓ Numeric rollback successful");
 
     Ok(())
@@ -1412,146 +2126,253 @@ async fn it_should_authorize_numeric_to_another_wallet(rig: &TestRig) -> anyhow:
 
     // Create a num for Alice
     println!("Test 1: Alice creates and delegates a numeric");
-    wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: None })
-    ], false).await?;
+    wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::CreateNum(CreateNumParams {
+            bind_spk: None,
+        })],
+        false,
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
     let alice_nums = rig.spaced.client.wallet_list_nums(ALICE, None).await?;
     let num_entry = alice_nums.nums.last().expect("Alice should have a num");
     let numeric_label = num_entry.numout.num.name.to_slabel();
     let num_id = num_entry.numout.num.id;
-    println!("  Created numeric: {} (id={})", num_entry.numout.num.name, num_id);
+    println!(
+        "  Created numeric: {} (id={})",
+        num_entry.numout.num.name, num_id
+    );
 
     // Delegate it
-    let delegate_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Operate(OperateParams {
+    let delegate_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Operate(OperateParams {
             subject: Subject::Label(numeric_label.clone()),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&delegate_res)?;
     mine_and_sync(rig, 1).await?;
 
     // Alice can operate, Bob cannot
-    let can_op_alice = rig.spaced.client
-        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone())).await?;
-    assert!(can_op_alice, "Alice should be able to operate before authorize");
-    let can_op_bob = rig.spaced.client
-        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone())).await?;
-    assert!(!can_op_bob, "Bob should not be able to operate before authorize");
+    let can_op_alice = rig
+        .spaced
+        .client
+        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        can_op_alice,
+        "Alice should be able to operate before authorize"
+    );
+    let can_op_bob = rig
+        .spaced
+        .client
+        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        !can_op_bob,
+        "Bob should not be able to operate before authorize"
+    );
     println!("✓ Pre-authorize: Alice can operate, Bob cannot");
 
     // Get the delegating NumId
-    let delegation_id = rig.spaced.client
-        .get_delegation(Subject::Label(numeric_label.clone())).await?
+    let delegation_id = rig
+        .spaced
+        .client
+        .get_delegation(Subject::Label(numeric_label.clone()))
+        .await?
         .expect("delegation must exist");
     println!("  Delegating num id: {}", delegation_id);
 
     // Alice transfers the delegating num to Bob (authorize)
     println!("\nTest 2: Alice authorizes Bob by transferring the delegating num");
-    let bob_addr = rig.spaced.client
-        .wallet_get_new_address(BOB, AddressKind::Space).await?;
-    let authorize_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Transfer(TransferSpacesParams { secret: None,
+    let bob_addr = rig
+        .spaced
+        .client
+        .wallet_get_new_address(BOB, AddressKind::Space)
+        .await?;
+    let authorize_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Transfer(TransferSpacesParams {
+            secret: None,
             spaces: vec![Subject::NumId(delegation_id)],
             to: Some(bob_addr),
             data: None,
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&authorize_res)?;
     mine_and_sync(rig, 1).await?;
 
     // Now Bob can operate, Alice cannot
-    let can_op_bob_after = rig.spaced.client
-        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone())).await?;
-    assert!(can_op_bob_after, "Bob should be able to operate after authorize");
-    let can_op_alice_after = rig.spaced.client
-        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone())).await?;
-    assert!(!can_op_alice_after, "Alice should not be able to operate after authorize");
+    let can_op_bob_after = rig
+        .spaced
+        .client
+        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        can_op_bob_after,
+        "Bob should be able to operate after authorize"
+    );
+    let can_op_alice_after = rig
+        .spaced
+        .client
+        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        !can_op_alice_after,
+        "Alice should not be able to operate after authorize"
+    );
     println!("✓ Post-authorize: Bob can operate, Alice cannot");
 
     // Test 3: Bob can commit to the numeric
     println!("\nTest 3: Bob commits to the numeric");
-    let commit_res = wallet_do(rig, BOB, vec![
-        RpcWalletRequest::Commit(CommitParams {
+    let commit_res = wallet_do(
+        rig,
+        BOB,
+        vec![RpcWalletRequest::Commit(CommitParams {
             subject: Subject::Label(numeric_label.clone()),
             root: Some(sha256::Hash::from_slice(&[99u8; 32])?),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&commit_res)?;
     mine_and_sync(rig, 1).await?;
 
-    let commitment = rig.spaced.client
-        .get_commitment(Subject::Label(numeric_label.clone()), None).await?
+    let commitment = rig
+        .spaced
+        .client
+        .get_commitment(Subject::Label(numeric_label.clone()), None)
+        .await?
         .expect("commitment should exist after Bob commits");
-    assert_eq!(commitment.state_root, [99u8; 32], "commitment root should match Bob's");
+    assert_eq!(
+        commitment.state_root, [99u8; 32],
+        "commitment root should match Bob's"
+    );
     println!("✓ Bob successfully committed to Alice's numeric");
 
     // Test 4: Bob rolls back the commitment
     println!("\nTest 4: Bob rolls back the commitment");
-    let rollback_res = wallet_do(rig, BOB, vec![
-        RpcWalletRequest::Commit(CommitParams {
+    let rollback_res = wallet_do(
+        rig,
+        BOB,
+        vec![RpcWalletRequest::Commit(CommitParams {
             subject: Subject::Label(numeric_label.clone()),
             root: None,
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&rollback_res)?;
     mine_and_sync(rig, 1).await?;
 
-    let after_rollback = rig.spaced.client
-        .get_commitment(Subject::Label(numeric_label.clone()), None).await?;
-    assert!(after_rollback.is_none(), "commitment tip should be gone after rollback");
+    let after_rollback = rig
+        .spaced
+        .client
+        .get_commitment(Subject::Label(numeric_label.clone()), None)
+        .await?;
+    assert!(
+        after_rollback.is_none(),
+        "commitment tip should be gone after rollback"
+    );
 
     // Delegation should still be intact after rollback
-    let can_op_bob_after_rollback = rig.spaced.client
-        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone())).await?;
-    assert!(can_op_bob_after_rollback, "Bob should still be able to operate after rollback");
+    let can_op_bob_after_rollback = rig
+        .spaced
+        .client
+        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        can_op_bob_after_rollback,
+        "Bob should still be able to operate after rollback"
+    );
     println!("✓ Bob rolled back successfully, delegation intact");
 
     // Test 5: Alice re-delegates to revoke Bob's authorization
     println!("\nTest 5: Alice re-delegates to revoke Bob's authorization");
-    let redelegate_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Operate(OperateParams {
+    let redelegate_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Operate(OperateParams {
             subject: Subject::Label(numeric_label.clone()),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&redelegate_res)?;
     mine_and_sync(rig, 1).await?;
 
-    let can_op_alice_revoked = rig.spaced.client
-        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone())).await?;
-    assert!(can_op_alice_revoked, "Alice should be able to operate after re-delegate");
-    let can_op_bob_revoked = rig.spaced.client
-        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone())).await?;
-    assert!(!can_op_bob_revoked, "Bob should no longer be able to operate after revoke");
+    let can_op_alice_revoked = rig
+        .spaced
+        .client
+        .wallet_can_operate(ALICE, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        can_op_alice_revoked,
+        "Alice should be able to operate after re-delegate"
+    );
+    let can_op_bob_revoked = rig
+        .spaced
+        .client
+        .wallet_can_operate(BOB, Subject::Label(numeric_label.clone()))
+        .await?;
+    assert!(
+        !can_op_bob_revoked,
+        "Bob should no longer be able to operate after revoke"
+    );
     println!("✓ Re-delegate revoked Bob's authorization, Alice has control again");
 
     // Test 6: Alice commits successfully after re-delegation
     println!("\nTest 6: Alice commits after revoking Bob");
-    let alice_commit_res = wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Commit(CommitParams {
+    let alice_commit_res = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Commit(CommitParams {
             subject: Subject::Label(numeric_label.clone()),
             root: Some(sha256::Hash::from_slice(&[77u8; 32])?),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     wallet_res_err(&alice_commit_res)?;
     mine_and_sync(rig, 1).await?;
 
-    let alice_commitment = rig.spaced.client
-        .get_commitment(Subject::Label(numeric_label.clone()), None).await?
+    let alice_commitment = rig
+        .spaced
+        .client
+        .get_commitment(Subject::Label(numeric_label.clone()), None)
+        .await?
         .expect("commitment should exist after Alice commits");
-    assert_eq!(alice_commitment.state_root, [77u8; 32], "commitment root should match Alice's");
+    assert_eq!(
+        alice_commitment.state_root, [77u8; 32],
+        "commitment root should match Alice's"
+    );
     println!("✓ Alice committed successfully");
 
     // Test 7: Bob can no longer commit
     println!("\nTest 7: Bob cannot commit after revocation");
-    let bob_fail_res = wallet_do(rig, BOB, vec![
-        RpcWalletRequest::Commit(CommitParams {
+    let bob_fail_res = wallet_do(
+        rig,
+        BOB,
+        vec![RpcWalletRequest::Commit(CommitParams {
             subject: Subject::Label(numeric_label.clone()),
             root: Some(sha256::Hash::from_slice(&[88u8; 32])?),
-        })
-    ], false).await;
-    assert!(bob_fail_res.is_err(), "Bob's commit should fail after revocation");
+        })],
+        false,
+    )
+    .await;
+    assert!(
+        bob_fail_res.is_err(),
+        "Bob's commit should fail after revocation"
+    );
     println!("✓ Bob cannot commit after Alice revoked authorization");
 
     Ok(())
@@ -1566,17 +2387,30 @@ async fn it_should_create_multiple_nums_same_tx(rig: &TestRig) -> anyhow::Result
     let before = rig.spaced.client.wallet_list_nums(ALICE, None).await?;
     let before_count = before.nums.len();
 
-    wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: None }),
-        RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: None }),
-    ], false).await?;
+    wallet_do(
+        rig,
+        ALICE,
+        vec![
+            RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: None }),
+            RpcWalletRequest::CreateNum(CreateNumParams { bind_spk: None }),
+        ],
+        false,
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
     let after = rig.spaced.client.wallet_list_nums(ALICE, None).await?;
     assert_eq!(after.nums.len(), before_count + 2, "two new nums created");
 
-    let new_nums: Vec<_> = after.nums.iter()
-        .filter(|e| !before.nums.iter().any(|b| b.numout.num.id == e.numout.num.id))
+    let new_nums: Vec<_> = after
+        .nums
+        .iter()
+        .filter(|e| {
+            !before
+                .nums
+                .iter()
+                .any(|b| b.numout.num.id == e.numout.num.id)
+        })
         .collect();
     assert_eq!(new_nums.len(), 2, "exactly two new nums");
 
@@ -1596,39 +2430,73 @@ async fn it_should_create_multiple_nums_same_tx(rig: &TestRig) -> anyhow::Result
 
     // Test 2: Both can be looked up by their numeric label
     println!("\nTest 2: Lookup both by numeric label");
-    let lookup_a = rig.spaced.client
-        .get_num(Subject::Label(name_a.to_slabel())).await?;
-    let lookup_b = rig.spaced.client
-        .get_num(Subject::Label(name_b.to_slabel())).await?;
-    assert!(lookup_a.is_some(), "num A must be findable by numeric label");
-    assert!(lookup_b.is_some(), "num B must be findable by numeric label");
-    assert_eq!(lookup_a.unwrap().numout.num.id, id_a, "correct num A resolved");
-    assert_eq!(lookup_b.unwrap().numout.num.id, id_b, "correct num B resolved");
+    let lookup_a = rig
+        .spaced
+        .client
+        .get_num(Subject::Label(name_a.to_slabel()))
+        .await?;
+    let lookup_b = rig
+        .spaced
+        .client
+        .get_num(Subject::Label(name_b.to_slabel()))
+        .await?;
+    assert!(
+        lookup_a.is_some(),
+        "num A must be findable by numeric label"
+    );
+    assert!(
+        lookup_b.is_some(),
+        "num B must be findable by numeric label"
+    );
+    assert_eq!(
+        lookup_a.unwrap().numout.num.id,
+        id_a,
+        "correct num A resolved"
+    );
+    assert_eq!(
+        lookup_b.unwrap().numout.num.id,
+        id_b,
+        "correct num B resolved"
+    );
     println!("✓ Both nums resolvable by their unique numeric labels");
 
     // Test 3: Delegate both and verify independent delegations
     println!("\nTest 3: Delegate both nums independently");
-    wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Operate(OperateParams {
+    wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Operate(OperateParams {
             subject: Subject::Label(name_a.to_slabel()),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
-    wallet_do(rig, ALICE, vec![
-        RpcWalletRequest::Operate(OperateParams {
+    wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::Operate(OperateParams {
             subject: Subject::Label(name_b.to_slabel()),
-        })
-    ], false).await?;
+        })],
+        false,
+    )
+    .await?;
     mine_and_sync(rig, 1).await?;
 
-    let del_a = rig.spaced.client
-        .get_delegation(Subject::Label(name_a.to_slabel())).await?;
-    let del_b = rig.spaced.client
-        .get_delegation(Subject::Label(name_b.to_slabel())).await?;
+    let del_a = rig
+        .spaced
+        .client
+        .get_delegation(Subject::Label(name_a.to_slabel()))
+        .await?;
+    let del_b = rig
+        .spaced
+        .client
+        .get_delegation(Subject::Label(name_b.to_slabel()))
+        .await?;
     assert!(del_a.is_some(), "delegation A should exist");
     assert!(del_b.is_some(), "delegation B should exist");
     println!("✓ Both nums delegated independently");
 
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/nums/Cargo.toml b/nums/Cargo.toml
index d568149..e1bcae1 100644
--- a/nums/Cargo.toml
+++ b/nums/Cargo.toml
@@ -1,15 +1,21 @@
 [package]
 name = "spaces_nums"
-version = "0.1.0"
-edition = "2024"
+description = "Numeric identifier extension for the Spaces protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [dependencies]
 bitcoin = { version = "0.32.8", features = ["base64", "serde"], default-features = false }
-spaces_protocol = { path = "../protocol", default-features = false }
+spaces_protocol = { workspace = true }
 
 ## optional features
 borsh = { version = "1.5", default-features = false, features = ["derive"], optional = true }
-borsh_utils = { path = "../borsh_utils", optional = true }
+borsh_utils = { workspace = true, optional = true }
 serde = { version = "1.0", features = ["derive"], default-features = false, optional = true }
 bech32 = { workspace = true, optional = true }
 hex = { workspace = true, optional = true }
diff --git a/nums/src/constants.rs b/nums/src/constants.rs
index 68be580..f378877 100644
--- a/nums/src/constants.rs
+++ b/nums/src/constants.rs
@@ -1,14 +1,13 @@
 use spaces_protocol::constants::ChainAnchor;
 
-pub const COMMITMENT_FINALITY_INTERVAL : u32 = 144;
+pub const COMMITMENT_FINALITY_INTERVAL: u32 = 144;
 
 pub const NUMS_TESTNET4: fn() -> ChainAnchor = || {
     ChainAnchor::new(
         [
-            0x6c, 0x95, 0xe6, 0x8f, 0x41, 0x46, 0x90, 0xe8,
-            0x96, 0xfc, 0xc7, 0x2e, 0x13, 0x9a, 0xbf, 0xa9,
-            0x4e, 0xa1, 0x2e, 0xcc, 0xaf, 0xae, 0x80, 0x62,
-            0xb7, 0x34, 0xfe, 0x06, 0x00, 0x00, 0x00, 0x00,
+            0x6c, 0x95, 0xe6, 0x8f, 0x41, 0x46, 0x90, 0xe8, 0x96, 0xfc, 0xc7, 0x2e, 0x13, 0x9a,
+            0xbf, 0xa9, 0x4e, 0xa1, 0x2e, 0xcc, 0xaf, 0xae, 0x80, 0x62, 0xb7, 0x34, 0xfe, 0x06,
+            0x00, 0x00, 0x00, 0x00,
         ],
         122_222,
     )
@@ -17,10 +16,9 @@ pub const NUMS_TESTNET4: fn() -> ChainAnchor = || {
 pub const NUMS_MAINNET: fn() -> ChainAnchor = || {
     ChainAnchor::new(
         [
-            0xd5, 0x01, 0x39, 0x2b, 0xd5, 0x8a, 0xd3, 0x23,
-            0xfa, 0x4a, 0xaa, 0xf1, 0x2d, 0x0c, 0xfa, 0x8f,
-            0xcd, 0x20, 0x64, 0x43, 0xa3, 0xea, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xd5, 0x01, 0x39, 0x2b, 0xd5, 0x8a, 0xd3, 0x23, 0xfa, 0x4a, 0xaa, 0xf1, 0x2d, 0x0c,
+            0xfa, 0x8f, 0xcd, 0x20, 0x64, 0x43, 0xa3, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
         ],
         941_222,
     )
diff --git a/nums/src/lib.rs b/nums/src/lib.rs
index 7cd4031..513c2f6 100644
--- a/nums/src/lib.rs
+++ b/nums/src/lib.rs
@@ -1,5 +1,4 @@
 pub mod constants;
-#[cfg(feature = "std")]
 pub mod num_id;
 pub mod snumeric;
 
@@ -430,7 +429,7 @@ impl TxContext {
     ) -> spaces_protocol::errors::Result<Option<TxContext>> {
         let has_num_outputs = is_num_minting_locktime(&tx.lock_time)
             && tx.output.iter().any(|out| out.is_ptr_output());
-        let has_spaces = spends_spaces || space_outputs.len() > 0;
+        let has_spaces = spends_spaces || !space_outputs.is_empty();
 
         let relevant = has_spaces || has_num_outputs || Self::spending_nums(src, tx)?;
         if !relevant {
@@ -500,13 +499,11 @@ impl TxContext {
             }
         }
         for input in &inputs {
-            let dk = DelegatorKey::from_id::<H>(
-                NumId::from_spk::<H>(input.numout.script_pubkey.clone()),
-            );
-            if !nums_with_delegations.contains(&dk) {
-                if src.get_delegator(&dk)?.is_some() {
-                    nums_with_delegations.push(dk);
-                }
+            let dk = DelegatorKey::from_id::<H>(NumId::from_spk::<H>(
+                input.numout.script_pubkey.clone(),
+            ));
+            if !nums_with_delegations.contains(&dk) && src.get_delegator(&dk)?.is_some() {
+                nums_with_delegations.push(dk);
             }
         }
 
@@ -538,6 +535,12 @@ pub fn rolling_hash<H: KeyHasher>(old: [u8; 32], new_root: [u8; 32]) -> [u8; 32]
     H::hash(&data)
 }
 
+impl Default for Validator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Validator {
     pub fn new() -> Self {
         Self {}
@@ -582,24 +585,22 @@ impl Validator {
 
         // Revoke num to num delegations only when the source num is spent
         // and a delegation actually exists at that address.
-        changeset.revoked_delegations.extend(
-            ctx.inputs
-                .iter()
-                .filter_map(|input| {
-                    let operator_id = NumId::from_spk::<H>(input.numout.script_pubkey.clone());
-                    if operator_id == input.numout.num.id {
-                        return None;
-                    }
-                    let dk = DelegatorKey::from_id::<H>(operator_id);
-                    if !ctx.nums_with_delegations.contains(&dk) {
-                        return None;
-                    }
-                    Some(DelegationInfo {
-                        subject: input.numout.num.name.to_slabel(),
-                        id: operator_id,
-                    })
-                }),
-        );
+        changeset
+            .revoked_delegations
+            .extend(ctx.inputs.iter().filter_map(|input| {
+                let operator_id = NumId::from_spk::<H>(input.numout.script_pubkey.clone());
+                if operator_id == input.numout.num.id {
+                    return None;
+                }
+                let dk = DelegatorKey::from_id::<H>(operator_id);
+                if !ctx.nums_with_delegations.contains(&dk) {
+                    return None;
+                }
+                Some(DelegationInfo {
+                    subject: input.numout.num.name.to_slabel(),
+                    id: operator_id,
+                })
+            }));
 
         // Clear revoked num ids so they can be redelegated in the same tx
         let revoked_keys: Vec<DelegatorKey> = changeset
@@ -642,13 +643,13 @@ impl Validator {
                 match &commitment_op {
                     Some(CommitmentOp::Rollback) => {
                         // Rollback applies to ALL delegates with pending commitments
-                        if let Some(pending) = delegate.pending_tip {
-                            if !pending.is_finalized(height) {
-                                changeset.revoked_commitments.push(CommitmentInfo {
-                                    space: delegate.subject.clone(),
-                                    commitment: pending,
-                                });
-                            }
+                        if let Some(pending) = delegate.pending_tip
+                            && !pending.is_finalized(height)
+                        {
+                            changeset.revoked_commitments.push(CommitmentInfo {
+                                space: delegate.subject.clone(),
+                                commitment: pending,
+                            });
                         }
                     }
                     Some(CommitmentOp::Commit(_)) => {
@@ -758,12 +759,13 @@ impl Validator {
         changeset
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn process_spend(
         &self,
         tx: &Transaction,
         input_index: usize,
         mut numout: NumOut,
-        new_space_utxos: &Vec<SpaceOut>,
+        new_space_utxos: &[SpaceOut],
         changeset: &mut TxChangeSet,
         height: u32,
         data: &Option<Bytes>,
@@ -795,10 +797,11 @@ impl Validator {
         // Only update data if:
         // 1. A data OP_RETURN is present
         // 2. PTR is P2TR and input uses SIGHASH_ALL (prevents malicious data injection)
-        if let Some(new_data) = data {
-            if numout.script_pubkey.is_p2tr() && is_p2tr_sighash_all(tx, input_index) {
-                ptr.data = Some(new_data.clone());
-            }
+        if let Some(new_data) = data
+            && numout.script_pubkey.is_p2tr()
+            && is_p2tr_sighash_all(tx, input_index)
+        {
+            ptr.data = Some(new_data.clone());
         }
         numout.n = output_index;
         numout.value = output.value;
@@ -821,8 +824,8 @@ pub enum NumOp {
 }
 
 /// To make a commitment, we use:
-/// Commit: OP_RETURN OP_PUSHNUM_2 OP_PUSHBYTES_x <data>
-/// Rollback: OP_RETURN OP_PUSHNUM_2 OP_PUSHBYTES_0
+/// - Commit: `OP_RETURN OP_PUSHNUM_2 OP_PUSHBYTES_x <data>`
+/// - Rollback: `OP_RETURN OP_PUSHNUM_2 OP_PUSHBYTES_0`
 pub fn find_op_commit(tx_outputs: &[TxOut]) -> Option<CommitmentOp> {
     tx_outputs.iter().find_map(|s| {
         let mut instructions = s.script_pubkey.instructions().skip(1);
@@ -857,7 +860,7 @@ pub fn create_commitment_script(op: &CommitmentOp) -> ScriptBuf {
     match op {
         CommitmentOp::Rollback => {
             // OP_RETURN OP_PUSHNUM_2 OP_PUSHBYTES_0
-            builder = builder.push_slice(&[]);
+            builder = builder.push_slice([]);
         }
         CommitmentOp::Commit(commitments) => {
             // OP_RETURN OP_PUSHNUM_2 OP_PUSHBYTES_N <commitments>
@@ -876,6 +879,7 @@ pub fn create_commitment_script(op: &CommitmentOp) -> ScriptBuf {
 /// Per BIP 341:
 /// - 64 bytes = SIGHASH_DEFAULT (0x00), equivalent to SIGHASH_ALL
 /// - 65 bytes with last byte 0x01 = SIGHASH_ALL
+///
 /// Note: 0x00 is never appended (always 64 bytes for default)
 fn is_p2tr_sighash_all(tx: &Transaction, input_index: usize) -> bool {
     let input = match tx.input.get(input_index) {
diff --git a/nums/src/num_id.rs b/nums/src/num_id.rs
index a7f4b0e..97adaf0 100644
--- a/nums/src/num_id.rs
+++ b/nums/src/num_id.rs
@@ -1,8 +1,12 @@
-use core::{fmt, str::FromStr};
-use bech32::{self, Hrp, Bech32m};
-use bitcoin::{ScriptBuf};
+use crate::{KeyKind, ns_hash};
+#[cfg(feature = "bech32")]
+use bech32::{Bech32m, Hrp};
+use bitcoin::ScriptBuf;
+#[cfg(feature = "bech32")]
+use core::fmt;
+#[cfg(feature = "bech32")]
+use core::str::FromStr;
 use spaces_protocol::hasher::{Hash, KeyHash, KeyHasher};
-use crate::{ns_hash, KeyKind};
 
 pub const NUM_HRP: &str = "num";
 
@@ -11,17 +15,22 @@ impl KeyHash for NumId {}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct NumId(pub(crate) [u8; 32]);
 
-
 impl NumId {
     #[inline]
-    pub fn from_bytes(bytes: [u8; 32]) -> Self { Self(bytes) }
+    pub fn from_bytes(bytes: [u8; 32]) -> Self {
+        Self(bytes)
+    }
     #[inline]
-    pub fn as_slice(&self) -> &[u8] { &self.0 }
+    pub fn as_slice(&self) -> &[u8] {
+        &self.0
+    }
     #[inline]
-    pub fn to_bytes(self) -> [u8; 32] { self.0 }
+    pub fn to_bytes(self) -> [u8; 32] {
+        self.0
+    }
 
     pub fn from_spk<H: KeyHasher>(spk: ScriptBuf) -> Self {
-        Self(ns_hash::<H>(KeyKind::NumId, H::hash(&spk.as_bytes())))
+        Self(ns_hash::<H>(KeyKind::NumId, H::hash(spk.as_bytes())))
     }
 }
 
@@ -31,6 +40,7 @@ impl From<NumId> for Hash {
     }
 }
 
+#[cfg(feature = "bech32")]
 #[derive(Debug)]
 pub enum NumIdParseError {
     Bech32(bech32::DecodeError),
@@ -38,6 +48,7 @@ pub enum NumIdParseError {
     InvalidLen,
 }
 
+#[cfg(feature = "bech32")]
 impl fmt::Display for NumIdParseError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -48,9 +59,10 @@ impl fmt::Display for NumIdParseError {
     }
 }
 
+#[cfg(all(feature = "std", feature = "bech32"))]
 impl std::error::Error for NumIdParseError {}
 
-#[cfg(feature = "serde")]
+#[cfg(all(feature = "serde", feature = "bech32"))]
 impl serde::Serialize for NumId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -60,7 +72,7 @@ impl serde::Serialize for NumId {
     }
 }
 
-#[cfg(feature = "serde")]
+#[cfg(all(feature = "serde", feature = "bech32"))]
 impl<'de> serde::Deserialize<'de> for NumId {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -74,8 +86,8 @@ impl<'de> serde::Deserialize<'de> for NumId {
 
 #[cfg(feature = "borsh")]
 mod borsh_impl {
-    use borsh::{io, BorshDeserialize, BorshSerialize};
     use super::*;
+    use borsh::{BorshDeserialize, BorshSerialize, io};
 
     impl BorshSerialize for NumId {
         fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
@@ -92,10 +104,14 @@ mod borsh_impl {
     }
 }
 
+#[cfg(feature = "bech32")]
 impl From<bech32::DecodeError> for NumIdParseError {
-    fn from(e: bech32::DecodeError) -> Self { NumIdParseError::Bech32(e) }
+    fn from(e: bech32::DecodeError) -> Self {
+        NumIdParseError::Bech32(e)
+    }
 }
 
+#[cfg(feature = "bech32")]
 impl fmt::Display for NumId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let hrp = Hrp::parse(NUM_HRP).map_err(|_| fmt::Error)?;
@@ -104,13 +120,18 @@ impl fmt::Display for NumId {
     }
 }
 
+#[cfg(feature = "bech32")]
 impl FromStr for NumId {
     type Err = NumIdParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let (hrp, data) = bech32::decode(s)?;
-        if hrp.as_str() != NUM_HRP { return Err(NumIdParseError::InvalidHrp); }
-        if data.len() != 32 { return Err(NumIdParseError::InvalidLen); }
+        if hrp.as_str() != NUM_HRP {
+            return Err(NumIdParseError::InvalidHrp);
+        }
+        if data.len() != 32 {
+            return Err(NumIdParseError::InvalidLen);
+        }
         let mut arr = [0u8; 32];
         arr.copy_from_slice(&data);
         Ok(NumId(arr))
@@ -120,7 +141,7 @@ impl FromStr for NumId {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bech32::{Bech32m};
+    use bech32::Bech32m;
 
     #[test]
     fn num_id_roundtrip() {
diff --git a/nums/src/snumeric.rs b/nums/src/snumeric.rs
index d9b2429..b5d4cc8 100644
--- a/nums/src/snumeric.rs
+++ b/nums/src/snumeric.rs
@@ -10,17 +10,27 @@ pub struct SNumeric {
 
 impl SNumeric {
     pub fn new(block: u32, tx_pos: u16, vout: u16) -> Self {
-        Self { block, tx_pos, vout }
+        Self {
+            block,
+            tx_pos,
+            vout,
+        }
     }
 
     #[inline]
-    pub fn block(&self) -> u32 { self.block }
+    pub fn block(&self) -> u32 {
+        self.block
+    }
 
     #[inline]
-    pub fn tx_pos(&self) -> u16 { self.tx_pos }
+    pub fn tx_pos(&self) -> u16 {
+        self.tx_pos
+    }
 
     #[inline]
-    pub fn vout(&self) -> u16 { self.vout }
+    pub fn vout(&self) -> u16 {
+        self.vout
+    }
 
     pub fn to_slabel(&self) -> SLabel {
         SLabel::from_str(&self.to_string()).expect("valid numeric label")
@@ -31,7 +41,9 @@ impl TryFrom<SLabel> for SNumeric {
     type Error = SNumericParseError;
 
     fn try_from(label: SLabel) -> Result<Self, Self::Error> {
-        let s = label.as_str_unprefixed().map_err(|_| SNumericParseError::MissingPrefix)?;
+        let s = label
+            .as_str_unprefixed()
+            .map_err(|_| SNumericParseError::MissingPrefix)?;
         SNumeric::from_str(s)
     }
 }
@@ -49,7 +61,9 @@ impl fmt::Display for SNumericParseError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             SNumericParseError::MissingPrefix => f.write_str("expected '#' prefix"),
-            SNumericParseError::InvalidFormat => f.write_str("expected '#<block>-<tx_pos>-<vout>' format"),
+            SNumericParseError::InvalidFormat => {
+                f.write_str("expected '#<block>-<tx_pos>-<vout>' format")
+            }
             SNumericParseError::InvalidBlock(e) => write!(f, "invalid block number: {e}"),
             SNumericParseError::InvalidTxPos(e) => write!(f, "invalid tx position: {e}"),
             SNumericParseError::InvalidVout(e) => write!(f, "invalid vout: {e}"),
@@ -57,6 +71,7 @@ impl fmt::Display for SNumericParseError {
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for SNumericParseError {}
 
 impl fmt::Display for SNumeric {
@@ -69,15 +84,27 @@ impl FromStr for SNumeric {
     type Err = SNumericParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.strip_prefix('#').ok_or(SNumericParseError::MissingPrefix)?;
+        let s = s
+            .strip_prefix('#')
+            .ok_or(SNumericParseError::MissingPrefix)?;
         let mut parts = s.splitn(3, '-');
         let block_str = parts.next().ok_or(SNumericParseError::InvalidFormat)?;
         let pos_str = parts.next().ok_or(SNumericParseError::InvalidFormat)?;
         let vout_str = parts.next().ok_or(SNumericParseError::InvalidFormat)?;
-        let block = block_str.parse::<u32>().map_err(SNumericParseError::InvalidBlock)?;
-        let tx_pos = pos_str.parse::<u16>().map_err(SNumericParseError::InvalidTxPos)?;
-        let vout = vout_str.parse::<u16>().map_err(SNumericParseError::InvalidVout)?;
-        Ok(SNumeric { block, tx_pos, vout })
+        let block = block_str
+            .parse::<u32>()
+            .map_err(SNumericParseError::InvalidBlock)?;
+        let tx_pos = pos_str
+            .parse::<u16>()
+            .map_err(SNumericParseError::InvalidTxPos)?;
+        let vout = vout_str
+            .parse::<u16>()
+            .map_err(SNumericParseError::InvalidVout)?;
+        Ok(SNumeric {
+            block,
+            tx_pos,
+            vout,
+        })
     }
 }
 
@@ -121,8 +148,8 @@ impl<'de> serde::Deserialize<'de> for SNumeric {
 
 #[cfg(feature = "borsh")]
 mod borsh_impl {
-    use borsh::{io, BorshDeserialize, BorshSerialize};
     use super::*;
+    use borsh::{BorshDeserialize, BorshSerialize, io};
 
     impl BorshSerialize for SNumeric {
         fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
@@ -137,7 +164,11 @@ mod borsh_impl {
             let block = u32::deserialize_reader(reader)?;
             let tx_pos = u16::deserialize_reader(reader)?;
             let vout = u16::deserialize_reader(reader)?;
-            Ok(SNumeric { block, tx_pos, vout })
+            Ok(SNumeric {
+                block,
+                tx_pos,
+                vout,
+            })
         }
     }
 }
diff --git a/protocol/Cargo.toml b/protocol/Cargo.toml
index e9330a8..2240a23 100644
--- a/protocol/Cargo.toml
+++ b/protocol/Cargo.toml
@@ -1,14 +1,20 @@
 [package]
 name = "spaces_protocol"
-version = "0.0.7"
-edition = "2021"
+description = "Core protocol types and consensus rules for the Spaces Protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [dependencies]
 bitcoin = { version = "0.32.8", features = ["base64", "serde"], default-features = false }
 
 ## optional features
 borsh = { version = "1.5", default-features = false, features = ["derive"], optional = true }
-borsh_utils = { path = "../borsh_utils", optional = true }
+borsh_utils = { workspace = true, optional = true }
 serde = { version = "1.0", features = ["derive"], default-features = false, optional = true }
 
 [dev-dependencies]
diff --git a/protocol/src/constants.rs b/protocol/src/constants.rs
index 1be53d0..bfa0717 100644
--- a/protocol/src/constants.rs
+++ b/protocol/src/constants.rs
@@ -1,8 +1,8 @@
 use bitcoin::{
+    BlockHash, Sequence,
     absolute::{Height, LockTime},
     blockdata::transaction::Version,
     hashes::Hash,
-    BlockHash, Sequence,
 };
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -18,7 +18,7 @@ pub struct ChainAnchor {
 
 pub const SPACES_SIGNED_MSG_PREFIX: &[u8] = b"\x17Spaces Signed Message:\n";
 
-pub const RESERVED_SPACES: [&'static [u8]; 3] = [b"\x07example", b"\x04test", b"\x05local"];
+pub const RESERVED_SPACES: [&[u8]; 3] = [b"\x07example", b"\x04test", b"\x05local"];
 
 /// The number of blocks between each rollout of new spaces for auction.
 pub const ROLLOUT_BLOCK_INTERVAL: u32 = 144;
@@ -62,10 +62,9 @@ impl ChainAnchor {
     pub const MAINNET: fn() -> Self = || {
         Self::new(
             [
-                0x0c, 0x5a, 0x27, 0x95, 0xe2, 0xb7, 0xd5, 0x06,
-                0xdf, 0x09, 0x6a, 0x33, 0x28, 0x47, 0xba, 0x98,
-                0x9f, 0xa6, 0x37, 0x9d, 0xfd, 0x2d, 0x02, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0c, 0x5a, 0x27, 0x95, 0xe2, 0xb7, 0xd5, 0x06, 0xdf, 0x09, 0x6a, 0x33, 0x28, 0x47,
+                0xba, 0x98, 0x9f, 0xa6, 0x37, 0x9d, 0xfd, 0x2d, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00,
             ],
             871_222,
         )
@@ -75,23 +74,21 @@ impl ChainAnchor {
     pub const TESTNET4: fn() -> Self = || {
         Self::new(
             [
-                0xcb, 0xf2, 0xef, 0x93, 0xe8, 0xd0, 0xca, 0x10,
-                0xfb, 0x09, 0xb0, 0xe2, 0x69, 0x97, 0x7a, 0xf0,
-                0x33, 0x72, 0x99, 0x88, 0x9a, 0x16, 0x26, 0xa1,
-                0x4b, 0xc9, 0xc8, 0xe2, 0x00, 0x00, 0x00, 0x00,
+                0xcb, 0xf2, 0xef, 0x93, 0xe8, 0xd0, 0xca, 0x10, 0xfb, 0x09, 0xb0, 0xe2, 0x69, 0x97,
+                0x7a, 0xf0, 0x33, 0x72, 0x99, 0x88, 0x9a, 0x16, 0x26, 0xa1, 0x4b, 0xc9, 0xc8, 0xe2,
+                0x00, 0x00, 0x00, 0x00,
             ],
             50_000,
         )
     };
-    
+
     // Testnet activation block
     pub const TESTNET: fn() -> Self = || {
         Self::new(
             [
-                0xb8, 0x9d, 0xd5, 0xe4, 0x5e, 0xd7, 0x0a, 0x50,
-                0x73, 0x25, 0x2e, 0x0f, 0x5f, 0xba, 0x4a, 0x9e,
-                0xd2, 0x37, 0x73, 0x9d, 0x3b, 0x5a, 0x19, 0x58,
-                0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0xb8, 0x9d, 0xd5, 0xe4, 0x5e, 0xd7, 0x0a, 0x50, 0x73, 0x25, 0x2e, 0x0f, 0x5f, 0xba,
+                0x4a, 0x9e, 0xd2, 0x37, 0x73, 0x9d, 0x3b, 0x5a, 0x19, 0x58, 0x1a, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00,
             ],
             2_865_460,
         )
@@ -101,10 +98,9 @@ impl ChainAnchor {
     pub const REGTEST: fn() -> Self = || {
         Self::new(
             [
-                0x06, 0x22, 0x6e, 0x46, 0x11, 0x1a, 0x0b, 0x59,
-                0xca, 0xaf, 0x12, 0x60, 0x43, 0xeb, 0x5b, 0xbf,
-                0x28, 0xc3, 0x4f, 0x3a, 0x5e, 0x33, 0x2a, 0x1f,
-                0xc7, 0xb2, 0xb7, 0x3c, 0xf1, 0x88, 0x91, 0x0f,
+                0x06, 0x22, 0x6e, 0x46, 0x11, 0x1a, 0x0b, 0x59, 0xca, 0xaf, 0x12, 0x60, 0x43, 0xeb,
+                0x5b, 0xbf, 0x28, 0xc3, 0x4f, 0x3a, 0x5e, 0x33, 0x2a, 0x1f, 0xc7, 0xb2, 0xb7, 0x3c,
+                0xf1, 0x88, 0x91, 0x0f,
             ],
             0,
         )
@@ -113,10 +109,9 @@ impl ChainAnchor {
     pub const NUMS_REGTEST: fn() -> Self = || {
         Self::new(
             [
-                0x06, 0x22, 0x6e, 0x46, 0x11, 0x1a, 0x0b, 0x59,
-                0xca, 0xaf, 0x12, 0x60, 0x43, 0xeb, 0x5b, 0xbf,
-                0x28, 0xc3, 0x4f, 0x3a, 0x5e, 0x33, 0x2a, 0x1f,
-                0xc7, 0xb2, 0xb7, 0x3c, 0xf1, 0x88, 0x91, 0x0f,
+                0x06, 0x22, 0x6e, 0x46, 0x11, 0x1a, 0x0b, 0x59, 0xca, 0xaf, 0x12, 0x60, 0x43, 0xeb,
+                0x5b, 0xbf, 0x28, 0xc3, 0x4f, 0x3a, 0x5e, 0x33, 0x2a, 0x1f, 0xc7, 0xb2, 0xb7, 0x3c,
+                0xf1, 0x88, 0x91, 0x0f,
             ],
             0,
         )
@@ -127,8 +122,8 @@ impl ChainAnchor {
 pub mod borsh_impl {
     use alloc::vec::Vec;
 
-    use bitcoin::{hashes::Hash, BlockHash};
-    use borsh::{io, BorshDeserialize, BorshSerialize};
+    use bitcoin::{BlockHash, hashes::Hash};
+    use borsh::{BorshDeserialize, BorshSerialize, io};
 
     use crate::constants::ChainAnchor;
 
diff --git a/protocol/src/hasher.rs b/protocol/src/hasher.rs
index 9900bf1..78a31a6 100644
--- a/protocol/src/hasher.rs
+++ b/protocol/src/hasher.rs
@@ -1,6 +1,6 @@
+use bitcoin::{Amount, OutPoint};
 #[cfg(feature = "borsh")]
 use borsh::{BorshDeserialize, BorshSerialize};
-use bitcoin::{Amount, OutPoint};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -58,7 +58,7 @@ impl SpaceKey {
     #[inline(always)]
     pub fn from_raw(value: Hash) -> crate::errors::Result<Self> {
         if Self::is_valid(&value) {
-            return Ok(Self { 0: value });
+            return Ok(Self(value));
         }
         Err(crate::errors::Error::IO("bad space hash".to_string()))
     }
@@ -76,7 +76,7 @@ impl SpaceKey {
 
     #[inline(always)]
     pub fn as_slice(&self) -> &[u8] {
-        return &self.0;
+        &self.0
     }
 }
 
diff --git a/protocol/src/lib.rs b/protocol/src/lib.rs
index e6116ac..61278b3 100644
--- a/protocol/src/lib.rs
+++ b/protocol/src/lib.rs
@@ -7,16 +7,15 @@ pub extern crate bitcoin;
 
 use alloc::{vec, vec::Vec};
 
-#[cfg(feature = "borsh")]
-use borsh::{BorshDeserialize, BorshSerialize};
 use bitcoin::{
-    psbt,
-    secp256k1::{schnorr, Message},
+    Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid, Witness, psbt,
+    secp256k1::{Message, schnorr},
     sighash::{Prevouts, SighashCache, TapSighashType},
     taproot,
     transaction::Version,
-    Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid, Witness,
 };
+#[cfg(feature = "borsh")]
+use borsh::{BorshDeserialize, BorshSerialize};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -31,8 +30,8 @@ pub mod hasher;
 pub mod prepare;
 pub mod script;
 pub mod slabel;
-pub mod validate;
 pub mod sname;
+pub mod validate;
 
 #[derive(Clone, PartialEq, Debug)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -256,7 +255,7 @@ pub mod serde_bytes_impl {
 pub mod borsh_bytes_impl {
     use alloc::vec::Vec;
 
-    use borsh::{io, BorshDeserialize, BorshSerialize};
+    use borsh::{BorshDeserialize, BorshSerialize, io};
 
     use super::Bytes;
 
@@ -278,17 +277,17 @@ impl Space {
     pub fn is_expired(&self, height: u32) -> bool {
         match self.covenant {
             Covenant::Transfer { expire_height, .. } => expire_height < height,
-            _ => return false,
+            _ => false,
         }
     }
 
     pub fn is_owned(&self) -> bool {
-        return matches!(self.covenant, Covenant::Transfer { .. });
+        matches!(self.covenant, Covenant::Transfer { .. })
     }
 
     pub fn claim_height(&self) -> Option<u32> {
         match &self.covenant {
-            Covenant::Bid { claim_height, .. } => claim_height.clone(),
+            Covenant::Bid { claim_height, .. } => *claim_height,
             _ => None,
         }
     }
@@ -311,20 +310,16 @@ impl Space {
 
     pub fn data(&self) -> Option<&[u8]> {
         match &self.covenant {
-            Covenant::Transfer { data, .. } => match &data {
-                None => None,
-                Some(data) => Some(data.as_slice()),
-            },
+            Covenant::Transfer {
+                data: Some(data), ..
+            } => Some(data.as_slice()),
             _ => None,
         }
     }
 
     pub fn data_owned(&self) -> Option<Bytes> {
         match &self.covenant {
-            Covenant::Transfer { data, .. } => match &data {
-                None => None,
-                Some(data) => Some(data.clone()),
-            },
+            Covenant::Transfer { data, .. } => data.clone(),
             _ => None,
         }
     }
@@ -384,9 +379,7 @@ impl FullSpaceOut {
     pub fn refund_signing_info(
         &self,
     ) -> Option<(Transaction, Prevouts<'_, TxOut>, schnorr::Signature)> {
-        if self.spaceout.space.is_none() {
-            return None;
-        }
+        self.spaceout.space.as_ref()?;
 
         match &self.spaceout.space.as_ref().unwrap().covenant {
             Covenant::Bid {
@@ -404,7 +397,7 @@ impl FullSpaceOut {
                             script_pubkey: self.spaceout.script_pubkey.clone(),
                         },
                     ),
-                    signature.clone(),
+                    *signature,
                 ))
             }
             _ => None,
@@ -412,9 +405,7 @@ impl FullSpaceOut {
     }
 
     pub fn refund_psbt_data(&self) -> Option<(psbt::Input, TxOut)> {
-        if self.spaceout.space.is_none() {
-            return None;
-        }
+        self.spaceout.space.as_ref()?;
 
         match &self.spaceout.space.as_ref().unwrap().covenant {
             Covenant::Bid {
@@ -426,7 +417,7 @@ impl FullSpaceOut {
                 let mut witness = Witness::default();
                 witness.push(
                     taproot::Signature {
-                        signature: signature.clone(),
+                        signature: *signature,
                         sighash_type: TapSighashType::SinglePlusAnyoneCanPay,
                     }
                     .to_vec(),
@@ -460,13 +451,13 @@ impl FullSpaceOut {
         let mut witness = Witness::default();
         witness.push(
             taproot::Signature {
-                signature: signature.clone(),
+                signature: *signature,
                 sighash_type: TapSighashType::SinglePlusAnyoneCanPay,
             }
             .to_vec(),
         );
 
-        let tx = Transaction {
+        Transaction {
             version: BID_PSBT_TX_VERSION,
             lock_time: BID_PSBT_TX_LOCK_TIME,
             input: vec![TxIn {
@@ -482,7 +473,6 @@ impl FullSpaceOut {
                 value: refund_amount,
                 script_pubkey: auctioned_utxo.spaceout.script_pubkey.clone(),
             }],
-        };
-        tx
+        }
     }
 }
diff --git a/protocol/src/prepare.rs b/protocol/src/prepare.rs
index 2b0cfc7..c2e4cc4 100644
--- a/protocol/src/prepare.rs
+++ b/protocol/src/prepare.rs
@@ -1,14 +1,19 @@
 use alloc::{vec, vec::Vec};
 
+use crate::script::{OpenContext, find_op_set_data, load_open_context};
+use crate::{
+    Bytes, SpaceOut,
+    errors::Result,
+    hasher::{KeyHasher, SpaceKey},
+    script::OpenResult,
+};
+use bitcoin::taproot::LeafVersion;
 use bitcoin::{
+    Amount, OutPoint, Transaction, TxOut,
     absolute::LockTime,
     opcodes::all::OP_RETURN,
     secp256k1::{schnorr, schnorr::Signature},
-    Amount, OutPoint, Transaction, TxOut,
 };
-use bitcoin::taproot::LeafVersion;
-use crate::{errors::Result, hasher::{KeyHasher, SpaceKey}, script::{OpenResult}, Bytes, SpaceOut};
-use crate::script::{find_op_set_data, load_open_context, OpenContext};
 
 const COMPRESSED_PSBT_SIZE: usize = 65;
 
@@ -73,7 +78,7 @@ impl TxContext {
         tx: &Transaction,
     ) -> Result<Option<TxContext>> {
         let mut proposed_space = None;
-        if !Self::spending_spaces(src, &tx)? {
+        if !Self::spending_spaces(src, tx)? {
             if is_magic_lock_time(&tx.lock_time)
                 && tx.output.iter().any(|out| out.is_magic_output())
             {
@@ -90,7 +95,7 @@ impl TxContext {
         }
 
         let mut inputs = Vec::with_capacity(tx.input.len());
-        let auctioned_output = match Self::get_bid_psbt(&tx) {
+        let auctioned_output = match Self::get_bid_psbt(tx) {
             None => None,
             Some(out) => Some(AuctionedOutput {
                 output: src.get_spaceout(&out.outpoint)?,
@@ -106,19 +111,18 @@ impl TxContext {
             let sstxo = SSTXO {
                 previous_output: spaceout,
             };
-            let spacein = InputContext {
-                n,
-                sstxo,
-            };
+            let spacein = InputContext { n, sstxo };
 
             // Check for a name revealed in the witness
-            if auctioned_output.is_some() && proposed_space.is_none() {
-                if let Some(leaf_script) = input.witness
+            if auctioned_output.is_some()
+                && proposed_space.is_none()
+                && let Some(leaf_script) = input
+                    .witness
                     .taproot_leaf_script()
-                    .filter(|ls| ls.version == LeafVersion::TapScript) {
-                    proposed_space = load_open_context::<T, H>(src, leaf_script.script)?
-                        .map(|o| (n, o));
-                }
+                    .filter(|ls| ls.version == LeafVersion::TapScript)
+            {
+                proposed_space =
+                    load_open_context::<T, H>(src, leaf_script.script)?.map(|o| (n, o));
             }
 
             inputs.push(spacein)
@@ -139,10 +143,7 @@ impl TxContext {
             return None;
         }
 
-        let cpsbt = match Self::cpsbt_from_script(tx.output[0].script_pubkey.as_bytes()) {
-            None => return None,
-            Some(c) => c,
-        };
+        let cpsbt = Self::cpsbt_from_script(tx.output[0].script_pubkey.as_bytes())?;
 
         let bid = BidPsbt {
             outpoint: OutPoint {
@@ -165,7 +166,7 @@ impl TxContext {
             return None;
         }
 
-        let script_ref: &[u8] = script.as_ref();
+        let script_ref: &[u8] = script;
         let cpsbt: &[u8] = &script_ref[2..];
 
         let cpsbt = CPsbt {
diff --git a/protocol/src/script.rs b/protocol/src/script.rs
index c221aa1..44834a7 100644
--- a/protocol/src/script.rs
+++ b/protocol/src/script.rs
@@ -1,13 +1,24 @@
 use alloc::vec::Vec;
 
+use bitcoin::opcodes::all::{OP_PUSHNUM_1, OP_RETURN};
+use bitcoin::{
+    Script, ScriptBuf, TxOut,
+    opcodes::all::OP_DROP,
+    script,
+    script::{Instruction, PushBytesBuf},
+};
 #[cfg(feature = "borsh")]
 use borsh::{BorshDeserialize, BorshSerialize};
-use bitcoin::{opcodes::all::OP_DROP, script, script::{Instruction, PushBytesBuf}, Script, ScriptBuf, TxOut};
-use bitcoin::opcodes::all::{OP_PUSHNUM_1, OP_RETURN};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::{hasher::{KeyHasher, SpaceKey}, prepare::SpacesSource, slabel::{SLabel, SLabelRef}, validate::RejectParams, Bytes, FullSpaceOut};
+use crate::{
+    Bytes, FullSpaceOut,
+    hasher::{KeyHasher, SpaceKey},
+    prepare::SpacesSource,
+    slabel::{SLabel, SLabelRef},
+    validate::RejectParams,
+};
 
 /// Ways that a script might fail. Not everything is split up as
 /// much as it could be; patches welcome if more detailed errors
@@ -41,20 +52,21 @@ pub enum OpenContext {
 }
 
 /// To set data associated with a space, we use:
-/// OP_RETURN OP_PUSHNUM_1 <op push bytes> <data>
+/// `OP_RETURN OP_PUSHNUM_1 <op push bytes> <data>`
 pub fn find_op_set_data(tx_outputs: &[TxOut]) -> Option<Bytes> {
     tx_outputs.iter().find_map(|s| {
         let mut instructions = s.script_pubkey.instructions().skip(1);
         match (instructions.next()?.ok()?, instructions.next()?.ok()?) {
-            (Instruction::Op(OP_PUSHNUM_1), Instruction::PushBytes(bytes)) =>
-                Some(Bytes::new(bytes.as_bytes().to_vec())),
+            (Instruction::Op(OP_PUSHNUM_1), Instruction::PushBytes(bytes)) => {
+                Some(Bytes::new(bytes.as_bytes().to_vec()))
+            }
             _ => None,
         }
     })
 }
 
 /// Create data OP_RETURN script for spaces/PTRs
-/// Format: OP_RETURN OP_PUSHNUM_1 <data>
+/// Format: `OP_RETURN OP_PUSHNUM_1 <data>`
 pub fn create_data_script(data: &[u8]) -> ScriptBuf {
     let mut buf = PushBytesBuf::new();
     buf.extend_from_slice(data).expect("valid");
@@ -86,7 +98,7 @@ pub fn nop_script(space_script: Vec<u8>) -> script::Builder {
 
 pub fn load_open_context<T: SpacesSource, H: KeyHasher>(
     src: &mut T,
-    script: &Script
+    script: &Script,
 ) -> crate::errors::Result<Option<OpenResult<OpenContext>>> {
     let name = match find_open(script) {
         Some(Ok(name)) => name,
@@ -114,7 +126,6 @@ pub fn load_open_context<T: SpacesSource, H: KeyHasher>(
     Ok(Some(Ok(ctx)))
 }
 
-
 fn find_open(script: &Script) -> Option<OpenResult<SLabelRef<'_>>> {
     // Find the first OP_PUSH bytes in a bitcoin script prefixed with our magic
     let mut open_bytes = None;
@@ -131,8 +142,7 @@ fn find_open(script: &Script) -> Option<OpenResult<SLabelRef<'_>>> {
                     continue;
                 }
                 bytes = &bytes[OPEN_MAGIC.len()..];
-                let name = SLabelRef::try_from(bytes)
-                    .map_err(|_| OpenError::MalformedName);
+                let name = SLabelRef::try_from(bytes).map_err(|_| OpenError::MalformedName);
                 open_bytes = Some(name);
                 break;
             }
@@ -142,7 +152,6 @@ fn find_open(script: &Script) -> Option<OpenResult<SLabelRef<'_>>> {
     open_bytes
 }
 
-
 impl core::fmt::Display for OpenError {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         use OpenError::*;
@@ -161,15 +170,15 @@ mod tests {
     use core::str::FromStr;
 
     use bitcoin::{
-        hashes::Hash as OtherHash, opcodes, script::PushBytesBuf, OutPoint, ScriptBuf, Txid,
+        OutPoint, ScriptBuf, Txid, hashes::Hash as OtherHash, opcodes, script::PushBytesBuf,
     };
 
     use crate::{
+        Covenant, FullSpaceOut, Space, SpaceOut,
         hasher::{Hash, KeyHasher, SpaceKey},
         prepare::SpacesSource,
-        script::{create_open_data, load_open_context, OpenContext, OpenError, OPEN_MAGIC},
+        script::{OPEN_MAGIC, OpenContext, OpenError, create_open_data, load_open_context},
         slabel::SLabel,
-        Covenant, FullSpaceOut, Space, SpaceOut,
     };
 
     pub struct DummySource {
@@ -248,7 +257,7 @@ mod tests {
         let mut builder = ScriptBuf::new();
 
         // Doesn't matter just throwing some dummy script
-        builder.push_slice(&[0u8; 32]);
+        builder.push_slice([0u8; 32]);
         builder.push_opcode(opcodes::all::OP_CHECKSIG);
 
         // Should ignore magic without an opcode
diff --git a/protocol/src/slabel.rs b/protocol/src/slabel.rs
index dab8875..4bbfac7 100644
--- a/protocol/src/slabel.rs
+++ b/protocol/src/slabel.rs
@@ -6,7 +6,7 @@ use core::{
 };
 
 #[cfg(feature = "serde")]
-use serde::{de::Error as ErrorUtil, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error as ErrorUtil};
 
 use crate::{constants::RESERVED_SPACES, errors::Error};
 
@@ -18,7 +18,7 @@ pub struct SLabel([u8; MAX_LABEL_LEN + 1]);
 
 #[cfg(feature = "borsh")]
 pub mod borsh_impl {
-    use borsh::{io, BorshDeserialize, BorshSerialize};
+    use borsh::{BorshDeserialize, BorshSerialize, io};
 
     use super::*;
 
@@ -165,12 +165,16 @@ impl<'a> TryFrom<&'a [u8]> for SLabelRef<'a> {
         if label[1] == b'#' {
             let content = &label[2..];
             // Find first dash (block-txpos boundary)
-            let d1 = content.iter().position(|&c| c == b'-')
+            let d1 = content
+                .iter()
+                .position(|&c| c == b'-')
                 .filter(|&p| p > 0)
                 .ok_or(Error::Name(NameErrorKind::InvalidCharacter))?;
             let rest = &content[d1 + 1..];
             // Find second dash (txpos-vout boundary)
-            let d2 = rest.iter().position(|&c| c == b'-')
+            let d2 = rest
+                .iter()
+                .position(|&c| c == b'-')
                 .filter(|&p| p > 0)
                 .ok_or(Error::Name(NameErrorKind::InvalidCharacter))?;
 
@@ -178,7 +182,9 @@ impl<'a> TryFrom<&'a [u8]> for SLabelRef<'a> {
             let tx_pos = &rest[..d2];
             let vout = &rest[d2 + 1..];
 
-            if block.is_empty() || tx_pos.is_empty() || vout.is_empty()
+            if block.is_empty()
+                || tx_pos.is_empty()
+                || vout.is_empty()
                 || !block.iter().all(|c| c.is_ascii_digit())
                 || !tx_pos.iter().all(|c| c.is_ascii_digit())
                 || !vout.iter().all(|c| c.is_ascii_digit())
@@ -253,8 +259,8 @@ impl TryFrom<&str> for SLabel {
         if value.starts_with('#') {
             return Self::from_str_unprefixed(value);
         }
-        if value.starts_with('@') {
-            return Self::from_str_unprefixed(&value[1..]);
+        if let Some(rest) = value.strip_prefix('@') {
+            return Self::from_str_unprefixed(rest);
         }
         Err(Error::Name(NameErrorKind::NotCanonical))
     }
@@ -273,7 +279,7 @@ impl Display for SLabel {
 
 impl Display for SLabelRef<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self)
+        Display::fmt(&self.to_owned(), f)
     }
 }
 
@@ -540,13 +546,22 @@ mod tests {
         assert!(SLabel::try_from("#123-4").is_err(), "missing vout");
 
         // No digits before first dash
-        assert!(SLabel::try_from("#-3-1").is_err(), "no digits before first dash");
+        assert!(
+            SLabel::try_from("#-3-1").is_err(),
+            "no digits before first dash"
+        );
 
         // No digits between dashes
-        assert!(SLabel::try_from("#3--1").is_err(), "no digits between dashes");
+        assert!(
+            SLabel::try_from("#3--1").is_err(),
+            "no digits between dashes"
+        );
 
         // No digits after second dash
-        assert!(SLabel::try_from("#3-4-").is_err(), "no digits after second dash");
+        assert!(
+            SLabel::try_from("#3-4-").is_err(),
+            "no digits after second dash"
+        );
 
         // Non-digit characters
         assert!(SLabel::try_from("#abc-3-1").is_err(), "letters in block");
diff --git a/protocol/src/sname.rs b/protocol/src/sname.rs
index 80d700c..ad56fcf 100644
--- a/protocol/src/sname.rs
+++ b/protocol/src/sname.rs
@@ -1,8 +1,8 @@
+use crate::slabel::{SLabel, SLabelRef};
 use alloc::string::String;
 use alloc::vec::Vec;
 use core::fmt::{Display, Formatter};
 use core::str::FromStr;
-use crate::slabel::{SLabel, SLabelRef};
 
 pub const MAX_SPACE_LEN: usize = 255;
 pub const MAX_LABEL_LEN: usize = 62;
@@ -20,8 +20,8 @@ pub struct Subname(SLabel);
 #[cfg(feature = "borsh")]
 mod borsh_impl {
     use super::*;
-    use borsh::{BorshDeserialize, BorshSerialize};
     use borsh::io::{Read, Write};
+    use borsh::{BorshDeserialize, BorshSerialize};
 
     impl BorshSerialize for SName {
         fn serialize<W: Write>(&self, writer: &mut W) -> borsh::io::Result<()> {
@@ -45,8 +45,9 @@ mod borsh_impl {
     impl BorshDeserialize for Subname {
         fn deserialize_reader<R: Read>(reader: &mut R) -> borsh::io::Result<Self> {
             let bytes: Vec<u8> = BorshDeserialize::deserialize_reader(reader)?;
-            let slabel = SLabel::try_from(bytes.as_slice())
-                .map_err(|e| borsh::io::Error::new(borsh::io::ErrorKind::InvalidData, alloc::format!("{}", e)))?;
+            let slabel = SLabel::try_from(bytes.as_slice()).map_err(|e| {
+                borsh::io::Error::new(borsh::io::ErrorKind::InvalidData, alloc::format!("{}", e))
+            })?;
             Ok(Subname(slabel))
         }
     }
@@ -60,7 +61,10 @@ impl Subname {
 
 impl Display for Subname {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        let s = self.0.to_string_unprefixed().map_err(|_| core::fmt::Error)?;
+        let s = self
+            .0
+            .to_string_unprefixed()
+            .map_err(|_| core::fmt::Error)?;
         write!(f, "{}", s)
     }
 }
@@ -81,7 +85,9 @@ impl Display for Error {
         match self {
             Error::Empty => write!(f, "name is empty"),
             Error::TooLong => write!(f, "name exceeds maximum length of {} bytes", MAX_SPACE_LEN),
-            Error::LabelTooLong => write!(f, "label exceeds maximum length of {} bytes", MAX_LABEL_LEN),
+            Error::LabelTooLong => {
+                write!(f, "label exceeds maximum length of {} bytes", MAX_LABEL_LEN)
+            }
             Error::MissingNullTerminator => write!(f, "missing null terminator"),
             Error::InvalidLabelLength => write!(f, "invalid label length byte"),
             Error::InvalidCharacter => write!(f, "invalid character"),
@@ -117,7 +123,7 @@ pub trait NameLike {
 
     fn label_count(&self) -> usize {
         let mut count = 0;
-        let mut slice = &self.inner_bytes()[..];
+        let mut slice = self.inner_bytes();
         while !slice.is_empty() && slice[0] != 0 {
             slice = &slice[slice[0] as usize + 1..];
             count += 1;
@@ -127,7 +133,7 @@ pub trait NameLike {
 
     #[inline(always)]
     fn iter(&self) -> LabelIterator<'_> {
-        LabelIterator(&self.inner_bytes()[..])
+        LabelIterator(self.inner_bytes())
     }
 }
 
@@ -285,8 +291,7 @@ impl TryFrom<&str> for SName {
                 continue;
             }
 
-            let slabel = SLabel::from_str_unprefixed(label)
-                .map_err(|_| Error::InvalidCharacter)?;
+            let slabel = SLabel::from_str_unprefixed(label).map_err(|_| Error::InvalidCharacter)?;
             let slabel_bytes = slabel.as_ref();
             let slabel_len = slabel_bytes.len();
 
@@ -392,8 +397,8 @@ impl<'a> Iterator for LabelIterator<'a> {
 #[cfg(feature = "serde")]
 mod serde_impl {
     use super::*;
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
     use serde::de::{Error as DeError, SeqAccess, Visitor};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
     impl Serialize for SName {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -443,7 +448,7 @@ mod serde_impl {
         {
             if deserializer.is_human_readable() {
                 let s = <String as Deserialize>::deserialize(deserializer)?;
-                SName::from_str(&s).map_err(|e| serde::de::Error::custom(e))
+                SName::from_str(&s).map_err(serde::de::Error::custom)
             } else {
                 deserializer.deserialize_seq(SNameVisitorBytes)
             }
@@ -505,23 +510,27 @@ mod tests {
 
         assert!(SName::try_from(b"\x03bob\x07bitcoin\x00").is_ok());
         assert_eq!(
-            SName::try_from(b"\x03bob\x07bitcoin\x00").unwrap().label_count(),
+            SName::try_from(b"\x03bob\x07bitcoin\x00")
+                .unwrap()
+                .label_count(),
             2,
         );
 
         let mut max_label = vec![0x3e];
-        max_label.extend_from_slice(&vec![b'a'; 62]);
+        max_label.extend_from_slice(&[b'a'; 62]);
         max_label.push(0x00);
         assert!(SName::try_from(&max_label).is_ok());
 
         let mut too_long_label = vec![0x3f];
-        too_long_label.extend_from_slice(&vec![b'a'; 63]);
+        too_long_label.extend_from_slice(&[b'a'; 63]);
         too_long_label.push(0x00);
         assert!(SName::try_from(&too_long_label).is_err());
 
         assert!(SName::try_from(b"\x03bob\x00\x03foo").is_ok());
         assert_eq!(
-            SName::try_from(b"\x03bob\x00\x03foo").unwrap().label_count(),
+            SName::try_from(b"\x03bob\x00\x03foo")
+                .unwrap()
+                .label_count(),
             1,
         );
 
@@ -680,4 +689,4 @@ mod tests {
         let restored = SName::try_from(bytes).unwrap();
         assert_eq!(name, restored);
     }
-}
\ No newline at end of file
+}
diff --git a/protocol/src/validate.rs b/protocol/src/validate.rs
index 316d0ff..2636ba5 100644
--- a/protocol/src/validate.rs
+++ b/protocol/src/validate.rs
@@ -1,17 +1,17 @@
 use alloc::{vec, vec::Vec};
 
+use bitcoin::{Amount, OutPoint, Transaction, Txid};
 #[cfg(feature = "borsh")]
 use borsh::{BorshDeserialize, BorshSerialize};
-use bitcoin::{Amount, OutPoint, Transaction, Txid};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    BidPsbtReason, Bytes, Covenant, FullSpaceOut, RejectReason, RevokeReason, Space, SpaceOut,
     constants::{AUCTION_DURATION, AUCTION_EXTENSION_ON_BID, RENEWAL_INTERVAL, ROLLOUT_BATCH_SIZE},
-    prepare::{AuctionedOutput, TrackableOutput, TxContext, SSTXO},
+    prepare::{AuctionedOutput, SSTXO, TrackableOutput, TxContext},
     script::{OpenContext, OpenError},
     slabel::SLabel,
-    BidPsbtReason, Bytes, Covenant, FullSpaceOut, RejectReason, RevokeReason, Space, SpaceOut,
 };
 
 #[derive(Debug, Clone)]
@@ -113,6 +113,12 @@ pub struct EventOutput {
     pub spaceout: SpaceOut,
 }
 
+impl Default for Validator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Validator {
     pub fn new() -> Validator {
         Self {}
@@ -162,13 +168,14 @@ impl Validator {
                     );
                 }
                 Err(e) => {
-                    let input =
-                        changeset.spends.iter_mut().find(|s| s.n == open_idx)
-                            .expect("input for open should exist");
+                    let input = changeset
+                        .spends
+                        .iter_mut()
+                        .find(|s| s.n == open_idx)
+                        .expect("input for open should exist");
                     input.script_error = Some(e);
                 }
             }
-
         }
 
         // Check if any outputs should be tracked
@@ -245,15 +252,13 @@ impl Validator {
         if let Some(auctioned) = meta
             .auctioned_output
             .as_ref()
-            .and_then(|out| Some(out.bid_psbt.outpoint))
-        {
-            if tx
+            .map(|out| out.bid_psbt.outpoint)
+            && tx
                 .input
                 .iter()
                 .any(|input| input.previous_output == auctioned)
-            {
-                meta.auctioned_output.as_mut().unwrap().output = None;
-            }
+        {
+            meta.auctioned_output.as_mut().unwrap().output = None;
         }
     }
 
@@ -284,9 +289,10 @@ impl Validator {
                 }
 
                 // Revoke the previously expired space
-                if !changeset.updates.iter()
-                    .any(|update| update.output.outpoint() == prev.outpoint() &&
-                        matches!(update.kind, UpdateKind::Revoke(_))) {
+                if !changeset.updates.iter().any(|update| {
+                    update.output.outpoint() == prev.outpoint()
+                        && matches!(update.kind, UpdateKind::Revoke(_))
+                }) {
                     changeset.updates.push(UpdateOut {
                         kind: UpdateKind::Revoke(RevokeReason::Expired),
                         output: FullSpaceOut {
@@ -388,6 +394,7 @@ impl Validator {
 
     /// All spends with a spent spaces transaction output must be
     /// marked as spent as this function only does additional processing for spends of spaces
+    #[allow(clippy::too_many_arguments)]
     fn process_spend(
         &self,
         height: u32,
@@ -396,7 +403,7 @@ impl Validator {
         input_index: usize,
         stxo: SSTXO,
         changeset: &mut TxChangeSet,
-        data: &Option<Bytes>
+        data: &Option<Bytes>,
     ) {
         let spaceout = &stxo.previous_output;
         let space = match &spaceout.space {
@@ -455,6 +462,7 @@ impl Validator {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn process_bid_spend(
         &self,
         height: u32,
@@ -466,7 +474,7 @@ impl Validator {
         claim_height: Option<u32>,
         changeset: &mut TxChangeSet,
     ) {
-        let input = tx.input.get(input_index as usize).expect("input");
+        let input = tx.input.get(input_index).expect("input");
         let spaceout = stxo.previous_output;
         let space_ref = spaceout.space.as_ref().unwrap();
         // Handle bid spends
@@ -596,12 +604,7 @@ impl Validator {
             Some(output) => {
                 // check if there's an existing space output created by this transaction
                 // representing another space somehow (should never be possible anyway?)
-                if changeset
-                    .creates
-                    .iter()
-                    .position(|x| x.n == output_index)
-                    .is_some()
-                {
+                if changeset.creates.iter().any(|x| x.n == output_index) {
                     changeset.updates.push(UpdateOut {
                         output: FullSpaceOut {
                             txid: input.previous_output.txid,
diff --git a/release-plz.toml b/release-plz.toml
new file mode 100644
index 0000000..e5f3c6d
--- /dev/null
+++ b/release-plz.toml
@@ -0,0 +1,106 @@
+[workspace]
+changelog_path = "CHANGELOG.md"
+changelog_update = true
+pr_draft = false
+
+[changelog]
+header = """# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+"""
+
+body = """
+## [{{ version | trim_start_matches(pat=\"v\") }}]\
+  {%- if release_link -%}\
+    ({{ release_link }})\
+  {% endif %} - {{ timestamp | date(format=\"%Y-%m-%d\") }}
+{% for group, commits in commits | group_by(attribute=\"group\") %}
+### {{ group | upper_first }}
+{% for commit in commits %}
+- {% if commit.scope %}*({{ commit.scope }})* {% endif %}\
+    {% if commit.breaking %}[**breaking**] {% endif %}\
+    {{ commit.message | upper_first }}\
+{% endfor %}
+{% endfor %}
+"""
+
+commit_parsers = [
+  { message = "^feat", group = "Features" },
+  { message = "^fix", group = "Bug Fixes" },
+  { message = "^perf", group = "Performance" },
+  { message = "^refactor", group = "Refactor" },
+  { message = "^docs", group = "Documentation" },
+  { message = "^test", group = "Tests" },
+  { message = "^build", group = "Build" },
+  { message = "^ci", group = "CI" },
+  { message = "^chore\\(release\\)", skip = true },
+  { message = "^chore", group = "Chore" },
+  { message = "^revert", group = "Revert" },
+]
+
+# Publishable crates — published to crates.io + GitHub release on tag.
+[[package]]
+name = "borsh_utils"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "borsh_utils-v{{ version }}"
+
+[[package]]
+name = "spaces_protocol"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "spaces_protocol-v{{ version }}"
+
+[[package]]
+name = "spaces_nums"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "spaces_nums-v{{ version }}"
+
+[[package]]
+name = "sip7"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "sip7-v{{ version }}"
+
+[[package]]
+name = "spaces_wallet"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "spaces_wallet-v{{ version }}"
+
+[[package]]
+name = "spaces_client"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "spaces_client-v{{ version }}"
+git_release_body = """
+> ⚠️ **Subspaces preview — for mainnet alpha testing.**
+>
+> This release is built from the `subspaces` branch and ships new protocol changes. If you are running a production mainnet node, continue using the latest `v0.0.9a` release from the `main` branch:
+> https://github.com/spacesprotocol/spaces/releases/tag/v0.0.9a
+
+{{ changelog }}
+"""
+
+[[package]]
+name = "spaces_checkpoint"
+publish = true
+git_release_enable = true
+git_release_latest = false
+git_tag_name = "spaces_checkpoint-v{{ version }}"
+
+# Internal test-only crate; never released.
+[[package]]
+name = "spaces_testutil"
+release = false
+publish = false
\ No newline at end of file
diff --git a/sip7/Cargo.toml b/sip7/Cargo.toml
index 023a8b1..30f74fc 100644
--- a/sip7/Cargo.toml
+++ b/sip7/Cargo.toml
@@ -1,13 +1,19 @@
 [package]
 name = "sip7"
-version = "0.1.0"
-edition = "2021"
+description = "Signed Inscribed Packets (SIP-7): signed resource-record payloads for the Spaces protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [dependencies]
 serde = { version = "1.0", features = ["derive", "alloc"], default-features = false, optional = true }
 base64 = { workspace = true, optional = true }
 hex = { workspace = true, optional = true }
-spaces_protocol = { path = "../protocol", default-features = false }
+spaces_protocol = { workspace = true }
 
 [dev-dependencies]
 serde_json = { workspace = true }
diff --git a/sip7/src/lib.rs b/sip7/src/lib.rs
index fc70cc7..4b7f67d 100644
--- a/sip7/src/lib.rs
+++ b/sip7/src/lib.rs
@@ -35,6 +35,7 @@ pub const SIG_PRIMARY_ZONE: u8 = 0x01;
 
 /// A single record in a SIP-7 record set.
 #[derive(Clone, Debug, PartialEq, Eq)]
+#[allow(clippy::large_enum_variant)]
 pub enum Record {
     Seq(u64),
     Txt {
@@ -71,7 +72,7 @@ pub struct SigData {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Signable<'a> {
-    pub bytes: &'a[u8],
+    pub bytes: &'a [u8],
     pub sig: Option<SigData>,
 }
 
@@ -107,7 +108,12 @@ impl Record {
 
     /// Creates a SIG record.
     pub fn sig(canonical: SName, handle: SName, sig: Vec<u8>, flags: u8) -> Self {
-        Record::Sig { flags, canonical, handle, sig }
+        Record::Sig {
+            flags,
+            canonical,
+            handle,
+            sig,
+        }
     }
 
     /// Creates an unknown record type (preserved for round-tripping).
@@ -382,7 +388,9 @@ impl RecordSet {
         while pos < data.len() {
             let rtype = data[pos];
             let mut rpos = pos + 1;
-            let Ok(rlen) = read_compact_size(data, &mut rpos) else { break };
+            let Ok(rlen) = read_compact_size(data, &mut rpos) else {
+                break;
+            };
             let rlen = rlen as usize;
             if rpos + rlen > data.len() {
                 break;
@@ -399,11 +407,13 @@ impl RecordSet {
             pos = rpos + rlen;
         }
 
-        Signable { bytes: data, sig: None }
+        Signable {
+            bytes: data,
+            sig: None,
+        }
     }
 }
 
-
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -510,15 +520,19 @@ fn parse_sig_rdata(rdata: &[u8]) -> Result<(SigData, usize), Error> {
     let rest = &rdata[1..];
     let canonical_ref = SNameRef::try_from(rest).map_err(|_| Error::InvalidSName)?;
     let after_canonical = canonical_ref.to_bytes().len();
-    let handle_ref = SNameRef::try_from(&rest[after_canonical..]).map_err(|_| Error::InvalidSName)?;
+    let handle_ref =
+        SNameRef::try_from(&rest[after_canonical..]).map_err(|_| Error::InvalidSName)?;
     let sig_offset = 1 + after_canonical + handle_ref.to_bytes().len();
     let sig_bytes = &rdata[sig_offset..];
-    Ok((SigData {
-        flags,
-        canonical: canonical_ref.to_owned(),
-        handle: handle_ref.to_owned(),
-        sig: sig_bytes.to_vec(),
-    }, sig_offset))
+    Ok((
+        SigData {
+            flags,
+            canonical: canonical_ref.to_owned(),
+            handle: handle_ref.to_owned(),
+            sig: sig_bytes.to_vec(),
+        },
+        sig_offset,
+    ))
 }
 
 fn parse_kv(data: &[u8]) -> Result<(String, &[u8]), Error> {
@@ -606,18 +620,33 @@ pub struct ParsedSig<'a> {
     pub sig: &'a [u8],
 }
 
-/// A zero-copy parsed record. Returned from [`RecordsIter::iter`].
+/// A zero-copy parsed record. Yielded by [`RecordsIter`].
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ParsedRecord<'a> {
     Seq(u64),
-    Txt { key: &'a str, value: TextValues<'a> },
-    Blob { key: &'a str, value: &'a [u8] },
-    Addr { key: &'a str, value: TextValues<'a> },
+    Txt {
+        key: &'a str,
+        value: TextValues<'a>,
+    },
+    Blob {
+        key: &'a str,
+        value: &'a [u8],
+    },
+    Addr {
+        key: &'a str,
+        value: TextValues<'a>,
+    },
     Sig(ParsedSig<'a>),
     /// Known record type but rdata could not be parsed.
-    Malformed { rtype: u8, rdata: &'a [u8] },
+    Malformed {
+        rtype: u8,
+        rdata: &'a [u8],
+    },
     /// Unknown record type.
-    Unknown { rtype: u8, rdata: &'a [u8] },
+    Unknown {
+        rtype: u8,
+        rdata: &'a [u8],
+    },
 }
 
 impl<'a> From<ParsedRecord<'a>> for Record {
@@ -701,7 +730,9 @@ fn parse_record<'a>(rtype: u8, rdata: &'a [u8]) -> ParsedRecord<'a> {
             let values = TextValues(val_bytes);
             let mut check = TextValuesIter(val_bytes);
             let mut count = 0;
-            while let Some(_) = check.next() { count += 1; }
+            for _ in check.by_ref() {
+                count += 1;
+            }
             if !check.0.is_empty() || (count == 0 && !val_bytes.is_empty()) {
                 return ParsedRecord::Malformed { rtype, rdata };
             }
@@ -715,7 +746,10 @@ fn parse_record<'a>(rtype: u8, rdata: &'a [u8]) -> ParsedRecord<'a> {
             let Some((key, val_bytes)) = parse_kv_ref(rdata) else {
                 return ParsedRecord::Malformed { rtype, rdata };
             };
-            ParsedRecord::Blob { key, value: val_bytes }
+            ParsedRecord::Blob {
+                key,
+                value: val_bytes,
+            }
         }
         TYPE_SIG => {
             if rdata.is_empty() {
@@ -731,7 +765,12 @@ fn parse_record<'a>(rtype: u8, rdata: &'a [u8]) -> ParsedRecord<'a> {
                 return ParsedRecord::Malformed { rtype, rdata };
             };
             let sig = &after_canonical[handle.to_bytes().len()..];
-            ParsedRecord::Sig(ParsedSig { flags, canonical, handle, sig })
+            ParsedRecord::Sig(ParsedSig {
+                flags,
+                canonical,
+                handle,
+                sig,
+            })
         }
         _ => ParsedRecord::Unknown { rtype, rdata },
     }
@@ -769,13 +808,19 @@ impl RecordSet {
             }
 
             if rtype == TYPE_SEQ {
-                if seen_seq { return Err(Error::DuplicateSeq); }
-                if index > 0 { return Err(Error::SeqNotFirst); }
+                if seen_seq {
+                    return Err(Error::DuplicateSeq);
+                }
+                if index > 0 {
+                    return Err(Error::SeqNotFirst);
+                }
                 seen_seq = true;
             }
 
             if rtype == TYPE_SIG {
-                if seen_sig { return Err(Error::DuplicateSig); }
+                if seen_sig {
+                    return Err(Error::DuplicateSig);
+                }
                 seen_sig = true;
                 last_was_sig = true;
             }
@@ -791,7 +836,7 @@ impl RecordSet {
 #[cfg(feature = "serde")]
 mod serde_impl {
     use super::*;
-    use base64::prelude::{Engine, BASE64_STANDARD};
+    use base64::prelude::{BASE64_STANDARD, Engine};
     use serde::de::{self, SeqAccess, Visitor};
     use serde::ser::SerializeSeq;
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -952,7 +997,8 @@ mod serde_impl {
         where
             S: Serializer,
         {
-            let records: Vec<Record> = self.iter()
+            let records: Vec<Record> = self
+                .iter()
                 .map_err(serde::ser::Error::custom)?
                 .map(|r| r.into())
                 .collect();
@@ -986,7 +1032,7 @@ mod serde_impl {
                     while let Some(record) = seq.next_element::<Record>()? {
                         records.push(record);
                     }
-                    Ok(RecordSet::pack(records).map_err(de::Error::custom)?)
+                    RecordSet::pack(records).map_err(de::Error::custom)
                 }
             }
 
@@ -1180,14 +1226,17 @@ mod tests {
         let rs = RecordSet::pack(vec![
             Record::txt("btc", &["bc1qtest"]),
             Record::sig(canonical.clone(), handle.clone(), sig_bytes.clone(), 0),
-        ]).unwrap();
+        ])
+        .unwrap();
 
         let signable = rs.signable();
 
         // signable bytes should not contain the raw signature
         assert!(!signable.bytes.is_empty());
-        assert!(signable.bytes.len() < rs.as_slice().len(),
-            "signable should be shorter than full record set");
+        assert!(
+            signable.bytes.len() < rs.as_slice().len(),
+            "signable should be shorter than full record set"
+        );
 
         // sig data should be present
         let sig = signable.sig.expect("should have sig");
@@ -1199,10 +1248,16 @@ mod tests {
         // signable bytes should include TXT record + SIG header (flags, canonical, handle)
         // but not the signature itself
         let full = rs.as_slice();
-        assert_eq!(&full[..signable.bytes.len()], signable.bytes,
-            "signable should be a prefix of the full record set");
-        assert_eq!(&full[signable.bytes.len()..], &sig_bytes,
-            "remainder should be exactly the sig bytes");
+        assert_eq!(
+            &full[..signable.bytes.len()],
+            signable.bytes,
+            "signable should be a prefix of the full record set"
+        );
+        assert_eq!(
+            &full[signable.bytes.len()..],
+            &sig_bytes,
+            "remainder should be exactly the sig bytes"
+        );
     }
 
     #[test]
@@ -1210,10 +1265,15 @@ mod tests {
         let rs = RecordSet::pack(vec![
             Record::txt("btc", &["bc1qtest"]),
             Record::txt("nostr", &["npub1abc"]),
-        ]).unwrap();
+        ])
+        .unwrap();
 
         let signable = rs.signable();
-        assert_eq!(signable.bytes, rs.as_slice(), "no SIG means signable == full record set");
+        assert_eq!(
+            signable.bytes,
+            rs.as_slice(),
+            "no SIG means signable == full record set"
+        );
         assert!(signable.sig.is_none());
     }
 
@@ -1224,9 +1284,13 @@ mod tests {
         let handle = SName::empty();
         let sig_bytes = vec![0x01, 0x02];
 
-        let rs = RecordSet::pack(vec![
-            Record::sig(canonical.clone(), handle.clone(), sig_bytes.clone(), 0),
-        ]).unwrap();
+        let rs = RecordSet::pack(vec![Record::sig(
+            canonical.clone(),
+            handle.clone(),
+            sig_bytes.clone(),
+            0,
+        )])
+        .unwrap();
 
         let sig = rs.sig().expect("should have sig");
         assert_eq!(sig.canonical, canonical);
@@ -1241,7 +1305,8 @@ mod tests {
         let err = RecordSet::pack(vec![
             Record::sig(canonical, SName::empty(), vec![0x01], 0),
             Record::txt("btc", &["bc1q"]),
-        ]).unwrap_err();
+        ])
+        .unwrap_err();
         assert_eq!(err, Error::SigNotLast);
     }
 
@@ -1253,7 +1318,8 @@ mod tests {
         let err = RecordSet::pack(vec![
             Record::sig(canonical.clone(), SName::empty(), vec![0x01], 0),
             Record::sig(canonical, SName::empty(), vec![0x02], 0),
-        ]).unwrap_err();
+        ])
+        .unwrap_err();
         assert_eq!(err, Error::SigNotLast);
     }
 
@@ -1500,7 +1566,13 @@ mod tests {
         let rs = RecordSet::new(data);
         let records = rs.unpack().unwrap();
         assert_eq!(records.len(), 1);
-        assert!(matches!(records[0], ParsedRecord::Malformed { rtype: TYPE_TXT, .. }));
+        assert!(matches!(
+            records[0],
+            ParsedRecord::Malformed {
+                rtype: TYPE_TXT,
+                ..
+            }
+        ));
     }
 
     #[test]
@@ -1519,7 +1591,13 @@ mod tests {
 
         let rs = RecordSet::new(data);
         let records = rs.unpack().unwrap();
-        assert!(matches!(records[0], ParsedRecord::Malformed { rtype: TYPE_ADDR, .. }));
+        assert!(matches!(
+            records[0],
+            ParsedRecord::Malformed {
+                rtype: TYPE_ADDR,
+                ..
+            }
+        ));
     }
 
     #[test]
@@ -1534,7 +1612,13 @@ mod tests {
 
         let rs = RecordSet::new(data);
         let records = rs.unpack().unwrap();
-        assert!(matches!(records[0], ParsedRecord::Malformed { rtype: TYPE_SEQ, .. }));
+        assert!(matches!(
+            records[0],
+            ParsedRecord::Malformed {
+                rtype: TYPE_SEQ,
+                ..
+            }
+        ));
     }
 
     #[test]
@@ -1542,21 +1626,26 @@ mod tests {
         // Value 1 encoded as 0xFD 0x01 0x00 (3 bytes) instead of just 0x01 (1 byte)
         // Craft: TYPE_SEQ + non-minimal rdlength(1) + rdata(0x01)
         let data = vec![
-            TYPE_SEQ,
-            0xFD, 0x01, 0x00, // non-minimal: value 1 using 3-byte encoding
-            0x01,              // version = 1
+            TYPE_SEQ, 0xFD, 0x01, 0x00, // non-minimal: value 1 using 3-byte encoding
+            0x01, // version = 1
         ];
         let rs = RecordSet::new(data);
-        assert!(rs.unpack().is_err(), "non-minimal compact size should be rejected");
-        assert!(rs.iter().is_err(), "structural validation should also reject");
+        assert!(
+            rs.unpack().is_err(),
+            "non-minimal compact size should be rejected"
+        );
+        assert!(
+            rs.iter().is_err(),
+            "structural validation should also reject"
+        );
     }
 
     #[test]
     fn non_minimal_compact_size_0xfe_rejected() {
         // Value 100 encoded as 0xFE (4-byte) instead of 1-byte
         let data = vec![
-            TYPE_SEQ,
-            0xFE, 0x64, 0x00, 0x00, 0x00, // non-minimal: value 100 using 5-byte encoding
+            TYPE_SEQ, 0xFE, 0x64, 0x00, 0x00,
+            0x00, // non-minimal: value 100 using 5-byte encoding
         ];
         let rs = RecordSet::new(data);
         assert!(rs.unpack().is_err());
@@ -1701,9 +1790,7 @@ mod tests {
 
     #[test]
     fn records_zero_copy_txt() {
-        let rs = RecordSet::pack(vec![
-            Record::txt("btc", &["bc1qtest", "bc1qother"]),
-        ]).unwrap();
+        let rs = RecordSet::pack(vec![Record::txt("btc", &["bc1qtest", "bc1qother"])]).unwrap();
 
         let parsed: Vec<_> = rs.iter().unwrap().collect();
         assert_eq!(parsed.len(), 1);
@@ -1719,9 +1806,7 @@ mod tests {
 
     #[test]
     fn records_zero_copy_addr() {
-        let rs = RecordSet::pack(vec![
-            Record::addr("eth", &["0xdead", "0xbeef"]),
-        ]).unwrap();
+        let rs = RecordSet::pack(vec![Record::addr("eth", &["0xdead", "0xbeef"])]).unwrap();
 
         let parsed: Vec<_> = rs.iter().unwrap().collect();
         match &parsed[0] {
@@ -1735,9 +1820,7 @@ mod tests {
 
     #[test]
     fn records_zero_copy_blob() {
-        let rs = RecordSet::pack(vec![
-            Record::blob("avatar", vec![0x89, 0x50]),
-        ]).unwrap();
+        let rs = RecordSet::pack(vec![Record::blob("avatar", vec![0x89, 0x50])]).unwrap();
 
         let parsed: Vec<_> = rs.iter().unwrap().collect();
         match &parsed[0] {
@@ -1758,7 +1841,8 @@ mod tests {
         let rs = RecordSet::pack(vec![
             Record::txt("btc", &["bc1q"]),
             Record::sig(canonical.clone(), handle.clone(), vec![0xAB, 0xCD], 0),
-        ]).unwrap();
+        ])
+        .unwrap();
 
         let parsed: Vec<_> = rs.iter().unwrap().collect();
         assert_eq!(parsed.len(), 2);
@@ -1775,10 +1859,7 @@ mod tests {
 
     #[test]
     fn records_zero_copy_seq() {
-        let rs = RecordSet::pack(vec![
-            Record::seq(42),
-            Record::txt("a", &["b"]),
-        ]).unwrap();
+        let rs = RecordSet::pack(vec![Record::seq(42), Record::txt("a", &["b"])]).unwrap();
 
         let parsed: Vec<_> = rs.iter().unwrap().collect();
         assert_eq!(parsed.len(), 2);
@@ -1798,7 +1879,13 @@ mod tests {
         let records = rs.iter().unwrap(); // structural validation passes
         let parsed: Vec<_> = records.collect();
         assert_eq!(parsed.len(), 1);
-        assert!(matches!(parsed[0], ParsedRecord::Malformed { rtype: TYPE_TXT, .. }));
+        assert!(matches!(
+            parsed[0],
+            ParsedRecord::Malformed {
+                rtype: TYPE_TXT,
+                ..
+            }
+        ));
     }
 
     #[test]
@@ -1810,7 +1897,10 @@ mod tests {
 
         let rs = RecordSet::new(data);
         let parsed: Vec<_> = rs.iter().unwrap().collect();
-        assert!(matches!(parsed[0], ParsedRecord::Unknown { rtype: 0xFF, .. }));
+        assert!(matches!(
+            parsed[0],
+            ParsedRecord::Unknown { rtype: 0xFF, .. }
+        ));
     }
 
     #[test]
@@ -1818,7 +1908,9 @@ mod tests {
         use core::str::FromStr;
         let canonical = SName::from_str("@bitcoin").unwrap();
         // Manually craft: SIG then TXT
-        let sig_bytes = Record::sig(canonical, SName::empty(), vec![0x01], 0).pack().unwrap();
+        let sig_bytes = Record::sig(canonical, SName::empty(), vec![0x01], 0)
+            .pack()
+            .unwrap();
         let txt_bytes = Record::txt("a", &["b"]).pack().unwrap();
         let mut data = sig_bytes;
         data.extend_from_slice(&txt_bytes);
@@ -1849,7 +1941,13 @@ mod tests {
         let parsed: Vec<_> = records.collect();
         assert_eq!(parsed.len(), 3);
         assert!(matches!(parsed[0], ParsedRecord::Txt { .. }));
-        assert!(matches!(parsed[1], ParsedRecord::Malformed { rtype: TYPE_TXT, .. }));
+        assert!(matches!(
+            parsed[1],
+            ParsedRecord::Malformed {
+                rtype: TYPE_TXT,
+                ..
+            }
+        ));
         assert!(matches!(parsed[2], ParsedRecord::Blob { .. }));
     }
 }
diff --git a/testutil/Cargo.toml b/testutil/Cargo.toml
index a180a52..967f405 100644
--- a/testutil/Cargo.toml
+++ b/testutil/Cargo.toml
@@ -1,7 +1,14 @@
 [package]
 name = "spaces_testutil"
-version = "0.0.1"
-edition = "2021"
+description = "Internal test utilities for the Spaces project."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
+publish = false
 
 [[bin]]
 name = "db-dump"
@@ -9,12 +16,12 @@ path = "src/bin/db_dump.rs"
 
 [dependencies]
 bitcoind = { workspace = true }
-spaces_client = { path = "../client" }
+spaces_client = { workspace = true }
 assert_cmd = { workspace = true }
 anyhow = { workspace = true }
 hex = { workspace = true }
 spacedb = { workspace = true }
-spaces_protocol = { path = "../protocol", features = ["std", "serde"] }
+spaces_protocol = { workspace = true, features = ["std", "serde"] }
 borsh = { version = "1.5", features = ["derive"] }
 serde_json = { workspace = true }
 tokio = { workspace = true }
diff --git a/testutil/build.rs b/testutil/build.rs
index 01a8e8b..547db84 100644
--- a/testutil/build.rs
+++ b/testutil/build.rs
@@ -18,7 +18,7 @@ fn main() -> io::Result<()> {
     fs::create_dir_all(&target_dir)?;
 
     // Unpack the ZIP file
-    let zip_file = fs::File::open(&zip_path)?;
+    let zip_file = fs::File::open(zip_path)?;
     let mut archive = zip::ZipArchive::new(zip_file)?;
 
     for i in 0..archive.len() {
@@ -28,10 +28,10 @@ fn main() -> io::Result<()> {
         if file.is_dir() {
             fs::create_dir_all(&outpath)?;
         } else {
-            if let Some(p) = outpath.parent() {
-                if !p.exists() {
-                    fs::create_dir_all(p)?;
-                }
+            if let Some(p) = outpath.parent()
+                && !p.exists()
+            {
+                fs::create_dir_all(p)?;
             }
             let mut outfile = fs::File::create(&outpath)?;
             io::copy(&mut file, &mut outfile)?;
diff --git a/testutil/src/bin/db_dump.rs b/testutil/src/bin/db_dump.rs
index 0691f8d..c985921 100644
--- a/testutil/src/bin/db_dump.rs
+++ b/testutil/src/bin/db_dump.rs
@@ -1,16 +1,21 @@
-use std::path::PathBuf;
+use anyhow::Result;
+use spacedb::{Configuration, Sha256Hasher, db::Database, fs::FileBackend};
+use spaces_protocol::{
+    SpaceOut,
+    hasher::{BidKey, OutpointKey, SpaceKey},
+};
 use std::collections::HashMap;
 use std::fs::OpenOptions;
-use anyhow::Result;
-use spaces_protocol::{SpaceOut, hasher::{SpaceKey, OutpointKey, BidKey}};
-use serde_json;
-use spacedb::{db::Database, fs::FileBackend, Configuration, Sha256Hasher};
+use std::path::{Path, PathBuf};
 
 fn main() -> Result<()> {
     let args: Vec<String> = std::env::args().collect();
 
     if args.len() < 3 {
-        eprintln!("Usage: {} --type <spaces|ptrs> <db_path> [compare_db_path]", args[0]);
+        eprintln!(
+            "Usage: {} --type <spaces|ptrs> <db_path> [compare_db_path]",
+            args[0]
+        );
         eprintln!("\nDumps or compares spaces/ptrs databases");
         eprintln!("  <db_path>: Direct path to the database file");
         eprintln!("  [compare_db_path]: Optional second database to compare with");
@@ -41,20 +46,17 @@ fn main() -> Result<()> {
 }
 
 fn open_db(path: PathBuf) -> Result<Database<Sha256Hasher>> {
-    let file = OpenOptions::new()
-        .read(true)
-        .write(false)
-        .open(path)?;
+    let file = OpenOptions::new().read(true).write(false).open(path)?;
 
     let config = Configuration::new().with_cache_size(1000000);
     Ok(Database::new(Box::new(FileBackend::new(file)?), config)?)
 }
 
-fn dump_database(db_type: &str, db_path: &PathBuf) -> Result<()> {
+fn dump_database(db_type: &str, db_path: &Path) -> Result<()> {
     println!("=== Database Dump: {} ===", db_path.display());
     println!("Type: {}\n", db_type);
 
-    let db = open_db(db_path.clone())?;
+    let db = open_db(db_path.to_path_buf())?;
 
     match db_type {
         "spaces" => dump_spaces(&db)?,
@@ -133,15 +135,15 @@ fn dump_ptrs(db: &Database<Sha256Hasher>) -> Result<()> {
     Ok(())
 }
 
-fn compare_databases(db_type: &str, db1_path: &PathBuf, db2_path: &PathBuf) -> Result<()> {
+fn compare_databases(db_type: &str, db1_path: &Path, db2_path: &Path) -> Result<()> {
     println!("=== Comparing Databases ===");
     println!("Type: {}", db_type);
     println!("DB1: {}", db1_path.display());
     println!("DB2: {}", db2_path.display());
     println!();
 
-    let db1 = open_db(db1_path.clone())?;
-    let db2 = open_db(db2_path.clone())?;
+    let db1 = open_db(db1_path.to_path_buf())?;
+    let db2 = open_db(db2_path.to_path_buf())?;
 
     match db_type {
         "spaces" => compare_spaces(&db1, &db2)?,
diff --git a/testutil/src/lib.rs b/testutil/src/lib.rs
index 0dc84db..8ef1ae4 100644
--- a/testutil/src/lib.rs
+++ b/testutil/src/lib.rs
@@ -13,10 +13,10 @@ use ::spaces_client::{
     client::spaces_protocol::{
         bitcoin,
         bitcoin::{
-            absolute, address::NetworkChecked, block, block::Header, hashes::Hash,
-            key::rand::random, transaction, Address, Amount, Block, BlockHash, CompactTarget,
-            OutPoint, ScriptBuf, ScriptHash, Sequence, Transaction, TxIn, TxMerkleNode, TxOut,
-            Txid,
+            Address, Amount, Block, BlockHash, CompactTarget, OutPoint, ScriptBuf, ScriptHash,
+            Sequence, Transaction, TxIn, TxMerkleNode, TxOut, Txid, absolute,
+            address::NetworkChecked, block, block::Header, hashes::Hash, key::rand::random,
+            transaction,
         },
     },
     jsonrpsee::tokio,
@@ -24,14 +24,14 @@ use ::spaces_client::{
 };
 use anyhow::Result;
 use bitcoind::{
-    anyhow,
-    anyhow::{anyhow, Context},
+    BitcoinD, anyhow,
+    anyhow::{Context, anyhow},
     bitcoincore_rpc::{
+        RpcApi,
         bitcoincore_rpc_json::{GetBlockTemplateModes, GetBlockTemplateRules},
-        json, RpcApi,
+        json,
     },
-    tempfile::{tempdir, TempDir},
-    BitcoinD,
+    tempfile::{TempDir, tempdir},
 };
 
 use crate::spaced::SpaceD;
@@ -67,7 +67,7 @@ impl TestRig {
             "-regtest",
             "-rpcworkqueue=100",
             "-fallbackfee=0.0001",
-            "-rpcauth=user:70dbb4f60ccc95e154da97a43b7a9d06$00c10a3849edf2f10173e80d0bdadbde793ad9a80e6e6f9f71f978fb5c797343"
+            "-rpcauth=user:70dbb4f60ccc95e154da97a43b7a9d06$00c10a3849edf2f10173e80d0bdadbde793ad9a80e6e6f9f71f978fb5c797343",
         ];
 
         conf.staticdir = Some(path.join("bitcoind"));
@@ -92,7 +92,7 @@ impl TestRig {
             "-txindex=1",
             "-rpcworkqueue=100",
             "-fallbackfee=0.0001",
-            "-rpcauth=user:70dbb4f60ccc95e154da97a43b7a9d06$00c10a3849edf2f10173e80d0bdadbde793ad9a80e6e6f9f71f978fb5c797343"
+            "-rpcauth=user:70dbb4f60ccc95e154da97a43b7a9d06$00c10a3849edf2f10173e80d0bdadbde793ad9a80e6e6f9f71f978fb5c797343",
         ];
 
         conf.staticdir = Some(path.join("bitcoind"));
@@ -120,7 +120,7 @@ impl TestRig {
         conf.args = vec![
             "-regtest",
             "-fallbackfee=0.0001",
-            "-rpcauth=user:70dbb4f60ccc95e154da97a43b7a9d06$00c10a3849edf2f10173e80d0bdadbde793ad9a80e6e6f9f71f978fb5c797343"
+            "-rpcauth=user:70dbb4f60ccc95e154da97a43b7a9d06$00c10a3849edf2f10173e80d0bdadbde793ad9a80e6e6f9f71f978fb5c797343",
         ];
 
         Self::new_with_bitcoin_conf(conf, None, None).await
@@ -224,7 +224,7 @@ impl TestRig {
     /// `address`.
     ///
     /// An async verison of bdk's testenv mine_blocks:
-    /// https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs
+    /// <https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs>
     pub async fn mine_blocks(
         &self,
         count: usize,
@@ -250,7 +250,7 @@ impl TestRig {
     /// Mine a block that is guaranteed to be empty even with transactions in the mempool.
     ///
     /// An async version of bdk's testenv mine_empty_block:
-    /// https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs
+    /// <https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs>
     pub async fn mine_empty_block(&self) -> anyhow::Result<(usize, BlockHash)> {
         let c = self.bitcoind.clone();
         let bt = tokio::task::spawn_blocking(move || {
@@ -322,7 +322,7 @@ impl TestRig {
     /// Invalidate a number of blocks of a given size `count`.
     ///
     /// An async version of bdk's testenv invalidate_blocks:
-    /// https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs
+    /// <https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs>
     pub async fn invalidate_blocks(&self, count: usize) -> anyhow::Result<()> {
         let mut hash = self.get_best_block_hash().await?;
 
@@ -375,7 +375,7 @@ impl TestRig {
 
     pub async fn get_raw_transaction(&self, txid: &Txid) -> Result<Transaction> {
         let c = self.bitcoind.clone();
-        let txid = txid.clone();
+        let txid = *txid;
         Ok(
             tokio::task::spawn_blocking(move || c.client.get_raw_transaction(&txid, None))
                 .await
@@ -394,7 +394,7 @@ impl TestRig {
 
     pub async fn get_block(&self, hash: &BlockHash) -> Result<Block> {
         let c = self.bitcoind.clone();
-        let hash = hash.clone();
+        let hash = *hash;
         Ok(
             tokio::task::spawn_blocking(move || c.client.get_block(&hash))
                 .await
@@ -403,10 +403,10 @@ impl TestRig {
     }
 
     /// Reorg a number of blocks of a given size `count`.
-    /// Refer to [`SpaceD::mine_empty_block`] for more information.
+    /// Refer to [`Self::mine_empty_block`] for more information.
     ///
     /// An async version of bdk's testenv reorg:
-    /// https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs
+    /// <https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs>
     pub async fn reorg(&self, count: usize) -> anyhow::Result<Vec<BlockHash>> {
         let start_height = self.get_block_count().await?;
         self.invalidate_blocks(count).await?;
@@ -423,7 +423,7 @@ impl TestRig {
     /// Reorg with a number of empty blocks of a given size `count`.
     ///
     /// An async version of bdk's testenv reorg_empty_blocks:
-    /// https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs
+    /// <https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs>
     pub async fn reorg_empty_blocks(&self, count: usize) -> Result<Vec<(usize, BlockHash)>> {
         let start_height = self.get_block_count().await?;
         self.invalidate_blocks(count).await?;
@@ -443,7 +443,7 @@ impl TestRig {
     /// Send a tx of a given `amount` to a given `address`.
     ///
     /// An async version of bdk's testenv send:
-    /// https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs
+    /// <https://github.com/bitcoindevkit/bdk/blob/master/crates/testenv/src/lib.rs>
     pub async fn send(&self, address: &Address<NetworkChecked>, amount: Amount) -> Result<Txid> {
         let c = self.bitcoind.clone();
         let addr = address.clone();
diff --git a/testutil/src/spaced.rs b/testutil/src/spaced.rs
index 7d9d238..9e05485 100644
--- a/testutil/src/spaced.rs
+++ b/testutil/src/spaced.rs
@@ -7,7 +7,12 @@ use std::{
 
 use anyhow::Result;
 use assert_cmd::cargo::CommandCargoExt;
-use bitcoind::{anyhow, anyhow::anyhow, get_available_port, tempfile::{tempdir, TempDir}};
+use bitcoind::{
+    anyhow,
+    anyhow::anyhow,
+    get_available_port,
+    tempfile::{TempDir, tempdir},
+};
 use spaces_client::{
     auth::{auth_token_from_creds, http_client_with_auth},
     jsonrpsee::{http_client::HttpClient, tokio},
@@ -50,34 +55,35 @@ impl SpaceD {
 
         let args: Vec<_> = conf.args.into_iter().map(String::from).collect();
         let data_dir = conf.data_dir.clone();
-        let (process, tempdir_handle) = tokio::task::spawn_blocking(move || -> Result<(Child, Option<TempDir>)> {
-            let (data_dir_path, tempdir_handle) = match data_dir {
-                Some(path) => (path, None),
-                None => {
-                    let td = tempdir()?;
-                    let path = td.path().to_path_buf();
-                    (path, Some(td))
-                }
-            };
-
-            #[allow(deprecated)]
-            let child = std::process::Command::cargo_bin("spaced")?
-                .args(args)
-                .arg("--rpc-port")
-                .arg(rpc_port.to_string())
-                .arg("--data-dir")
-                .arg(&data_dir_path)
-                .arg("--rpc-user")
-                .arg("user")
-                .arg("--rpc-password")
-                .arg("pass")
-                .stdout(stdout)
-                .spawn()?;
-
-            Ok((child, tempdir_handle))
-        })
-        .await
-        .expect("spawn blocking task")?;
+        let (process, tempdir_handle) =
+            tokio::task::spawn_blocking(move || -> Result<(Child, Option<TempDir>)> {
+                let (data_dir_path, tempdir_handle) = match data_dir {
+                    Some(path) => (path, None),
+                    None => {
+                        let td = tempdir()?;
+                        let path = td.path().to_path_buf();
+                        (path, Some(td))
+                    }
+                };
+
+                #[allow(deprecated)]
+                let child = std::process::Command::cargo_bin("spaced")?
+                    .args(args)
+                    .arg("--rpc-port")
+                    .arg(rpc_port.to_string())
+                    .arg("--data-dir")
+                    .arg(&data_dir_path)
+                    .arg("--rpc-user")
+                    .arg("user")
+                    .arg("--rpc-password")
+                    .arg("pass")
+                    .stdout(stdout)
+                    .spawn()?;
+
+                Ok((child, tempdir_handle))
+            })
+            .await
+            .expect("spawn blocking task")?;
 
         let client =
             http_client_with_auth(&rpc_url(rpc_port), &auth_token_from_creds("user", "pass"))?;
diff --git a/wallet/Cargo.toml b/wallet/Cargo.toml
index 7e7faf0..3a8b9a8 100644
--- a/wallet/Cargo.toml
+++ b/wallet/Cargo.toml
@@ -1,11 +1,17 @@
 [package]
 name = "spaces_wallet"
-version = "0.0.7"
-edition = "2021"
+description = "Wallet implementation for the Spaces Protocol."
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
 
 [dependencies]
-spaces_protocol = { path = "../protocol", features = ["std"] }
-spaces_nums = { path = "../nums", features = ["std"] }
+spaces_protocol = { workspace = true, features = ["std"] }
+spaces_nums = { workspace = true, features = ["std"] }
 bitcoin = { version = "0.32.8", features = ["base64", "serde"] }
 bdk_wallet = { workspace = true }
 secp256k1 = { workspace = true }
diff --git a/wallet/src/address.rs b/wallet/src/address.rs
index 57b4c81..9cd4dd5 100644
--- a/wallet/src/address.rs
+++ b/wallet/src/address.rs
@@ -1,13 +1,13 @@
 use core::{fmt, str::FromStr};
 
-use bech32::{primitives::decode::SegwitHrpstringError, Hrp};
+use bech32::{Hrp, primitives::decode::SegwitHrpstringError};
 use bitcoin::blockdata::script::witness_version::WitnessVersion;
 use spaces_protocol::{
     bitcoin,
     bitcoin::{
+        ScriptBuf, WitnessProgram,
         address::{Address, ParseError},
         network::Network,
-        ScriptBuf, WitnessProgram,
     },
 };
 
diff --git a/wallet/src/builder.rs b/wallet/src/builder.rs
index 2fbd17c..58c3e90 100644
--- a/wallet/src/builder.rs
+++ b/wallet/src/builder.rs
@@ -1,27 +1,31 @@
 use crate::{
-    address::SpaceAddress, tx_event::TxRecord, DoubleUtxo, FullTxOut, SpaceScriptSigningInfo,
-    SpacesWallet,
+    DoubleUtxo, FullTxOut, SpaceScriptSigningInfo, SpacesWallet, address::SpaceAddress,
+    tx_event::TxRecord,
 };
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 
 use bdk_wallet::{
+    KeychainKind, TxBuilder, Utxo, WeightedUtxo,
     coin_selection::{
         CoinSelectionAlgorithm, CoinSelectionResult, DefaultCoinSelectionAlgorithm,
         InsufficientFunds,
     },
     error::CreateTxError,
     tx_builder::TxOrdering,
-    KeychainKind, TxBuilder, Utxo, WeightedUtxo,
 };
-use bitcoin::{absolute::LockTime, key::rand::RngCore, psbt::Input, script, script::PushBytesBuf, Address, Amount, FeeRate, Network, OutPoint, Psbt, Script, ScriptBuf, Sequence, Transaction, TxOut, Txid, Weight, Witness};
+use bitcoin::{
+    Address, Amount, FeeRate, Network, OutPoint, Psbt, Script, ScriptBuf, Sequence, Transaction,
+    TxOut, Txid, Weight, Witness, absolute::LockTime, key::rand::RngCore, psbt::Input, script,
+    script::PushBytesBuf,
+};
 
-use spaces_nums::{create_commitment_script, CommitmentOp, FullNumOut};
+use spaces_nums::{CommitmentOp, FullNumOut, create_commitment_script};
 use spaces_protocol::hasher::Hash;
 use spaces_protocol::script::{create_data_script, create_open_data, nop_script};
 use spaces_protocol::{
+    Covenant, FullSpaceOut, Space,
     bitcoin::absolute::Height,
     constants::{BID_PSBT_INPUT_SEQUENCE, BID_PSBT_TX_VERSION},
-    Covenant, FullSpaceOut, Space,
 };
 use std::{
     cmp::min,
@@ -145,7 +149,7 @@ pub struct NumTransfer {
     /// Whether this transfer is a delegation (authorize) rather than a regular transfer
     pub is_delegate: bool,
     /// Must be specified if num isn't owned by wallet
-    pub secret: Option<[u8;32]>,
+    pub secret: Option<[u8; 32]>,
 }
 
 #[derive(Debug, Clone)]
@@ -278,11 +282,10 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilderSpacesUtils<'a, Cs> for TxBuilder<
             .proprietary
             .insert(SpacesWallet::spaces_signer("tbs"), Vec::new());
 
-        let compressed_psbt = PushBytesBuf::try_from(SpacesWallet::compress_bid_psbt(
+        let compressed_psbt = PushBytesBuf::from(SpacesWallet::compress_bid_psbt(
             placeholder.auction.outpoint.vout as u8,
             &offer,
-        )?)
-        .expect("compressed psbt script bytes");
+        )?);
 
         let carrier = ScriptBuf::new_op_return(&compressed_psbt);
 
@@ -359,7 +362,7 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilderSpacesUtils<'a, Cs> for TxBuilder<
 }
 
 impl Builder {
-    #[allow(unused_assignments)]
+    #[allow(unused_assignments, clippy::too_many_arguments)]
     fn prepare_all(
         median_time: u64,
         w: &mut SpacesWallet,
@@ -413,7 +416,7 @@ impl Builder {
                 // Must be an odd number of outputs so that
                 // transfers align correctly
                 // TODO: use the actual change output instead of creating this
-                if vout % 2 == 0 {
+                if vout.is_multiple_of(2) {
                     let dust = match dust {
                         None => change_address.minimal_non_dust().mul(2),
                         Some(dust) => dust,
@@ -479,15 +482,15 @@ impl Builder {
             }
 
             builder.fee_rate(fee_rate);
-            let r = builder.finish().map_err(|e| match e {
+
+            builder.finish().map_err(|e| match e {
                 CreateTxError::CoinSelection(e) if confirmed_only => {
                     anyhow!("{} (replacements use confirmed balance only)", e)
                 }
                 _ => {
                     anyhow!("{}", e)
                 }
-            })?;
-            r
+            })?
         };
 
         let tx = w.sign(commit_psbt, None)?;
@@ -508,10 +511,7 @@ impl Iterator for BuilderIterator<'_> {
     type Item = anyhow::Result<TxRecord>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let op = match self.stack.pop() {
-            None => return None,
-            Some(req) => req,
-        };
+        let op = self.stack.pop()?;
 
         match op {
             // A Prepare tx could bundle all P2TR commitments for open and other scripts
@@ -521,18 +521,18 @@ impl Iterator for BuilderIterator<'_> {
 
                 // Push all open script commitments
                 for req in params.opens.iter() {
-                    let tap = Builder::create_open_tap_data(self.wallet.config.network, &req.name)
-                        .context("could not initialize tap data for name");
-                    if tap.is_err() {
-                        return Some(Err(tap.unwrap_err()));
+                    match Builder::create_open_tap_data(self.wallet.config.network, &req.name)
+                        .context("could not initialize tap data for name")
+                    {
+                        Ok(data) => reveals.push(data),
+                        Err(err) => return Some(Err(err)),
                     }
-                    reveals.push(tap.unwrap());
                 }
 
                 let (tx, commitments) = match Builder::prepare_all(
                     self.median_time,
                     self.wallet,
-                    params.bidouts.clone(),
+                    params.bidouts,
                     Some(&reveals),
                     params.transfers.clone(),
                     params.sends.clone(),
@@ -653,12 +653,19 @@ impl Iterator for BuilderIterator<'_> {
                 }))
             }
             StackOp::Num(params) => {
-                let transfers: Vec<_> = params.transfers.iter().map(|t| {
-                    (t.num.numout.num.name.to_string(), t.num.numout.num.id.to_string(), t.recipient.script_pubkey(), t.is_delegate)
-                }).collect();
-                let binds: Vec<_> = params.binds.iter().map(|b| {
-                    b.bind_spk.clone()
-                }).collect();
+                let transfers: Vec<_> = params
+                    .transfers
+                    .iter()
+                    .map(|t| {
+                        (
+                            t.num.numout.num.name.to_string(),
+                            t.num.numout.num.id.to_string(),
+                            t.recipient.script_pubkey(),
+                            t.is_delegate,
+                        )
+                    })
+                    .collect();
+                let binds: Vec<_> = params.binds.iter().map(|b| b.bind_spk.clone()).collect();
                 let tx = create_num_tx(
                     self.wallet,
                     self.median_time,
@@ -703,14 +710,19 @@ impl Iterator for BuilderIterator<'_> {
             }
             StackOp::Commitment(commitments) => {
                 let is_rollback = commitments.iter().all(|c| c.root.is_none());
-                let event_info: Vec<_> = commitments.iter().map(|c| {
-                    let root_hex = c.root.map(|r|
-                        r.iter().map(|b| format!("{:02x}", b)).collect::<String>()
-                    );
-                    let name = c.subject.clone()
-                        .unwrap_or_else(|| c.numout.numout.num.name.to_string());
-                    (name, root_hex)
-                }).collect();
+                let event_info: Vec<_> = commitments
+                    .iter()
+                    .map(|c| {
+                        let root_hex = c
+                            .root
+                            .map(|r| r.iter().map(|b| format!("{:02x}", b)).collect::<String>());
+                        let name = c
+                            .subject
+                            .clone()
+                            .unwrap_or_else(|| c.numout.numout.num.name.to_string());
+                        (name, root_hex)
+                    })
+                    .collect();
                 let tx = create_commitment_tx(
                     self.wallet,
                     self.median_time,
@@ -736,6 +748,12 @@ impl Iterator for BuilderIterator<'_> {
     }
 }
 
+impl Default for Builder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Builder {
     pub fn new() -> Self {
         Builder {
@@ -837,11 +855,10 @@ impl Builder {
         unspendables: Vec<OutPoint>,
         confirmed_only: bool,
     ) -> anyhow::Result<BuilderIterator<'_>> {
-        let fee_rate = self
+        let fee_rate = *self
             .fee_rate
             .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("fee_rate is required"))?
-            .clone();
+            .ok_or_else(|| anyhow::anyhow!("fee_rate is required"))?;
 
         let (open_count, bid_count) =
             self.requests
@@ -1060,7 +1077,7 @@ pub struct SelectionOutput {
 
 /// A coin selection algorithm that :
 /// 1. Guarantees required utxos are ordered first appending
-/// any funding/change outputs to the end of the selected utxos.
+///    any funding/change outputs to the end of the selected utxos.
 /// 2. Excludes all dust outputs to avoid accidentally spending space utxos
 /// 3. Enables adding additional output exclusions
 #[derive(Debug, Clone)]
@@ -1103,15 +1120,11 @@ impl CoinSelectionAlgorithm for SpacesAwareCoinSelection {
 
         // Filter out UTXOs that are either explicitly excluded or below the dust threshold
         optional_utxos.retain(|weighted_utxo| {
-            if self.confirmed_only {
-                match &weighted_utxo.utxo {
-                    Utxo::Local(local) => {
-                        if !local.chain_position.is_confirmed() {
-                            return false;
-                        }
-                    }
-                    _ => {}
-                }
+            if self.confirmed_only
+                && let Utxo::Local(local) = &weighted_utxo.utxo
+                && !local.chain_position.is_confirmed()
+            {
+                return false;
             }
 
             weighted_utxo.utxo.txout().value > SpacesAwareCoinSelection::DUST_THRESHOLD
@@ -1232,10 +1245,7 @@ fn create_num_delegate_tx(
         } else {
             num_utxo_dust(Amount::from_sat(1000))
         };
-        (
-            new_mint,
-            num_utxo_delegate_dust(d.num.numout.value),
-        )
+        (new_mint, num_utxo_delegate_dust(d.num.numout.value))
     };
     builder.add_recipient(d.unique_num_spk.clone(), a);
     builder.add_recipient(d.unique_num_spk, b);
@@ -1331,9 +1341,10 @@ fn create_num_tx(
                 proprietary: BTreeMap::new(),
                 ..Default::default()
             };
-            spend_input
-                .proprietary
-                .insert(SpacesWallet::spaces_signer("sign_with_custom_secret"), secret.to_vec());
+            spend_input.proprietary.insert(
+                SpacesWallet::spaces_signer("sign_with_custom_secret"),
+                secret.to_vec(),
+            );
             builder
                 .add_foreign_utxo_with_sequence(
                     outpoint,
@@ -1348,7 +1359,7 @@ fn create_num_tx(
                 .add_utxo(outpoint)
                 .map_err(|e| anyhow!("could not transfer num at {}:{}", outpoint, e))?;
         }
-        
+
         // add replacement output at the same index
         builder.add_recipient(
             transfer.recipient.script_pubkey(),
@@ -1362,11 +1373,11 @@ fn create_num_tx(
     }
 
     // Add data OP_RETURN if present (only makes sense with transfers)
-    if let Some(data) = params.data {
-        if has_transfers {
-            let script = create_data_script(&data);
-            builder.add_recipient(script, Amount::from_sat(0));
-        }
+    if let Some(data) = params.data
+        && has_transfers
+    {
+        let script = create_data_script(&data);
+        builder.add_recipient(script, Amount::from_sat(0));
     }
 
     let psbt = builder.finish()?;
diff --git a/wallet/src/export.rs b/wallet/src/export.rs
index cb308a4..e287511 100644
--- a/wallet/src/export.rs
+++ b/wallet/src/export.rs
@@ -16,7 +16,7 @@ use serde::{Deserialize, Serialize};
 
 /// Structure that contains the export of a wallet
 ///
-/// For a usage example see [this module](crate::wallet::export)'s documentation.
+/// For a usage example see [this module](crate::export)'s documentation.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct WalletExport {
     pub descriptor: String,
diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs
index 84e34eb..e3dd24c 100644
--- a/wallet/src/lib.rs
+++ b/wallet/src/lib.rs
@@ -1,25 +1,24 @@
-use std::{collections::BTreeMap, fmt, fmt::Debug, fs, ops::Mul, path::PathBuf, str::FromStr};
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
+use bdk_wallet::chain::keychain_txout::KeychainTxOutIndex;
 use bdk_wallet::{
-    chain,
+    AddressInfo, KeychainKind, LocalOutput, PersistedWallet, SignOptions, TxBuilder, Update,
+    Wallet, WalletTx, WeightedUtxo, chain,
     chain::{
+        BlockId, ChainPosition, Indexer,
         local_chain::{CannotConnectError, LocalChain},
         tx_graph::CalculateFeeError,
-        BlockId, ChainPosition, Indexer,
     },
     coin_selection::{CoinSelectionAlgorithm, CoinSelectionResult, Excess, InsufficientFunds},
     keys::DescriptorSecretKey,
     rusqlite::Connection,
     tx_builder::TxOrdering,
-    AddressInfo, KeychainKind, LocalOutput, PersistedWallet, SignOptions, TxBuilder, Update,
-    Wallet, WalletTx, WeightedUtxo,
 };
-use bdk_wallet::chain::keychain_txout::KeychainTxOutIndex;
-use borsh::{BorshDeserialize, BorshSerialize, io};
 use bitcoin::{
+    Amount, Block, BlockHash, FeeRate, Network, OutPoint, Psbt, Sequence, TapLeafHash,
+    TapSighashType, Transaction, TxIn, TxOut, Txid, Weight, Witness,
     absolute::{Height, LockTime},
     bip32::ChildNumber,
-    key::{rand::RngCore, TapTweak, TweakedKeypair},
+    key::{TapTweak, TweakedKeypair, rand::RngCore},
     psbt,
     psbt::raw::ProprietaryKey,
     script,
@@ -27,33 +26,36 @@ use bitcoin::{
     taproot,
     taproot::LeafVersion,
     transaction::Version,
-    Amount, Block, BlockHash, FeeRate, Network, OutPoint, Psbt, Sequence, TapLeafHash,
-    TapSighashType, Transaction, TxIn, TxOut, Txid, Weight, Witness,
 };
-use secp256k1::{schnorr, schnorr::Signature, Message};
-use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
+use borsh::{BorshDeserialize, BorshSerialize, io};
+use secp256k1::{Message, schnorr, schnorr::Signature};
+use serde::{Deserialize, Deserializer, Serialize, Serializer, ser::SerializeSeq};
+use spaces_nums::snumeric::SNumeric;
+use spaces_nums::{
+    NumSource,
+    num_id::{NUM_HRP, NumId},
+};
 use spaces_protocol::{
+    Covenant, FullSpaceOut, Space,
     bitcoin::{
+        Address, ScriptBuf, XOnlyPublicKey,
         constants::genesis_block,
-        key::{rand, UntweakedKeypair},
+        key::{UntweakedKeypair, rand},
         opcodes,
         taproot::{ControlBlock, TaprootBuilder},
-        Address, ScriptBuf, XOnlyPublicKey,
     },
     constants::{BID_PSBT_INPUT_SEQUENCE, BID_PSBT_TX_LOCK_TIME},
     hasher::{KeyHasher, SpaceKey},
-    prepare::{is_magic_lock_time, SpacesSource, TrackableOutput},
+    prepare::{SpacesSource, TrackableOutput, is_magic_lock_time},
     slabel::SLabel,
-    Covenant, FullSpaceOut, Space,
 };
-use spaces_nums::{NumSource, num_id::{NumId, NUM_HRP}};
-use spaces_nums::snumeric::SNumeric;
+use std::{collections::BTreeMap, fmt, fmt::Debug, fs, ops::Mul, path::PathBuf, str::FromStr};
 
 use crate::{
     address::SpaceAddress,
     builder::{
-        is_connector_dust, is_space_dust, space_dust, tap_key_spend_weight,
-        SpacesAwareCoinSelection,
+        SpacesAwareCoinSelection, is_connector_dust, is_space_dust, space_dust,
+        tap_key_spend_weight,
     },
     nostr::NostrEvent,
     tx_event::{TxEvent, TxEventKind, TxRecord},
@@ -280,11 +282,11 @@ impl SpacesWallet {
                 config.space_descriptors.external.clone(),
                 config.space_descriptors.internal.clone(),
             )
-                .lookahead(50)
-                .network(config.network)
-                .genesis_hash(genesis_hash)
-                .create_wallet(&mut conn)
-                .context("could not create wallet")?
+            .lookahead(50)
+            .network(config.network)
+            .genesis_hash(genesis_hash)
+            .create_wallet(&mut conn)
+            .context("could not create wallet")?
         };
 
         let tx = conn
@@ -355,7 +357,7 @@ impl SpacesWallet {
         })
     }
 
-    pub fn transactions(&self) -> impl Iterator<Item=WalletTx<'_>> + '_ {
+    pub fn transactions(&self) -> impl Iterator<Item = WalletTx<'_>> + '_ {
         self.internal
             .transactions()
             .filter(|tx| !is_revert_tx(tx) && self.internal.spk_index().is_tx_relevant(&tx.tx_node))
@@ -402,8 +404,8 @@ impl SpacesWallet {
     ) -> anyhow::Result<TxBuilder<'_, SpacesAwareCoinSelection>> {
         let events = self.get_tx_events(txid)?;
         for event in events {
-            match event.kind {
-                TxEventKind::Bid => match self.get_tx(txid) {
+            if event.kind == TxEventKind::Bid {
+                match self.get_tx(txid) {
                     Some(tx) => {
                         if !tx.chain_position.is_confirmed() {
                             return Err(anyhow!(
@@ -413,8 +415,7 @@ impl SpacesWallet {
                         }
                     }
                     _ => continue,
-                },
-                _ => {}
+                }
             }
         }
 
@@ -453,11 +454,11 @@ impl SpacesWallet {
         self.internal.is_mine(script)
     }
 
-    pub fn list_unspent(&self) -> impl Iterator<Item=LocalOutput> + '_ {
+    pub fn list_unspent(&self) -> impl Iterator<Item = LocalOutput> + '_ {
         self.internal.list_unspent()
     }
 
-    pub fn list_output(&self) -> impl Iterator<Item=LocalOutput> + '_ {
+    pub fn list_output(&self) -> impl Iterator<Item = LocalOutput> + '_ {
         self.internal.list_output()
     }
 
@@ -480,7 +481,8 @@ impl SpacesWallet {
         let outpoint = match &subject {
             Subject::Label(label) if label.is_numeric() => {
                 let numeric: SNumeric = label.clone().try_into().unwrap();
-                let id = src.get_num_id(&numeric)?
+                let id = src
+                    .get_num_id(&numeric)?
                     .ok_or_else(|| anyhow::anyhow!("Numeric '{}' not found", numeric))?;
                 src.get_num_outpoint_by_id(&id)?
                     .ok_or_else(|| anyhow::anyhow!("Num id not found"))?
@@ -493,16 +495,19 @@ impl SpacesWallet {
                 src.get_space_outpoint(&space_key)?
                     .ok_or_else(|| anyhow::anyhow!("Space not found"))?
             }
-            Subject::NumId(id) => {
-                src.get_num_outpoint_by_id(id)?
-                    .ok_or_else(|| anyhow::anyhow!("Num id not found"))?
-            }
+            Subject::NumId(id) => src
+                .get_num_outpoint_by_id(id)?
+                .ok_or_else(|| anyhow::anyhow!("Num id not found"))?,
         };
 
         // We use list_output instead of get_utxo because the output might
         // be spent in a pending tx, so signatures are still valid until confirmed.
-        let utxo = self.internal.list_output().find(|o| o.outpoint == outpoint)
-            .clone().ok_or_else(|| anyhow::anyhow!("Not owned by wallet"))?;
+        let utxo = self
+            .internal
+            .list_output()
+            .find(|o| o.outpoint == outpoint)
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("Not owned by wallet"))?;
 
         let keypair = self
             .get_taproot_keypair(utxo.keychain, utxo.derivation_index)
@@ -520,11 +525,14 @@ impl SpacesWallet {
         let script_pubkey = match &subject {
             Subject::Label(label) if label.is_numeric() => {
                 let numeric: SNumeric = label.clone().try_into().unwrap();
-                let id = src.get_num_id(&numeric)?
+                let id = src
+                    .get_num_id(&numeric)?
                     .ok_or_else(|| anyhow::anyhow!("Numeric '{}' not found", numeric))?;
-                let outpoint = src.get_num_outpoint_by_id(&id)?
+                let outpoint = src
+                    .get_num_outpoint_by_id(&id)?
                     .ok_or_else(|| anyhow::anyhow!("Num id not found"))?;
-                let numout = src.get_numout(&outpoint)?
+                let numout = src
+                    .get_numout(&outpoint)?
                     .ok_or_else(|| anyhow::anyhow!("Num output not found"))?;
                 numout.script_pubkey
             }
@@ -533,16 +541,20 @@ impl SpacesWallet {
                     return Err(anyhow::anyhow!("Space tag does not match specified space"));
                 }
                 let space_key = SpaceKey::from(H::hash(label.as_ref()));
-                let outpoint = src.get_space_outpoint(&space_key)?
+                let outpoint = src
+                    .get_space_outpoint(&space_key)?
                     .ok_or_else(|| anyhow::anyhow!("Space not found"))?;
-                let spaceout = src.get_spaceout(&outpoint)?
+                let spaceout = src
+                    .get_spaceout(&outpoint)?
                     .ok_or_else(|| anyhow::anyhow!("Space not found"))?;
                 spaceout.script_pubkey
             }
             Subject::NumId(id) => {
-                let outpoint = src.get_num_outpoint_by_id(id)?
+                let outpoint = src
+                    .get_num_outpoint_by_id(id)?
                     .ok_or_else(|| anyhow::anyhow!("Num id not found"))?;
-                let numout = src.get_numout(&outpoint)?
+                let numout = src
+                    .get_numout(&outpoint)?
                     .ok_or_else(|| anyhow::anyhow!("Num output not found"))?;
                 numout.script_pubkey
             }
@@ -582,12 +594,13 @@ impl SpacesWallet {
         subject: Subject,
         message: &[u8],
     ) -> anyhow::Result<schnorr::Signature> {
-        use bitcoin::hashes::{sha256, Hash, HashEngine};
+        use bitcoin::hashes::{Hash, HashEngine, sha256};
 
         let outpoint = match &subject {
             Subject::Label(label) if label.is_numeric() => {
                 let numeric: SNumeric = label.clone().try_into().unwrap();
-                let id = src.get_num_id(&numeric)?
+                let id = src
+                    .get_num_id(&numeric)?
                     .ok_or_else(|| anyhow::anyhow!("Numeric '{}' not found", numeric))?;
                 src.get_num_outpoint_by_id(&id)?
                     .ok_or_else(|| anyhow::anyhow!("Num id not found"))?
@@ -597,16 +610,19 @@ impl SpacesWallet {
                 src.get_space_outpoint(&space_key)?
                     .ok_or_else(|| anyhow::anyhow!("Space not found"))?
             }
-            Subject::NumId(id) => {
-                src.get_num_outpoint_by_id(id)?
-                    .ok_or_else(|| anyhow::anyhow!("Num id not found"))?
-            }
+            Subject::NumId(id) => src
+                .get_num_outpoint_by_id(id)?
+                .ok_or_else(|| anyhow::anyhow!("Num id not found"))?,
         };
 
         // We use list_output instead of get_utxo because the output might
         // be spent in a pending tx, so signatures are still valid until confirmed.
-        let utxo = self.internal.list_output().find(|o| o.outpoint == outpoint)
-            .clone().ok_or_else(|| anyhow::anyhow!("Not owned by wallet"))?;
+        let utxo = self
+            .internal
+            .list_output()
+            .find(|o| o.outpoint == outpoint)
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("Not owned by wallet"))?;
 
         let keypair = self
             .get_taproot_keypair(utxo.keychain, utxo.derivation_index)
@@ -630,31 +646,38 @@ impl SpacesWallet {
         message: &[u8],
         signature: &schnorr::Signature,
     ) -> anyhow::Result<()> {
-        use bitcoin::hashes::{sha256, Hash, HashEngine};
+        use bitcoin::hashes::{Hash, HashEngine, sha256};
 
         let script_pubkey = match &subject {
             Subject::Label(label) if label.is_numeric() => {
                 let numeric: SNumeric = label.clone().try_into().unwrap();
-                let id = src.get_num_id(&numeric)?
+                let id = src
+                    .get_num_id(&numeric)?
                     .ok_or_else(|| anyhow::anyhow!("Numeric '{}' not found", numeric))?;
-                let outpoint = src.get_num_outpoint_by_id(&id)?
+                let outpoint = src
+                    .get_num_outpoint_by_id(&id)?
                     .ok_or_else(|| anyhow::anyhow!("Num id not found"))?;
-                let numout = src.get_numout(&outpoint)?
+                let numout = src
+                    .get_numout(&outpoint)?
                     .ok_or_else(|| anyhow::anyhow!("Num output not found"))?;
                 numout.script_pubkey
             }
             Subject::Label(label) => {
                 let space_key = SpaceKey::from(H::hash(label.as_ref()));
-                let outpoint = src.get_space_outpoint(&space_key)?
+                let outpoint = src
+                    .get_space_outpoint(&space_key)?
                     .ok_or_else(|| anyhow::anyhow!("Space not found"))?;
-                let spaceout = src.get_spaceout(&outpoint)?
+                let spaceout = src
+                    .get_spaceout(&outpoint)?
                     .ok_or_else(|| anyhow::anyhow!("Space not found"))?;
                 spaceout.script_pubkey
             }
             Subject::NumId(id) => {
-                let outpoint = src.get_num_outpoint_by_id(id)?
+                let outpoint = src
+                    .get_num_outpoint_by_id(id)?
                     .ok_or_else(|| anyhow::anyhow!("Num id not found"))?;
-                let numout = src.get_numout(&outpoint)?
+                let numout = src
+                    .get_numout(&outpoint)?
                     .ok_or_else(|| anyhow::anyhow!("Num output not found"))?;
                 numout.script_pubkey
             }
@@ -782,28 +805,28 @@ impl SpacesWallet {
     pub fn rebuild(self) -> anyhow::Result<Self> {
         let config = self.config;
         fs::remove_file(config.data_dir.join("wallet.db"))?;
-        Ok(SpacesWallet::new(config)?)
+        SpacesWallet::new(config)
     }
 
     pub fn get_info(&self) -> WalletInfo {
-        let mut descriptors = Vec::with_capacity(2);
-
-        descriptors.push(DescriptorInfo {
-            descriptor: self
-                .internal
-                .public_descriptor(KeychainKind::External)
-                .to_string(),
-            internal: false,
-            spaces: true,
-        });
-        descriptors.push(DescriptorInfo {
-            descriptor: self
-                .internal
-                .public_descriptor(KeychainKind::Internal)
-                .to_string(),
-            internal: true,
-            spaces: true,
-        });
+        let descriptors = vec![
+            DescriptorInfo {
+                descriptor: self
+                    .internal
+                    .public_descriptor(KeychainKind::External)
+                    .to_string(),
+                internal: false,
+                spaces: true,
+            },
+            DescriptorInfo {
+                descriptor: self
+                    .internal
+                    .public_descriptor(KeychainKind::Internal)
+                    .to_string(),
+                internal: true,
+                spaces: true,
+            },
+        ];
 
         WalletInfo {
             label: self.config.name.clone(),
@@ -831,16 +854,12 @@ impl SpacesWallet {
         block_id: BlockId,
     ) -> anyhow::Result<()> {
         self.internal
-            .apply_block_connected_to(&block, height, block_id)?;
+            .apply_block_connected_to(block, height, block_id)?;
         Ok(())
     }
 
-    pub fn apply_update(
-        &mut self,
-        update: impl Into<Update>,
-    ) -> Result<(), CannotConnectError> {
-        self.internal
-            .apply_update(update)
+    pub fn apply_update(&mut self, update: impl Into<Update>) -> Result<(), CannotConnectError> {
+        self.internal.apply_update(update)
     }
 
     pub fn apply_unconfirmed_tx(&mut self, tx: Transaction, seen: u64) {
@@ -873,7 +892,7 @@ impl SpacesWallet {
                 event.previous_spaceout,
                 event.details,
             )
-                .context("could not insert tx event into wallet db")?;
+            .context("could not insert tx event into wallet db")?;
         }
         db_tx
             .commit()
@@ -967,7 +986,7 @@ impl SpacesWallet {
         listing: &Listing,
         fee_rate: FeeRate,
     ) -> anyhow::Result<Transaction> {
-        let (seller, spaceout) = Self::verify_listing::<H>(src, &listing)?;
+        let (seller, spaceout) = Self::verify_listing::<H>(src, listing)?;
 
         let mut witness = Witness::new();
         witness.push(
@@ -975,7 +994,7 @@ impl SpacesWallet {
                 signature: listing.signature,
                 sighash_type: TapSighashType::SinglePlusAnyoneCanPay,
             }
-                .to_vec(),
+            .to_vec(),
         );
 
         let funded_psbt = {
@@ -1026,7 +1045,7 @@ impl SpacesWallet {
                 return Err(anyhow::anyhow!(
                     "Unknown space {} - no outpoint found",
                     listing.space
-                ))
+                ));
             }
             Some(outpoint) => outpoint,
         };
@@ -1047,7 +1066,7 @@ impl SpacesWallet {
         }
 
         let recipient = Self::verify_listing_signature(
-            &listing,
+            listing,
             outpoint,
             TxOut {
                 value: spaceout.value,
@@ -1111,7 +1130,7 @@ impl SpacesWallet {
         space: &str,
         asking_price: Amount,
     ) -> anyhow::Result<Listing> {
-        let label = SLabel::from_str(&space)?;
+        let label = SLabel::from_str(space)?;
         let spacehash = SpaceKey::from(H::hash(label.as_ref()));
         let space_outpoint = match src.get_space_outpoint(&spacehash)? {
             None => return Err(anyhow::anyhow!("Space not found")),
@@ -1133,7 +1152,7 @@ impl SpacesWallet {
                 return Err(anyhow::anyhow!(
                     "Wallet does not own a space with outpoint {}",
                     space_outpoint
-                ))
+                ));
             }
             Some(utxo) => utxo,
         };
@@ -1326,11 +1345,10 @@ impl SpacesWallet {
                 );
             }
 
-            if input.final_script_witness.is_none() && input.witness_utxo.is_some() {
-                if self
-                    .internal
-                    .is_mine(input.witness_utxo.as_ref().unwrap().script_pubkey.clone())
-                {
+            if input.final_script_witness.is_none()
+                && let Some(witness_utxo) = input.witness_utxo.as_ref()
+            {
+                if self.internal.is_mine(witness_utxo.script_pubkey.clone()) {
                     input
                         .proprietary
                         .insert(Self::spaces_signer("tbs"), Vec::new());
@@ -1340,10 +1358,7 @@ impl SpacesWallet {
 
                 let previous_output = psbt.unsigned_tx.input[input_index].previous_output;
                 let signing_info = self
-                    .get_signing_info(
-                        previous_output,
-                        &input.witness_utxo.as_ref().unwrap().script_pubkey,
-                    )
+                    .get_signing_info(previous_output, &witness_utxo.script_pubkey)
                     .context("could not retrieve signing info for script")?;
                 if let Some(info) = signing_info {
                     input
@@ -1390,7 +1405,7 @@ impl SpacesWallet {
         }
 
         let mut prevouts = Vec::new();
-        let extras = extra_prevouts.unwrap_or_else(|| BTreeMap::new());
+        let extras = extra_prevouts.unwrap_or_default();
 
         for input in tx.input.iter() {
             if let Some(prevout) = extras.get(&input.previous_output) {
@@ -1432,10 +1447,10 @@ impl SpacesWallet {
                     signature,
                     sighash_type,
                 }
-                    .to_vec(),
+                .to_vec(),
             );
             witness.push(&signing_info.script);
-            witness.push(&signing_info.control_block.serialize());
+            witness.push(signing_info.control_block.serialize());
         }
 
         // Sign inputs with externally-provided secret keys (taproot key-spend)
@@ -1555,7 +1570,7 @@ impl SpaceScriptSigningInfo {
         let key_pair = UntweakedKeypair::new(&secp256k1, &mut rand::thread_rng());
         let (public_key, _) = XOnlyPublicKey::from_keypair(&key_pair);
         let script = nop_script
-            .push_slice(&public_key.serialize())
+            .push_slice(public_key.serialize())
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .into_script();
 
diff --git a/wallet/src/nostr.rs b/wallet/src/nostr.rs
index e3baf38..62cd5cc 100644
--- a/wallet/src/nostr.rs
+++ b/wallet/src/nostr.rs
@@ -1,8 +1,8 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use anyhow::{anyhow, Result};
-use bitcoin::hashes::{sha256, Hash, HashEngine};
-use secp256k1::{schnorr::Signature, Keypair, Secp256k1, Signing, Verification, XOnlyPublicKey};
+use anyhow::{Result, anyhow};
+use bitcoin::hashes::{Hash, HashEngine, sha256};
+use secp256k1::{Keypair, Secp256k1, Signing, Verification, XOnlyPublicKey, schnorr::Signature};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 
@@ -47,7 +47,7 @@ impl NostrEvent {
         self.tags
             .iter()
             .find(|tag| {
-                if tag.0.len() >= 1 {
+                if !tag.0.is_empty() {
                     tag.0[0] == "space"
                 } else {
                     false
@@ -100,10 +100,7 @@ impl NostrEvent {
             Some(sig) => sig,
         };
         let msg = secp256k1::Message::from_digest(digest.to_byte_array());
-        match ctx.verify_schnorr(&sig, &msg, pubkey) {
-            Ok(_) => true,
-            Err(_) => false,
-        }
+        ctx.verify_schnorr(&sig, &msg, pubkey).is_ok()
     }
 
     pub fn sign<C: Signing>(&mut self, ctx: Secp256k1<C>, keypair: &Keypair) -> Result<()> {
@@ -124,7 +121,7 @@ impl NostrEvent {
             return Err(anyhow!("wrong event id"));
         }
 
-        self.id = Some(digest.clone());
+        self.id = Some(digest);
         let msg_to_sign = secp256k1::Message::from_digest(digest.to_byte_array());
         self.sig = Some(ctx.sign_schnorr(&msg_to_sign, keypair));
         Ok(())
diff --git a/wallet/src/rusqlite_impl.rs b/wallet/src/rusqlite_impl.rs
index 66749c4..992be18 100644
--- a/wallet/src/rusqlite_impl.rs
+++ b/wallet/src/rusqlite_impl.rs
@@ -5,9 +5,8 @@ use std::str::FromStr;
 // https://github.com/bitcoindevkit/bdk/blob/bcff89d51d0e1d91058e4430eda8cc57fb7f0f08/crates/chain/src/rusqlite_impl.rs#L55
 use bdk_wallet::rusqlite;
 use bdk_wallet::rusqlite::{
-    named_params,
+    OptionalExtension, ToSql, Transaction, named_params,
     types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef},
-    OptionalExtension, ToSql, Transaction,
 };
 
 use crate::*;
@@ -18,7 +17,10 @@ pub struct Impl<T>(pub T);
 
 /// Initialize the schema table.
 fn init_schemas_table(db_tx: &Transaction) -> rusqlite::Result<()> {
-    let sql = format!("CREATE TABLE IF NOT EXISTS {}( name TEXT PRIMARY KEY NOT NULL, version INTEGER NOT NULL ) STRICT", SCHEMAS_TABLE_NAME);
+    let sql = format!(
+        "CREATE TABLE IF NOT EXISTS {}( name TEXT PRIMARY KEY NOT NULL, version INTEGER NOT NULL ) STRICT",
+        SCHEMAS_TABLE_NAME
+    );
     db_tx.execute(&sql, ())?;
     Ok(())
 }
diff --git a/wallet/src/tx_event.rs b/wallet/src/tx_event.rs
index 93985d4..8d63a2f 100644
--- a/wallet/src/tx_event.rs
+++ b/wallet/src/tx_event.rs
@@ -3,8 +3,8 @@ use std::{fmt, fmt::Display, str::FromStr};
 use bdk_wallet::{
     chain, rusqlite,
     rusqlite::{
-        types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef},
         ToSql,
+        types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef},
     },
 };
 use bitcoin::{Amount, OutPoint, ScriptBuf, Transaction, TxOut, Txid};
@@ -12,8 +12,8 @@ use serde::{Deserialize, Serialize};
 use spaces_protocol::{Covenant, FullSpaceOut};
 
 use crate::{
-    rusqlite_impl::{migrate_schema, Impl},
     SpaceScriptSigningInfo, SpacesWallet,
+    rusqlite_impl::{Impl, migrate_schema},
 };
 
 #[derive(Clone, Debug)]
@@ -176,7 +176,7 @@ impl TxEvent {
         ))?;
 
         let rows = stmt.query_map(
-            rusqlite::params_from_iter(txids.into_iter().map(|t| Impl(t))),
+            rusqlite::params_from_iter(txids.into_iter().map(Impl)),
             |row| {
                 let txid: Impl<Txid> = row.get(0)?;
                 let previous_spaceout: Option<Impl<OutPoint>> = row.get(1)?;
@@ -184,10 +184,8 @@ impl TxEvent {
             },
         )?;
         let mut results = Vec::new();
-        for row in rows {
-            if let Ok((txid, outpoint)) = row {
-                results.push((txid.0, outpoint));
-            }
+        for (txid, outpoint) in rows.flatten() {
+            results.push((txid.0, outpoint));
         }
         Ok(results)
     }
@@ -202,7 +200,7 @@ impl TxEvent {
             Self::TX_EVENTS_TABLE_NAME,
         ))?;
         let results: Vec<Self> = Self::from_sqlite_statement(stmt, [Impl(txid)])?;
-        Ok(results.get(0).cloned())
+        Ok(results.first().cloned())
     }
 
     pub fn get_signing_info(
@@ -233,9 +231,7 @@ impl TxEvent {
     }
 
     /// Retrieve all CreateNum events
-    pub fn get_create_num_events(
-        db_tx: &rusqlite::Transaction,
-    ) -> rusqlite::Result<Vec<TxEvent>> {
+    pub fn get_create_num_events(db_tx: &rusqlite::Transaction) -> rusqlite::Result<Vec<TxEvent>> {
         let query = format!(
             "SELECT type, space, previous_spaceout, details
              FROM {table}
@@ -449,10 +445,7 @@ impl TxRecord {
             space: Some(space),
             previous_spaceout: None,
             details: Some(
-                serde_json::to_value(OpenEventDetails {
-                    initial_bid: initial_bid,
-                })
-                .expect("json value"),
+                serde_json::to_value(OpenEventDetails { initial_bid }).expect("json value"),
             ),
         });
     }
@@ -478,8 +471,7 @@ impl TxRecord {
             space: None,
             previous_spaceout: None,
             details: Some(
-                serde_json::to_value(CreateNumEventDetails { genesis_spk })
-                    .expect("json value"),
+                serde_json::to_value(CreateNumEventDetails { genesis_spk }).expect("json value"),
             ),
         });
     }
@@ -490,8 +482,7 @@ impl TxRecord {
             space: Some(num),
             previous_spaceout: None,
             details: Some(
-                serde_json::to_value(TransferNumEventDetails { num_id, to })
-                    .expect("json value"),
+                serde_json::to_value(TransferNumEventDetails { num_id, to }).expect("json value"),
             ),
         });
     }
@@ -514,8 +505,7 @@ impl TxRecord {
             space: Some(num),
             previous_spaceout: None,
             details: Some(
-                serde_json::to_value(CommitRootEventDetails { root })
-                    .expect("json value"),
+                serde_json::to_value(CommitRootEventDetails { root }).expect("json value"),
             ),
         });
     }
@@ -553,11 +543,11 @@ impl TxRecord {
         self.events.push(TxEvent {
             kind: TxEventKind::Bid,
             space: Some(space.name.to_string()),
-            previous_spaceout: previous_spaceout,
+            previous_spaceout,
             details: Some(
                 serde_json::to_value(BidEventDetails {
                     current_bid: amount,
-                    previous_bid: previous_bid,
+                    previous_bid,
                 })
                 .expect("json value"),
             ),
@@ -565,65 +555,6 @@ impl TxRecord {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use bitcoin::{hashes::Hash, Txid};
-    use serde_json::json;
-    use tempfile::tempdir;
-
-    use crate::{tx_event::TxEventKind, *};
-
-    #[test]
-    fn test_tx_event() -> anyhow::Result<()> {
-        // Create a temporary directory
-        let tmp_dir = tempdir()?;
-        let db_path = tmp_dir.path().join("test.db");
-
-        // Initialize SQLite connection
-        let mut conn = Connection::open(&db_path)?;
-        let tx = conn.transaction()?;
-
-        // Initialize the table
-        TxEvent::init_sqlite_tables(&tx)?;
-
-        // Insert a sample transaction event
-        let txid = Txid::all_zeros();
-        let kind = TxEventKind::Bid;
-        let space = Some("test_space".to_string());
-        let details = Some(json!({"amount": 1000, "currency": "USD"}));
-
-        TxEvent::insert(&tx, txid, kind, space.clone(), None, details.clone())?;
-
-        // Commit the transaction
-        tx.commit()?;
-
-        // Re-open the connection to verify the insertion
-        let mut conn = Connection::open(&db_path)?;
-        let tx = conn.transaction()?;
-
-        // Query the inserted event
-        let inserted_events = TxEvent::all(&tx, txid)?;
-
-        assert_eq!(inserted_events.len(), 1);
-        let event = &inserted_events[0];
-        assert_eq!(event.space, space);
-        assert_eq!(event.details, details);
-
-        let mut conn = Connection::open(&db_path)?;
-        let tx = conn.transaction()?;
-
-        let spaces = TxEvent::get_latest_events(&tx)?;
-        assert_eq!(spaces.len(), 1);
-        assert_eq!(spaces[0].1.space.as_ref().expect("space"), "test_space");
-
-        let bids = TxEvent::bids(&tx, "test_space".to_string())?;
-        assert_eq!(bids.len(), 1);
-        assert!(matches!(bids[0].kind, TxEventKind::Bid));
-
-        Ok(())
-    }
-}
-
 impl Display for TxEventKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {
@@ -688,3 +619,62 @@ impl ToSql for TxEventKind {
         Ok(ToSqlOutput::from(self.to_string()))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use bitcoin::{Txid, hashes::Hash};
+    use serde_json::json;
+    use tempfile::tempdir;
+
+    use crate::{tx_event::TxEventKind, *};
+
+    #[test]
+    fn test_tx_event() -> anyhow::Result<()> {
+        // Create a temporary directory
+        let tmp_dir = tempdir()?;
+        let db_path = tmp_dir.path().join("test.db");
+
+        // Initialize SQLite connection
+        let mut conn = Connection::open(&db_path)?;
+        let tx = conn.transaction()?;
+
+        // Initialize the table
+        TxEvent::init_sqlite_tables(&tx)?;
+
+        // Insert a sample transaction event
+        let txid = Txid::all_zeros();
+        let kind = TxEventKind::Bid;
+        let space = Some("test_space".to_string());
+        let details = Some(json!({"amount": 1000, "currency": "USD"}));
+
+        TxEvent::insert(&tx, txid, kind, space.clone(), None, details.clone())?;
+
+        // Commit the transaction
+        tx.commit()?;
+
+        // Re-open the connection to verify the insertion
+        let mut conn = Connection::open(&db_path)?;
+        let tx = conn.transaction()?;
+
+        // Query the inserted event
+        let inserted_events = TxEvent::all(&tx, txid)?;
+
+        assert_eq!(inserted_events.len(), 1);
+        let event = &inserted_events[0];
+        assert_eq!(event.space, space);
+        assert_eq!(event.details, details);
+
+        let mut conn = Connection::open(&db_path)?;
+        let tx = conn.transaction()?;
+
+        let spaces = TxEvent::get_latest_events(&tx)?;
+        assert_eq!(spaces.len(), 1);
+        assert_eq!(spaces[0].1.space.as_ref().expect("space"), "test_space");
+
+        let bids = TxEvent::bids(&tx, "test_space".to_string())?;
+        assert_eq!(bids.len(), 1);
+        assert!(matches!(bids[0].kind, TxEventKind::Bid));
+
+        Ok(())
+    }
+}