diff --git a/Cargo.lock b/Cargo.lock
index 6dd32815..31a28ee3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -95,23 +95,73 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445"
 
+[[package]]
+name = "bech32"
+version = "0.10.0-alpha"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cc1dec4c25e5a78c52802eda8e2adf0d2aca57ffc536326b75c0e531ea0a9b"
+
 [[package]]
 name = "bitcoin"
 version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0694ea59225b0c5f3cb405ff3f670e4828358ed26aec49dc352f730f0cb1a8a3"
 dependencies = [
- "bech32",
- "bitcoin_hashes",
- "secp256k1",
+ "bech32 0.9.1",
+ "bitcoin_hashes 0.11.0",
+ "secp256k1 0.24.1",
+]
+
+[[package]]
+name = "bitcoin"
+version = "0.30.0"
+source = "git+https://github.com/vincenzopalazzo/rust-bitcoin.git?branch=macros/calculate-next-work-requried#003673d1cb0495b80fcea5e01333eba9594d8e20"
+dependencies = [
+ "bech32 0.10.0-alpha",
+ "bitcoin-internals",
+ "bitcoin_hashes 0.13.0",
+ "hex-conservative",
+ "hex_lit",
+ "secp256k1 0.27.0",
 ]
 
+[[package]]
+name = "bitcoin-internals"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9425c3bf7089c983facbae04de54513cce73b41c7f9ff8c845b54e7bc64ebbfb"
+
+[[package]]
+name = "bitcoin-private"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73290177011694f38ec25e165d0387ab7ea749a4b81cd4c80dae5988229f7a57"
+
 [[package]]
 name = "bitcoin_hashes"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90064b8dee6815a6470d60bad07bbbaee885c0e12d04177138fa3291a01b7bc4"
 
+[[package]]
+name = "bitcoin_hashes"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d7066118b13d4b20b23645932dfb3a81ce7e29f95726c2036fa33cd7b092501"
+dependencies = [
+ "bitcoin-private",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1930a4dabfebb8d7d9992db18ebe3ae2876f0a305fab206fd168df931ede293b"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -156,7 +206,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a4b7b647ac3591f204635a704dcbf23b74f0b2be60dd23c9b2aa63caac4eb19"
 dependencies = [
  "aes-ctr",
- "bitcoin",
+ "bitcoin 0.29.2",
  "hidapi",
 ]
 
@@ -254,6 +304,18 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "hex-conservative"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30ed443af458ccb6d81c1e7e661545f94d3176752fb1df2f543b902a1e0f51e2"
+
+[[package]]
+name = "hex_lit"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
+
 [[package]]
 name = "hidapi"
 version = "1.4.2"
@@ -374,8 +436,7 @@ dependencies = [
 name = "nakamoto-common"
 version = "0.4.0"
 dependencies = [
- "bitcoin",
- "bitcoin_hashes",
+ "bitcoin 0.30.0",
  "fastrand",
  "log",
  "microserde",
@@ -661,9 +722,19 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff55dc09d460954e9ef2fa8a7ced735a964be9981fd50e870b2b3b0705e14964"
 dependencies = [
- "bitcoin_hashes",
+ "bitcoin_hashes 0.11.0",
  "rand",
- "secp256k1-sys",
+ "secp256k1-sys 0.6.1",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25996b82292a7a57ed3508f052cfff8640d38d32018784acd714758b43da9c8f"
+dependencies = [
+ "bitcoin_hashes 0.12.0",
+ "secp256k1-sys 0.8.1",
 ]
 
 [[package]]
@@ -675,6 +746,15 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "secp256k1-sys"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70a129b9e9efbfb223753b9163c4ab3b13cff7fd9c7f010fbac25ab4099fa07e"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "signal-hook"
 version = "0.3.14"
diff --git a/chain/src/block.rs b/chain/src/block.rs
index 279ebc14..0f4de162 100644
--- a/chain/src/block.rs
+++ b/chain/src/block.rs
@@ -2,7 +2,7 @@
 pub mod cache;
 pub mod store;
 
-pub use nakamoto_common::bitcoin::blockdata::block::{Block, BlockHeader};
+pub use nakamoto_common::bitcoin::blockdata::block::{Block, Header as BlockHeader};
 pub use nakamoto_common::bitcoin::blockdata::transaction::Transaction;
 pub use nakamoto_common::bitcoin::hash_types::BlockHash;
 pub use nakamoto_common::block::tree::*;
diff --git a/chain/src/block/cache.rs b/chain/src/block/cache.rs
index 8312782a..cfb68371 100644
--- a/chain/src/block/cache.rs
+++ b/chain/src/block/cache.rs
@@ -11,15 +11,16 @@ use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
 use std::ops::ControlFlow;
 
+use common::bitcoin::block::ValidationError;
+use common::bitcoin::CompactTarget;
+use common::block::Target;
 use nakamoto_common as common;
 use nakamoto_common::bitcoin;
-use nakamoto_common::bitcoin::blockdata::block::BlockHeader;
+use nakamoto_common::bitcoin::blockdata::block::Header as BlockHeader;
 use nakamoto_common::bitcoin::consensus::params::Params;
 use nakamoto_common::bitcoin::hash_types::BlockHash;
-use nakamoto_common::bitcoin::network::constants::Network;
-use nakamoto_common::bitcoin::util::BitArray;
+use nakamoto_common::bitcoin::network::Network;
 
-use nakamoto_common::bitcoin::util::uint::Uint256;
 use nakamoto_common::block::tree::{self, BlockReader, BlockTree, Branch, Error, ImportResult};
 use nakamoto_common::block::{
     self,
@@ -76,7 +77,7 @@ pub struct BlockCache<S: Store> {
     checkpoints: BTreeMap<Height, BlockHash>,
     params: Params,
     /// Total cumulative work on the active chain.
-    chainwork: Uint256,
+    chainwork: Work,
     store: S,
 }
 
@@ -240,20 +241,16 @@ impl<S: Store<Header = BlockHeader>> BlockCache<S> {
         //
         // We do this because it's cheap to verify and prevents flooding attacks.
         let target = header.target();
-        match header.validate_pow(&target) {
+        match header.validate_pow(target) {
             Ok(_) => {
-                let limit = self.params.pow_limit;
+                let limit = self.params.pow_limit.to_target();
                 if target > limit {
                     return Err(Error::InvalidBlockTarget(target, limit));
                 }
             }
-            Err(bitcoin::util::Error::BlockBadProofOfWork) => {
+            Err(ValidationError::BadProofOfWork) => {
                 return Err(Error::InvalidBlockPoW);
             }
-            Err(bitcoin::util::Error::BlockBadTarget) => unreachable! {
-                // The only way to get a 'bad target' error is to pass a different target
-                // than the one specified in the header.
-            },
             Err(_) => unreachable! {
                 // We've handled all possible errors above.
             },
@@ -288,7 +285,9 @@ impl<S: Store<Header = BlockHeader>> BlockCache<S> {
 
         let mut best_branch = None;
         let mut best_hash = tip.hash();
-        let mut best_work = Uint256::zero();
+        // FIXME: this need to be a Work by network? or the min is equal for
+        // every network?
+        let mut best_work = Work::MAINNET_MIN;
 
         for branch in candidates.iter() {
             // Total work included in this branch.
@@ -453,15 +452,12 @@ impl<S: Store<Header = BlockHeader>> BlockCache<S> {
             self.next_difficulty_target(tip.height, tip.time, tip.target(), &self.params)
         };
 
-        let target = BlockHeader::u256_from_compact_target(compact_target);
+        let target = Target::from_compact(CompactTarget::from_consensus(compact_target));
 
-        match header.validate_pow(&target) {
-            Err(bitcoin::util::Error::BlockBadProofOfWork) => {
+        match header.validate_pow(target) {
+            Err(ValidationError::BadProofOfWork) => {
                 return Err(Error::InvalidBlockPoW);
             }
-            Err(bitcoin::util::Error::BlockBadTarget) => {
-                return Err(Error::InvalidBlockTarget(header.target(), target));
-            }
             Err(_) => unreachable!(),
             Ok(_) => {}
         }
@@ -497,10 +493,10 @@ impl<S: Store<Header = BlockHeader>> BlockCache<S> {
         let pow_limit_bits = block::pow_limit_bits(&params.network);
 
         for (height, header) in self.iter().rev() {
-            if header.bits != pow_limit_bits
+            if header.bits.to_consensus() != pow_limit_bits
                 || height % self.params.difficulty_adjustment_interval() == 0
             {
-                return header.bits;
+                return header.bits.to_consensus();
             }
         }
         pow_limit_bits
@@ -682,7 +678,7 @@ impl<S: Store<Header = BlockHeader>> BlockReader for BlockCache<S> {
     }
 
     /// Get the "chainwork", ie. the total accumulated proof-of-work of the active chain.
-    fn chain_work(&self) -> Uint256 {
+    fn chain_work(&self) -> Work {
         self.chainwork
     }
 
diff --git a/chain/src/block/cache/test.rs b/chain/src/block/cache/test.rs
index 6b498c23..14c4da3b 100644
--- a/chain/src/block/cache/test.rs
+++ b/chain/src/block/cache/test.rs
@@ -1,9 +1,10 @@
 use super::BlockCache;
 
+use nakamoto_common::bitcoin::block::Version;
 use nakamoto_common::bitcoin_hashes::Hash;
 use nakamoto_common::block::time::{AdjustedTime, Clock, LocalTime};
 use nakamoto_common::block::tree::{BlockReader, BlockTree, Error, ImportResult};
-use nakamoto_common::block::{BlockTime, Height, Target};
+use nakamoto_common::block::{BlockTime, Height, Target, Work};
 use nakamoto_common::nonempty::NonEmpty;
 
 use nakamoto_test::assert_matches;
@@ -15,30 +16,24 @@ use crate::block::store::{self, Store};
 use std::collections::{BTreeMap, VecDeque};
 use std::iter;
 use std::net;
+use std::str::FromStr;
 use std::sync::{Arc, RwLock};
 
 use quickcheck::{Arbitrary, Gen};
 use quickcheck_macros::quickcheck;
 
-use nakamoto_common::bitcoin;
-use nakamoto_common::bitcoin::blockdata::block::BlockHeader;
+use nakamoto_common::bitcoin::blockdata::block::Header as BlockHeader;
 use nakamoto_common::bitcoin::blockdata::constants;
 use nakamoto_common::bitcoin::consensus::params::Params;
 use nakamoto_common::bitcoin::hash_types::{BlockHash, TxMerkleNode};
+use nakamoto_common::bitcoin::{self, CompactTarget};
 use nakamoto_common::bitcoin_hashes::hex::FromHex;
 
-use nakamoto_common::bitcoin::util::uint::Uint256;
-
 /// Sun, 12 Jul 2020 15:03:05 +0000.
 const LOCAL_TIME: LocalTime = LocalTime::from_secs(1594566185);
 
 /// Lowest possible difficulty.
-const TARGET: Uint256 = Uint256([
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0x7fffffffffffffffu64,
-]);
+const TARGET: Target = Target::ZERO;
 /// Target block time (1 minute).
 const TARGET_SPACING: BlockTime = 60 * 10;
 /// Target time span (1 hour).
@@ -92,7 +87,7 @@ impl BlockReader for HeightCache {
         self.headers.get(&height)
     }
 
-    fn chain_work(&self) -> Uint256 {
+    fn chain_work(&self) -> Work {
         unimplemented!()
     }
 
@@ -183,7 +178,7 @@ mod arbitrary {
                     height,
                     header.block_hash(),
                     header.time,
-                    header.bits,
+                    header.bits.to_consensus(),
                     header.nonce
                 )?;
             }
@@ -259,7 +254,7 @@ mod arbitrary {
                     header.block_hash(),
                     header.prev_blockhash,
                     header.time,
-                    header.bits,
+                    header.bits.to_consensus(),
                 )?;
             }
             Ok(())
@@ -276,10 +271,10 @@ fn arbitrary_header(
     let delta = u32::arbitrary(g) % (TARGET_SPACING * 2) + TARGET_SPACING / 2;
 
     let time = prev_time + delta;
-    let bits = BlockHeader::compact_target_from_u256(target);
+    let bits = target.to_compact_lossy();
 
     let mut header = BlockHeader {
-        version: 1,
+        version: Version::from_consensus(1),
         time,
         nonce: 0,
         bits,
@@ -369,14 +364,15 @@ fn prop_invalid_block_target(import: BlockImport) -> bool {
     assert!(cache.clone().import_block(header, &ctx).is_ok());
 
     let header = BlockHeader {
-        bits: genesis.bits - 1,
+        bits: CompactTarget::from_consensus(genesis.bits.to_consensus() - 1),
         ..header
     };
 
+    let result = CompactTarget::from_consensus(genesis.bits.to_consensus() - 1);
     matches! {
         cache.import_block(header, &ctx).err(),
         Some(Error::InvalidBlockTarget(actual, expected))
-            if actual == BlockHeader::u256_from_compact_target(genesis.bits - 1)
+            if actual == Target::from_compact(result)
                 && expected == genesis.target()
     }
 }
@@ -390,18 +386,13 @@ fn test_invalid_orphan_block_target() {
     let params = Params::new(network);
 
     // A lower difficulty target than expected.
-    let invalid_bits: Uint256 = Uint256([
-        0xffffffffffffffffu64,
-        0xffffffffffffffffu64,
-        0xffffffffffffffffu64,
-        0x9fffffffffffffffu64,
-    ]);
+    let invalid_bits = Target::ZERO;
 
     let mut cache = BlockCache::from(store, params.clone(), &[]).unwrap();
 
     // Some arbitrary previous block we don't have.
     let prev_blockhash =
-        BlockHash::from_hex("0f9188f13cb7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
+        BlockHash::from_str("0f9188f13cb7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
             .unwrap();
 
     // A valid header.
@@ -422,7 +413,7 @@ fn test_invalid_orphan_block_target() {
 
     // An invalid header.
     let mut header = BlockHeader {
-        bits: BlockHeader::compact_target_from_u256(&invalid_bits),
+        bits: invalid_bits.to_compact_lossy(),
         ..header
     };
     block::solve(&mut header);
@@ -430,13 +421,10 @@ fn test_invalid_orphan_block_target() {
     // Even though the header can't be connected to the main chain, we still get an error.
     match cache.import_block(header, &clock).unwrap_err() {
         Error::InvalidBlockTarget(actual, expected) => {
+            assert_eq!(actual.to_compact_lossy(), invalid_bits.to_compact_lossy());
             assert_eq!(
-                BlockHeader::compact_target_from_u256(&actual),
-                BlockHeader::compact_target_from_u256(&invalid_bits)
-            );
-            assert_eq!(
-                BlockHeader::compact_target_from_u256(&expected),
-                BlockHeader::compact_target_from_u256(&params.pow_limit)
+                expected.to_compact_lossy(),
+                params.pow_limit.to_target().to_compact_lossy(),
             );
         }
         err => panic!("wrong error returned: {:?}", err),
@@ -455,7 +443,7 @@ fn test_invalid_orphan_block_pow() {
 
     // Some arbitrary previous block we don't have.
     let prev_blockhash =
-        BlockHash::from_hex("0f9188f13cb7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
+        BlockHash::from_str("0f9188f13cb7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
             .unwrap();
 
     // An invalid header.
@@ -484,7 +472,7 @@ fn prop_invalid_block_pow(import: BlockImport) -> bool {
     let mut header = header;
 
     // Find an *invalid* nonce.
-    while header.validate_pow(&header.target()).is_ok() {
+    while header.validate_pow(header.target()).is_ok() {
         header.nonce += 1;
     }
 
@@ -509,7 +497,7 @@ fn test_bitcoin_difficulty() {
         let target = cache.next_difficulty_target(
             height - 1,
             prev_time,
-            BlockHeader::u256_from_compact_target(prev_bits),
+            Target::from_compact(CompactTarget::from_consensus(prev_bits)),
             &params,
         );
 
@@ -520,9 +508,9 @@ fn test_bitcoin_difficulty() {
         cache.import(
             height,
             BlockHeader {
-                version: 1,
+                version: Version::from_consensus(1),
                 time,
-                bits,
+                bits: CompactTarget::from_consensus(bits),
                 merkle_root: TxMerkleNode::all_zeros(),
                 prev_blockhash: BlockHash::all_zeros(),
                 nonce: 0,
@@ -617,10 +605,10 @@ impl Tree {
     fn next(&self, g: &mut fastrand::Rng) -> Tree {
         let nonce = g.u32(..);
         let mut header = BlockHeader {
-            version: 1,
+            version: Version::from_consensus(1),
             prev_blockhash: self.hash,
             merkle_root: TxMerkleNode::all_zeros(),
-            bits: BlockHeader::compact_target_from_u256(&TARGET),
+            bits: TARGET.to_compact_lossy(),
             time: self.time + TARGET_SPACING,
             nonce,
         };
@@ -640,15 +628,15 @@ impl Tree {
     fn next_invalid(&self, g: &mut fastrand::Rng) -> Tree {
         let nonce = g.u32(..);
         let mut header = BlockHeader {
-            version: 1,
+            version: Version::from_consensus(1),
             prev_blockhash: self.hash,
             merkle_root: TxMerkleNode::all_zeros(),
-            bits: BlockHeader::compact_target_from_u256(&TARGET),
+            bits: TARGET.to_compact_lossy(),
             time: self.time + TARGET_SPACING,
             nonce,
         };
         let target = header.target();
-        while header.validate_pow(&target).is_ok() {
+        while header.validate_pow(target).is_ok() {
             header.nonce += 1;
         }
 
@@ -1012,36 +1000,36 @@ fn test_cache_import_back_and_forth() {
 fn test_cache_import_equal_difficulty_blocks() {
     let mut headers = vec![
         BlockHeader {
-            version: 1,
-            prev_blockhash: BlockHash::from_hex(
+            version: Version::from_consensus(1),
+            prev_blockhash: BlockHash::from_str(
                 "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
             )
             .unwrap(),
             merkle_root: TxMerkleNode::all_zeros(),
             time: 1296688662,
-            bits: 545259519,
+            bits: CompactTarget::from_consensus(545259519),
             nonce: 3705677718,
         },
         BlockHeader {
-            version: 1,
-            prev_blockhash: BlockHash::from_hex(
+            version: Version::from_consensus(1),
+            prev_blockhash: BlockHash::from_str(
                 "40e6856aba3aa0bab2ba97b5612dc22a485c3a583dc98a9f1cd1706dd858f623",
             )
             .unwrap(),
             merkle_root: TxMerkleNode::all_zeros(),
             time: 1296688722,
-            bits: 545259519,
+            bits: CompactTarget::from_consensus(545259519),
             nonce: 3581550584,
         },
         BlockHeader {
-            version: 1,
-            prev_blockhash: BlockHash::from_hex(
+            version: Version::from_consensus(1),
+            prev_blockhash: BlockHash::from_str(
                 "40e6856aba3aa0bab2ba97b5612dc22a485c3a583dc98a9f1cd1706dd858f623",
             )
             .unwrap(),
             merkle_root: TxMerkleNode::all_zeros(),
             time: 1296688722,
-            bits: 545259519,
+            bits: CompactTarget::from_consensus(545259519),
             nonce: 3850925874,
         },
     ];
@@ -1060,7 +1048,7 @@ fn test_cache_import_equal_difficulty_blocks() {
     assert_eq!(real.tip(), model.tip());
 
     let expected =
-        BlockHash::from_hex("79cdea612df7f65b541da8ff45913f472eb0bf9376e1b9e3cd2c6ce78f261954")
+        BlockHash::from_str("79cdea612df7f65b541da8ff45913f472eb0bf9376e1b9e3cd2c6ce78f261954")
             .unwrap();
 
     assert_eq!(real.tip().0, expected);
@@ -1462,7 +1450,7 @@ fn test_cache_locate_headers() {
     );
 
     let unknown =
-        BlockHash::from_hex("0f9188f13cb7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
+        BlockHash::from_str("0f9188f13cb7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
             .unwrap();
 
     assert_eq!(
diff --git a/chain/src/block/store/io.rs b/chain/src/block/store/io.rs
index 91f518f8..14240fd9 100644
--- a/chain/src/block/store/io.rs
+++ b/chain/src/block/store/io.rs
@@ -252,7 +252,9 @@ impl<H: 'static + Copy + Encodable + Decodable> Store for File<H> {
 mod test {
     use std::{io, iter};
 
-    use nakamoto_common::bitcoin::TxMerkleNode;
+    use nakamoto_common::bitcoin::string::FromHexStr;
+    use nakamoto_common::bitcoin::CompactTarget;
+    use nakamoto_common::bitcoin::{block::Version, hash_types::TxMerkleNode};
     use nakamoto_common::bitcoin_hashes::Hash;
     use nakamoto_common::block::BlockHash;
 
@@ -264,10 +266,10 @@ mod test {
     fn store(path: &str) -> File<BlockHeader> {
         let tmp = tempfile::tempdir().unwrap();
         let genesis = BlockHeader {
-            version: 1,
+            version: Version::from_consensus(1),
             prev_blockhash: BlockHash::all_zeros(),
             merkle_root: TxMerkleNode::all_zeros(),
-            bits: 0x2ffffff,
+            bits: CompactTarget::from_consensus(0x2ffffff),
             time: 39123818,
             nonce: 0,
         };
@@ -280,10 +282,10 @@ mod test {
         let mut store = store("headers.db");
 
         let header = BlockHeader {
-            version: 1,
+            version: Version::from_consensus(1),
             prev_blockhash: store.genesis.block_hash(),
             merkle_root: TxMerkleNode::all_zeros(),
-            bits: 0x2ffffff,
+            bits: CompactTarget::from_consensus(0x2ffffff),
             time: 1842918273,
             nonce: 312143,
         };
@@ -313,10 +315,10 @@ mod test {
 
         let count = 32;
         let header = BlockHeader {
-            version: 1,
+            version: Version::from_consensus(1),
             prev_blockhash: store.genesis().block_hash(),
             merkle_root: TxMerkleNode::all_zeros(),
-            bits: 0x2ffffff,
+            bits: CompactTarget::from_consensus(0x2ffffff),
             time: 1842918273,
             nonce: 0,
         };
@@ -377,10 +379,10 @@ mod test {
 
         let count = 32;
         let header = BlockHeader {
-            version: 1,
+            version: Version::from_consensus(1),
             prev_blockhash: store.genesis().block_hash(),
             merkle_root: TxMerkleNode::all_zeros(),
-            bits: 0x2ffffff,
+            bits: CompactTarget::from_consensus(0x2ffffff),
             time: 1842918273,
             nonce: 0,
         };
@@ -409,18 +411,18 @@ mod test {
 
         let headers = &[
             BlockHeader {
-                version: 1,
+                version: Version::from_consensus(1),
                 prev_blockhash: store.genesis().block_hash(),
                 merkle_root: TxMerkleNode::all_zeros(),
-                bits: 0x2ffffff,
+                bits: CompactTarget::from_consensus(0x2ffffff),
                 time: 1842918273,
                 nonce: 312143,
             },
             BlockHeader {
-                version: 1,
+                version: Version::from_consensus(1),
                 prev_blockhash: BlockHash::all_zeros(),
                 merkle_root: TxMerkleNode::all_zeros(),
-                bits: 0x1ffffff,
+                bits: CompactTarget::from_consensus(0x1ffffff),
                 time: 1842918920,
                 nonce: 913716378,
             },
diff --git a/chain/src/filter.rs b/chain/src/filter.rs
index 7d85adab..75d9b97d 100644
--- a/chain/src/filter.rs
+++ b/chain/src/filter.rs
@@ -2,4 +2,4 @@
 pub mod cache;
 pub mod store;
 
-pub use nakamoto_common::bitcoin::util::bip158::BlockFilter;
+pub use nakamoto_common::bitcoin::bip158::BlockFilter;
diff --git a/client/src/client.rs b/client/src/client.rs
index c3eefdf4..c094cd67 100644
--- a/client/src/client.rs
+++ b/client/src/client.rs
@@ -21,11 +21,13 @@ use nakamoto_chain::{block::cache::BlockCache, filter::BlockFilter};
 use nakamoto_common::bitcoin::network::constants::ServiceFlags;
 use nakamoto_common::bitcoin::network::message::NetworkMessage;
 use nakamoto_common::bitcoin::network::Address;
-use nakamoto_common::bitcoin::util::uint::Uint256;
+use nakamoto_common::bitcoin::CompactTarget;
 use nakamoto_common::bitcoin::Txid;
 use nakamoto_common::block::store::{Genesis as _, Store as _};
 use nakamoto_common::block::time::{AdjustedTime, RefClock};
 use nakamoto_common::block::tree::{self, BlockReader, ImportResult};
+use nakamoto_common::block::Target;
+use nakamoto_common::block::Work;
 use nakamoto_common::block::{BlockHash, BlockHeader, Height, Transaction};
 use nakamoto_common::nonempty::NonEmpty;
 use nakamoto_common::p2p::peer::{Source, Store as _};
@@ -482,8 +484,8 @@ impl<W: Waker> Handle<W> {
 }
 
 impl<W: Waker> handle::Handle for Handle<W> {
-    fn get_tip(&self) -> Result<(Height, BlockHeader, Uint256), handle::Error> {
-        let (transmit, receive) = chan::bounded::<(Height, BlockHeader, Uint256)>(1);
+    fn get_tip(&self) -> Result<(Height, BlockHeader, Work), handle::Error> {
+        let (transmit, receive) = chan::bounded::<(Height, BlockHeader, Work)>(1);
         self._command(Command::GetTip(transmit))?;
 
         Ok(receive.recv()?)
diff --git a/client/src/event.rs b/client/src/event.rs
index 1b084ab1..78975be5 100644
--- a/client/src/event.rs
+++ b/client/src/event.rs
@@ -584,6 +584,7 @@ mod test {
     use std::io;
 
     use nakamoto_common::bitcoin_hashes::Hash;
+    use nakamoto_common::block::{Target, Work};
     use quickcheck::TestResult;
     use quickcheck_macros::quickcheck;
 
@@ -787,7 +788,7 @@ mod test {
         let mut mock = mock::Client::new(network);
         let mut client = mock.handle();
 
-        client.tip = (height, chain[height as usize].header, Default::default());
+        client.tip = (height, chain[height as usize].header, Work::REGTEST_MIN);
 
         let mut spent = 0;
         let (watch, heights, balance) = gen::watchlist_rng(birth, chain.iter(), &mut rng);
diff --git a/client/src/handle.rs b/client/src/handle.rs
index 70a4fb29..fa3e68e5 100644
--- a/client/src/handle.rs
+++ b/client/src/handle.rs
@@ -8,13 +8,12 @@ use thiserror::Error;
 
 use nakamoto_common::bitcoin::network::constants::ServiceFlags;
 use nakamoto_common::bitcoin::network::Address;
-use nakamoto_common::bitcoin::util::uint::Uint256;
-use nakamoto_common::bitcoin::{Script, Txid};
+use nakamoto_common::bitcoin::{Script, ScriptBuf, Txid};
 
 use nakamoto_common::bitcoin::network::message::NetworkMessage;
 use nakamoto_common::block::filter::BlockFilter;
 use nakamoto_common::block::tree::{BlockReader, ImportResult};
-use nakamoto_common::block::{self, Block, BlockHash, BlockHeader, Height, Transaction};
+use nakamoto_common::block::{self, Block, BlockHash, BlockHeader, Height, Transaction, Work};
 use nakamoto_common::nonempty::NonEmpty;
 use nakamoto_p2p::fsm::Link;
 use nakamoto_p2p::fsm::{self, Command, CommandError, GetFiltersError, Peer};
@@ -66,7 +65,7 @@ impl<T> From<chan::SendError<T>> for Error {
 pub trait Handle: Sized + Send + Sync + Clone {
     /// Get the tip of the active chain. Returns the height of the chain, the header,
     /// and the total accumulated work.
-    fn get_tip(&self) -> Result<(Height, BlockHeader, Uint256), Error>;
+    fn get_tip(&self) -> Result<(Height, BlockHeader, Work), Error>;
     /// Get a block header from the block header cache.
     fn get_block(&self, hash: &BlockHash) -> Result<Option<(Height, BlockHeader)>, Error>;
     /// Get a block header by height, from the block header cache.
@@ -106,7 +105,7 @@ pub trait Handle: Sized + Send + Sync + Clone {
     fn rescan(
         &self,
         range: impl RangeBounds<Height>,
-        watch: impl Iterator<Item = Script>,
+        watch: impl Iterator<Item = ScriptBuf>,
     ) -> Result<(), Error> {
         // TODO: Handle invalid/empty ranges.
 
@@ -126,7 +125,7 @@ pub trait Handle: Sized + Send + Sync + Clone {
     /// Note that this won't trigger a rescan of any existing blocks. To avoid
     /// missing matching blocks, always watch scripts before sharing their
     /// corresponding address.
-    fn watch(&self, watch: impl Iterator<Item = Script>) -> Result<(), Error> {
+    fn watch(&self, watch: impl Iterator<Item = ScriptBuf>) -> Result<(), Error> {
         self.command(Command::Watch {
             watch: watch.collect(),
         })?;
diff --git a/client/src/tests/mock.rs b/client/src/tests/mock.rs
index b9a93981..db320231 100644
--- a/client/src/tests/mock.rs
+++ b/client/src/tests/mock.rs
@@ -8,14 +8,13 @@ use nakamoto_chain::filter::BlockFilter;
 
 use nakamoto_common::bitcoin::network::constants::ServiceFlags;
 use nakamoto_common::bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
-use nakamoto_common::bitcoin::network::Address;
-use nakamoto_common::bitcoin::util::uint::Uint256;
+use nakamoto_common::bitcoin::network::{Address, Magic};
 use nakamoto_common::bitcoin::Txid;
 use nakamoto_common::block::filter::FilterHeader;
 use nakamoto_common::block::store::Genesis as _;
 use nakamoto_common::block::time::{AdjustedTime, LocalTime};
 use nakamoto_common::block::tree::{self, ImportResult};
-use nakamoto_common::block::{BlockHash, BlockHeader, Height, Transaction};
+use nakamoto_common::block::{BlockHash, BlockHeader, Height, Transaction, Work};
 use nakamoto_common::network::Network;
 use nakamoto_common::nonempty::NonEmpty;
 use nakamoto_common::p2p::peer::KnownAddress;
@@ -137,7 +136,7 @@ impl Default for Client {
 
 #[derive(Clone)]
 pub struct TestHandle {
-    pub tip: (Height, BlockHeader, Uint256),
+    pub tip: (Height, BlockHeader, Work),
 
     #[allow(dead_code)]
     network: Network,
@@ -148,7 +147,7 @@ pub struct TestHandle {
 }
 
 impl Handle for TestHandle {
-    fn get_tip(&self) -> Result<(Height, BlockHeader, Uint256), handle::Error> {
+    fn get_tip(&self) -> Result<(Height, BlockHeader, Work), handle::Error> {
         Ok(self.tip)
     }
 
diff --git a/common/Cargo.toml b/common/Cargo.toml
index 2a9fe19e..39fb7f40 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -11,8 +11,7 @@ edition = "2021"
 
 [dependencies]
 nakamoto-net = { version = "0.4.0", path = "../net" }
-bitcoin = "0.29.2"
-bitcoin_hashes = "0.11.0"
+bitcoin = { git = "https://github.com/vincenzopalazzo/rust-bitcoin.git", branch = "macros/calculate-next-work-requried" }
 thiserror = "1.0"
 fastrand = "1.3.5"
 nonempty = "0.7"
diff --git a/common/src/block.rs b/common/src/block.rs
index 8fcf5100..72393a63 100644
--- a/common/src/block.rs
+++ b/common/src/block.rs
@@ -7,15 +7,10 @@ pub mod store;
 pub mod time;
 pub mod tree;
 
-pub use bitcoin::blockdata::block::{Block, BlockHeader};
+pub use bitcoin::blockdata::block::{Block, Header as BlockHeader};
 pub use bitcoin::blockdata::transaction::Transaction;
 pub use bitcoin::hash_types::BlockHash;
-
-/// Difficulty target of a block.
-pub type Target = bitcoin::util::uint::Uint256;
-
-/// Block work.
-pub type Work = bitcoin::util::uint::Uint256;
+pub use bitcoin::pow::{Target, Work};
 
 /// Compact difficulty bits (target) of a block.
 pub type Bits = u32;
@@ -62,5 +57,6 @@ pub fn pow_limit_bits(network: &bitcoin::Network) -> Bits {
         bitcoin::Network::Testnet => 0x1d00ffff,
         bitcoin::Network::Regtest => 0x207fffff,
         bitcoin::Network::Signet => 0x1e0377ae,
+        _ => unreachable!(),
     }
 }
diff --git a/common/src/block/filter.rs b/common/src/block/filter.rs
index 2451ee29..e6b0f768 100644
--- a/common/src/block/filter.rs
+++ b/common/src/block/filter.rs
@@ -3,13 +3,13 @@
 
 use std::ops::RangeInclusive;
 
-use bitcoin_hashes::Hash;
 use thiserror::Error;
 
+pub use bitcoin::bip158::BlockFilter;
 pub use bitcoin::hash_types::{FilterHash, FilterHeader};
-pub use bitcoin::util::bip158::BlockFilter;
 
 use super::Height;
+use crate::bitcoin_hashes::Hash;
 use crate::block::store::{self, Genesis};
 use crate::network::Network;
 
diff --git a/common/src/block/store.rs b/common/src/block/store.rs
index ea755699..7b71e58d 100644
--- a/common/src/block/store.rs
+++ b/common/src/block/store.rs
@@ -1,11 +1,14 @@
 //! Block header storage.
 #![allow(clippy::len_without_is_empty)]
+use std::borrow::Borrow;
+
 use crate::block::Height;
 
-use bitcoin::blockdata::block::BlockHeader;
+use bitcoin::bip158::BlockFilter;
+use bitcoin::block::Header;
 use bitcoin::consensus::encode;
 use bitcoin::hash_types::FilterHash;
-use bitcoin::util::bip158::BlockFilter;
+use bitcoin::{OutPoint, Script, ScriptBuf};
 use thiserror::Error;
 
 use crate::network::Network;
@@ -35,7 +38,7 @@ pub trait Genesis {
 }
 
 /// Genesis implementation for `bitcoin`'s header.
-impl Genesis for BlockHeader {
+impl Genesis for Header {
     fn genesis(network: Network) -> Self {
         network.genesis()
     }
@@ -47,9 +50,12 @@ impl Genesis for FilterHash {
         use bitcoin::hashes::Hash;
 
         let genesis = network.genesis_block();
-        let filter = BlockFilter::new_script_filter(&genesis, |_| {
-            panic!("{}: genesis block should have no inputs", source!())
-        })
+        let filter = BlockFilter::new_script_filter(
+            &genesis,
+            |_| -> Result<ScriptBuf, bitcoin::bip158::Error> {
+                panic!("{}: genesis block should have no inputs", source!())
+            },
+        )
         .unwrap();
 
         FilterHash::hash(&filter.content)
@@ -61,7 +67,7 @@ impl Genesis for BlockFilter {
     fn genesis(network: Network) -> Self {
         let genesis = network.genesis_block();
 
-        BlockFilter::new_script_filter(&genesis, |_| {
+        BlockFilter::new_script_filter(&genesis, |_| -> Result<ScriptBuf, bitcoin::bip158::Error> {
             panic!("{}: genesis block should have no inputs", source!())
         })
         .unwrap()
diff --git a/common/src/block/tree.rs b/common/src/block/tree.rs
index 41058914..4d927732 100644
--- a/common/src/block/tree.rs
+++ b/common/src/block/tree.rs
@@ -2,11 +2,12 @@
 #![warn(missing_docs)]
 use std::collections::BTreeMap;
 
-use bitcoin::blockdata::block::BlockHeader;
+use bitcoin::block::Header as BlockHeader;
 use bitcoin::consensus::params::Params;
 use bitcoin::hash_types::BlockHash;
-use bitcoin::util::uint::Uint256;
+use bitcoin::CompactTarget;
 
+use bitcoin::pow::calculate_next_work_required;
 use thiserror::Error;
 
 use crate::block::store;
@@ -102,7 +103,8 @@ pub struct Branch<'a, H: Header>(pub &'a [H]);
 impl<'a, H: Header> Branch<'a, H> {
     /// Compute the total proof-of-work carried by this branch.
     pub fn work(&self) -> Work {
-        let mut work = Work::default();
+        // FIXME: this should be by network
+        let mut work = Work::MAINNET_MIN;
         for header in self.0.iter() {
             work = work + header.work();
         }
@@ -145,7 +147,7 @@ pub trait BlockReader {
         Box::new(self.iter().map(|(_, h)| h))
     }
     /// Get the "chainwork", ie. the total accumulated proof-of-work of the active chain.
-    fn chain_work(&self) -> Uint256;
+    fn chain_work(&self) -> Work;
     /// Iterate over the longest chain, starting from genesis, including heights.
     fn iter<'a>(&'a self) -> Box<dyn DoubleEndedIterator<Item = (Height, BlockHeader)> + 'a>;
     /// Iterate over a range of blocks.
@@ -203,42 +205,15 @@ pub trait BlockReader {
         last_target: Target,
         params: &Params,
     ) -> Bits {
-        // Only adjust on set intervals. Otherwise return current target.
-        // Since the height is 0-indexed, we add `1` to check it against the interval.
-        if (last_height + 1) % params.difficulty_adjustment_interval() != 0 {
-            return BlockHeader::compact_target_from_u256(&last_target);
-        }
-
-        let last_adjustment_height =
-            last_height.saturating_sub(params.difficulty_adjustment_interval() - 1);
-        let last_adjustment_block = self
-            .get_block_by_height(last_adjustment_height)
-            .unwrap_or_else(|| self.genesis());
-        let last_adjustment_time = last_adjustment_block.time;
-
-        if params.no_pow_retargeting {
-            return last_adjustment_block.bits;
-        }
-
-        let actual_timespan = last_time - last_adjustment_time;
-        let mut adjusted_timespan = actual_timespan;
-
-        if actual_timespan < params.pow_target_timespan as BlockTime / 4 {
-            adjusted_timespan = params.pow_target_timespan as BlockTime / 4;
-        } else if actual_timespan > params.pow_target_timespan as BlockTime * 4 {
-            adjusted_timespan = params.pow_target_timespan as BlockTime * 4;
-        }
-
-        let mut target = last_target;
-
-        target = target.mul_u32(adjusted_timespan);
-        target = target / Target::from_u64(params.pow_target_timespan).unwrap();
-
-        // Ensure a difficulty floor.
-        if target > params.pow_limit {
-            target = params.pow_limit;
-        }
-
-        BlockHeader::compact_target_from_u256(&target)
+        // FIXME: improve the API usage and change the nakamoto height
+        calculate_next_work_required(
+            bitcoin::absolute::Height::from_consensus(last_height as u32).unwrap(),
+            last_time,
+            last_target,
+            params.difficulty_adjustment_interval(),
+            params.pow_target_timespan,
+            params.no_pow_retargeting,
+            |_| todo!(),
+        )
     }
 }
diff --git a/common/src/collections.rs b/common/src/collections.rs
index 766262bb..6e1c12e7 100644
--- a/common/src/collections.rs
+++ b/common/src/collections.rs
@@ -1,5 +1,5 @@
 //! Collections used in `nakamoto`.
-use bitcoin_hashes::siphash24::Hash;
+use bitcoin::hashes::siphash24::Hash;
 use std::ops::{Deref, DerefMut};
 
 use crate::nonempty::NonEmpty;
diff --git a/common/src/lib.rs b/common/src/lib.rs
index fff261ca..36af265e 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -7,7 +7,8 @@ pub mod network;
 pub mod p2p;
 
 pub use bitcoin;
-pub use bitcoin_hashes;
+// re-aliasing to bitcoin_hashes for retro-compatibility
+pub use bitcoin::hashes as bitcoin_hashes;
 pub use nakamoto_net as net;
 pub use nonempty;
 
diff --git a/common/src/network.rs b/common/src/network.rs
index b77dd9cd..bb38a29e 100644
--- a/common/src/network.rs
+++ b/common/src/network.rs
@@ -1,13 +1,12 @@
 //! Bitcoin peer network. Eg. *Mainnet*.
 use std::str::FromStr;
 
-use bitcoin::blockdata::block::{Block, BlockHeader};
+use bitcoin::blockdata::block::{Block, Header};
 use bitcoin::consensus::params::Params;
 use bitcoin::hash_types::BlockHash;
-use bitcoin::hashes::hex::FromHex;
-use bitcoin::network::constants::ServiceFlags;
+use bitcoin::p2p::{Magic, ServiceFlags};
 
-use bitcoin_hashes::sha256d;
+use bitcoin::hashes::sha256d;
 
 use crate::block::Height;
 
@@ -86,6 +85,7 @@ impl From<bitcoin::Network> for Network {
             bitcoin::Network::Testnet => Self::Testnet,
             bitcoin::Network::Signet => Self::Signet,
             bitcoin::Network::Regtest => Self::Regtest,
+            _ => unreachable!(),
         }
     }
 }
@@ -114,7 +114,7 @@ impl Network {
         .iter()
         .cloned()
         .map(|(height, hash)| {
-            let hash = BlockHash::from_hex(hash).unwrap();
+            let hash = BlockHash::from_str(hash).unwrap();
             (height, hash)
         });
 
@@ -169,7 +169,7 @@ impl Network {
     ///
     /// assert_eq!(network.genesis_hash(), genesis.block_hash());
     /// ```
-    pub fn genesis(&self) -> BlockHeader {
+    pub fn genesis(&self) -> Header {
         self.genesis_block().header
     }
 
@@ -183,7 +183,7 @@ impl Network {
     /// Get the hash of the genesis block of this network.
     pub fn genesis_hash(&self) -> BlockHash {
         use crate::block::genesis;
-        use bitcoin_hashes::Hash;
+        use bitcoin::hashes::Hash;
 
         let hash = match self {
             Self::Mainnet => genesis::MAINNET,
@@ -191,7 +191,7 @@ impl Network {
             Self::Regtest => genesis::REGTEST,
             Self::Signet => genesis::SIGNET,
         };
-        BlockHash::from_hash(
+        BlockHash::from_raw_hash(
             sha256d::Hash::from_slice(hash)
                 .expect("the genesis hash has the right number of bytes"),
         )
@@ -203,7 +203,7 @@ impl Network {
     }
 
     /// Get the network magic number for this network.
-    pub fn magic(&self) -> u32 {
+    pub fn magic(&self) -> Magic {
         bitcoin::Network::from(*self).magic()
     }
 }
diff --git a/common/src/p2p/peer.rs b/common/src/p2p/peer.rs
index 1949f39f..1446603d 100644
--- a/common/src/p2p/peer.rs
+++ b/common/src/p2p/peer.rs
@@ -5,9 +5,7 @@ use std::net;
 
 use microserde as serde;
 
-use bitcoin::network::address::Address;
-use bitcoin::network::constants::ServiceFlags;
-
+use crate::bitcoin::p2p::{Address, ServiceFlags};
 use crate::block::time::Clock;
 use crate::net::time::LocalTime;
 
diff --git a/p2p/src/fsm.rs b/p2p/src/fsm.rs
index eb8af178..ed1dccfe 100644
--- a/p2p/src/fsm.rs
+++ b/p2p/src/fsm.rs
@@ -45,22 +45,19 @@ use std::net;
 use std::ops::{Bound, RangeInclusive};
 use std::sync::Arc;
 
-use nakamoto_common::bitcoin::blockdata::block::BlockHeader;
 use nakamoto_common::bitcoin::consensus::encode;
 use nakamoto_common::bitcoin::consensus::params::Params;
-use nakamoto_common::bitcoin::network::constants::ServiceFlags;
-use nakamoto_common::bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
-use nakamoto_common::bitcoin::network::message_blockdata::{GetHeadersMessage, Inventory};
-use nakamoto_common::bitcoin::network::message_filter::GetCFilters;
-use nakamoto_common::bitcoin::network::message_network::VersionMessage;
-use nakamoto_common::bitcoin::network::Address;
-use nakamoto_common::bitcoin::util::uint::Uint256;
-use nakamoto_common::bitcoin::{Script, Txid};
+use nakamoto_common::bitcoin::p2p::message::{NetworkMessage, RawNetworkMessage};
+use nakamoto_common::bitcoin::p2p::message_blockdata::{GetHeadersMessage, Inventory};
+use nakamoto_common::bitcoin::p2p::message_filter::GetCFilters;
+use nakamoto_common::bitcoin::p2p::message_network::VersionMessage;
+use nakamoto_common::bitcoin::p2p::{Address, ServiceFlags};
+use nakamoto_common::bitcoin::{ScriptBuf, Txid};
 use nakamoto_common::block::filter::Filters;
 use nakamoto_common::block::time::AdjustedClock;
 use nakamoto_common::block::time::{LocalDuration, LocalTime};
 use nakamoto_common::block::tree::{self, BlockReader, BlockTree, ImportResult};
-use nakamoto_common::block::{BlockHash, Height};
+use nakamoto_common::block::{BlockHash, BlockHeader, Height, Work};
 use nakamoto_common::block::{BlockTime, Transaction};
 use nakamoto_common::network;
 use nakamoto_common::nonempty::NonEmpty;
@@ -233,7 +230,7 @@ pub enum Command {
     /// Get connected peers.
     GetPeers(ServiceFlags, chan::Sender<Vec<Peer>>),
     /// Get the tip of the active chain.
-    GetTip(chan::Sender<(Height, BlockHeader, Uint256)>),
+    GetTip(chan::Sender<(Height, BlockHeader, Work)>),
     /// Get a block from the active chain.
     RequestBlock(BlockHash),
     /// Get block filters.
@@ -248,12 +245,12 @@ pub enum Command {
         /// Stop scanning at this height. If unbounded, don't stop scanning.
         to: Bound<Height>,
         /// Scripts to match on.
-        watch: Vec<Script>,
+        watch: Vec<ScriptBuf>,
     },
     /// Update the watchlist with the provided scripts.
     Watch {
         /// Scripts to watch.
-        watch: Vec<Script>,
+        watch: Vec<ScriptBuf>,
     },
     /// Broadcast to peers matching the predicate.
     Broadcast(NetworkMessage, fn(Peer) -> bool, chan::Sender<Vec<PeerId>>),
@@ -791,8 +788,11 @@ impl<T: BlockTree, F: Filters, P: peer::Store, C: AdjustedClock<PeerId>> traits:
         let addr = *addr;
         let msg = msg.into_owned();
 
-        if msg.magic != self.network.magic() {
-            return self.disconnect(addr, DisconnectReason::PeerMagic(msg.magic));
+        if *msg.magic() != self.network.magic() {
+            return self.disconnect(
+                addr,
+                DisconnectReason::PeerMagic(u32::from_be_bytes(msg.magic().to_bytes())),
+            );
         }
 
         if !self.peermgr.is_connected(&addr) {
@@ -802,7 +802,7 @@ impl<T: BlockTree, F: Filters, P: peer::Store, C: AdjustedClock<PeerId>> traits:
 
         debug!(target: "p2p", "Received {:?} from {}", cmd, addr);
 
-        if let Err(err) = (self.hooks.on_message)(addr, &msg.payload, &self.outbox) {
+        if let Err(err) = (self.hooks.on_message)(addr, &msg.payload(), &self.outbox) {
             debug!(
                 target: "p2p",
                 "Message {:?} from {} dropped by user hook: {}",
@@ -811,7 +811,7 @@ impl<T: BlockTree, F: Filters, P: peer::Store, C: AdjustedClock<PeerId>> traits:
             return;
         }
 
-        match msg.payload {
+        match msg.payload() {
             NetworkMessage::Version(msg) => {
                 let height = self.tree.height();
 
diff --git a/p2p/src/fsm/addrmgr.rs b/p2p/src/fsm/addrmgr.rs
index d77a2036..86a82f9f 100644
--- a/p2p/src/fsm/addrmgr.rs
+++ b/p2p/src/fsm/addrmgr.rs
@@ -4,9 +4,7 @@
 #![warn(missing_docs)]
 use std::net;
 
-use nakamoto_common::bitcoin::network::address::Address;
-use nakamoto_common::bitcoin::network::constants::ServiceFlags;
-
+use nakamoto_common::bitcoin::p2p::{Address, ServiceFlags};
 use nakamoto_common::block::time::Clock;
 use nakamoto_common::block::time::{LocalDuration, LocalTime};
 use nakamoto_common::block::BlockTime;
diff --git a/p2p/src/fsm/cbfmgr.rs b/p2p/src/fsm/cbfmgr.rs
index e563e7b6..7a56ce3a 100644
--- a/p2p/src/fsm/cbfmgr.rs
+++ b/p2p/src/fsm/cbfmgr.rs
@@ -8,12 +8,11 @@ use std::ops::{Bound, RangeInclusive};
 
 use thiserror::Error;
 
-use nakamoto_common::bitcoin::network::constants::ServiceFlags;
-use nakamoto_common::bitcoin::network::message_filter::{CFHeaders, CFilter, GetCFHeaders};
-
-use nakamoto_common::bitcoin::{Script, Transaction, Txid};
-
-use nakamoto_common::block::filter::{self, BlockFilter, Filters};
+use nakamoto_common::bitcoin::p2p::message_filter::{CFHeaders, CFilter, GetCFHeaders};
+use nakamoto_common::bitcoin::p2p::ServiceFlags;
+use nakamoto_common::bitcoin::{ScriptBuf, Transaction, Txid};
+use nakamoto_common::block::filter;
+use nakamoto_common::block::filter::{BlockFilter, Filters};
 use nakamoto_common::block::time::{Clock, LocalDuration, LocalTime};
 use nakamoto_common::block::tree::BlockReader;
 use nakamoto_common::block::{BlockHash, Height};
@@ -427,7 +426,7 @@ impl<F: Filters, U: Wire<Event> + SetTimer + Disconnect, C: Clock> FilterManager
     }
 
     /// Add scripts to the list of scripts to watch.
-    pub fn watch(&mut self, scripts: Vec<Script>) {
+    pub fn watch(&mut self, scripts: Vec<ScriptBuf>) {
         self.rescan.watch.extend(scripts);
     }
 
@@ -449,7 +448,7 @@ impl<F: Filters, U: Wire<Event> + SetTimer + Disconnect, C: Clock> FilterManager
         &mut self,
         start: Bound<Height>,
         end: Bound<Height>,
-        watch: Vec<Script>,
+        watch: Vec<ScriptBuf>,
         tree: &T,
     ) -> Vec<(Height, BlockHash)> {
         self.rescan.restart(
@@ -1026,14 +1025,15 @@ impl Iterator for HeightIterator {
 mod tests {
     use std::iter;
     use std::ops::RangeBounds;
+    use std::str::FromStr;
 
     use nakamoto_common::bitcoin;
     use nakamoto_common::bitcoin_hashes;
 
+    use bitcoin::block::Header as BlockHeader;
     use bitcoin::consensus::Params;
     use bitcoin::network::message::NetworkMessage;
     use bitcoin::network::message_filter::GetCFilters;
-    use bitcoin::BlockHeader;
     use bitcoin_hashes::hex::FromHex;
 
     use nakamoto_chain::store::Genesis;
@@ -1232,17 +1232,17 @@ mod tests {
         {
             let msg = CFHeaders {
                 filter_type: 0,
-                stop_hash: BlockHash::from_hex(
+                stop_hash: BlockHash::from_str(
                     "00000000b3322c8c3ef7d2cf6da009a776e6a99ee65ec5a32f3f345712238473",
                 )
                 .unwrap(),
-                previous_filter_header: FilterHeader::from_hex(
+                previous_filter_header: FilterHeader::from_str(
                     "02c2392180d0ce2b5b6f8b08d39a11ffe831c673311a3ecf77b97fc3f0303c9f",
                 )
                 .unwrap(),
                 filter_hashes: FILTER_HASHES
                     .iter()
-                    .map(|h| FilterHash::from_hex(h).unwrap())
+                    .map(|h| FilterHash::from_str(h).unwrap())
                     .collect(),
             };
             cbfmgr.inflight.insert(msg.stop_hash, (1, *peer, time));
diff --git a/p2p/src/fsm/cbfmgr/rescan.rs b/p2p/src/fsm/cbfmgr/rescan.rs
index 9feb15c9..6548d16a 100644
--- a/p2p/src/fsm/cbfmgr/rescan.rs
+++ b/p2p/src/fsm/cbfmgr/rescan.rs
@@ -3,7 +3,7 @@ use std::collections::BTreeSet;
 use std::ops::RangeInclusive;
 use std::rc::Rc;
 
-use nakamoto_common::bitcoin::util::bip158;
+use nakamoto_common::bitcoin::{bip158, ScriptBuf};
 use nakamoto_common::bitcoin::{Script, Txid};
 use nakamoto_common::block::filter::BlockFilter;
 use nakamoto_common::block::tree::BlockReader;
@@ -27,9 +27,9 @@ pub struct Rescan {
     /// Filter cache.
     pub cache: FilterCache<Rc<BlockFilter>>,
     /// Addresses and outpoints to watch for.
-    pub watch: HashSet<Script>,
+    pub watch: HashSet<ScriptBuf>,
     /// Transactions to watch for.
-    pub transactions: HashMap<Txid, HashSet<Script>>,
+    pub transactions: HashMap<Txid, HashSet<ScriptBuf>>,
 
     /// Filters requested and remaining to download.
     requested: BTreeSet<Height>,
@@ -53,7 +53,7 @@ impl Rescan {
         &mut self,
         start: Height,
         end: Option<Height>,
-        watch: impl IntoIterator<Item = Script>,
+        watch: impl IntoIterator<Item = ScriptBuf>,
     ) {
         self.active = true;
         self.start = start;
diff --git a/p2p/src/fsm/event.rs b/p2p/src/fsm/event.rs
index d2e1a77f..0e4b4168 100644
--- a/p2p/src/fsm/event.rs
+++ b/p2p/src/fsm/event.rs
@@ -1,8 +1,9 @@
 //! State machine events.
-use nakamoto_common::bitcoin::network::message::NetworkMessage;
 
 use crate::fsm::{self, Height, LocalTime, PeerId};
 
+use nakamoto_common::bitcoin::p2p::message::NetworkMessage;
+
 /// A peer-to-peer event.
 #[derive(Debug, Clone)]
 pub enum Event {
diff --git a/p2p/src/fsm/fees.rs b/p2p/src/fsm/fees.rs
index 96ff3282..e68f4795 100644
--- a/p2p/src/fsm/fees.rs
+++ b/p2p/src/fsm/fees.rs
@@ -170,7 +170,7 @@ impl FeeEstimator {
 
         let fee = received - sent;
         let weight = tx.weight();
-        let rate = fee as f64 / (weight as f64 / WITNESS_SCALE_FACTOR as f64);
+        let rate = fee as f64 / (weight.to_wu() as f64 / WITNESS_SCALE_FACTOR as f64);
 
         Some(rate.round() as FeeRate)
     }
diff --git a/p2p/src/fsm/invmgr.rs b/p2p/src/fsm/invmgr.rs
index 2da55146..a335eee4 100644
--- a/p2p/src/fsm/invmgr.rs
+++ b/p2p/src/fsm/invmgr.rs
@@ -21,7 +21,8 @@
 //!
 use std::collections::BTreeMap;
 
-use nakamoto_common::bitcoin::network::{constants::ServiceFlags, message_blockdata::Inventory};
+use nakamoto_common::bitcoin::p2p::message_blockdata::Inventory;
+use nakamoto_common::bitcoin::p2p::ServiceFlags;
 use nakamoto_common::bitcoin::{Block, BlockHash, Transaction, Txid, Wtxid};
 
 // TODO: Timeout should be configurable
diff --git a/p2p/src/fsm/output.rs b/p2p/src/fsm/output.rs
index fef5e922..b1b3db34 100644
--- a/p2p/src/fsm/output.rs
+++ b/p2p/src/fsm/output.rs
@@ -13,13 +13,13 @@ use std::rc::Rc;
 
 pub use crossbeam_channel as chan;
 
-use nakamoto_common::bitcoin::network::address::Address;
-use nakamoto_common::bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
-use nakamoto_common::bitcoin::network::message_blockdata::{GetHeadersMessage, Inventory};
-use nakamoto_common::bitcoin::network::message_filter::{
+use nakamoto_common::bitcoin::p2p::message::{NetworkMessage, RawNetworkMessage};
+use nakamoto_common::bitcoin::p2p::message_blockdata::{GetHeadersMessage, Inventory};
+use nakamoto_common::bitcoin::p2p::message_filter::{
     CFHeaders, CFilter, GetCFHeaders, GetCFilters,
 };
-use nakamoto_common::bitcoin::network::message_network::VersionMessage;
+use nakamoto_common::bitcoin::p2p::message_network::VersionMessage;
+use nakamoto_common::bitcoin::p2p::Address;
 use nakamoto_common::bitcoin::Transaction;
 use nakamoto_common::block::time::LocalDuration;
 use nakamoto_common::block::{BlockHash, BlockHeader, BlockTime, Height};
diff --git a/p2p/src/fsm/peermgr.rs b/p2p/src/fsm/peermgr.rs
index 61297227..f68d0fc7 100644
--- a/p2p/src/fsm/peermgr.rs
+++ b/p2p/src/fsm/peermgr.rs
@@ -17,16 +17,13 @@
 use std::net;
 use std::sync::Arc;
 
-use nakamoto_common::bitcoin::network::address::Address;
-use nakamoto_common::bitcoin::network::constants::ServiceFlags;
-use nakamoto_common::bitcoin::network::message_network::VersionMessage;
-
-use nakamoto_common::p2p::peer::{AddressSource, Source};
-use nakamoto_common::p2p::Domain;
-
+use nakamoto_common::bitcoin::p2p::message_network::VersionMessage;
+use nakamoto_common::bitcoin::p2p::{Address, ServiceFlags};
 use nakamoto_common::block::time::{Clock, LocalDuration, LocalTime};
 use nakamoto_common::block::Height;
 use nakamoto_common::collections::{HashMap, HashSet};
+use nakamoto_common::p2p::peer::{AddressSource, Source};
+use nakamoto_common::p2p::Domain;
 use nakamoto_common::source;
 use nakamoto_net as network;
 
diff --git a/p2p/src/fsm/syncmgr.rs b/p2p/src/fsm/syncmgr.rs
index 3df8a437..5e84d911 100644
--- a/p2p/src/fsm/syncmgr.rs
+++ b/p2p/src/fsm/syncmgr.rs
@@ -2,8 +2,8 @@
 //! Manages header synchronization with peers.
 //!
 use nakamoto_common::bitcoin::consensus::params::Params;
-use nakamoto_common::bitcoin::network::constants::ServiceFlags;
-use nakamoto_common::bitcoin::network::message_blockdata::Inventory;
+use nakamoto_common::bitcoin::p2p::message_blockdata::Inventory;
+use nakamoto_common::bitcoin::p2p::ServiceFlags;
 
 use nakamoto_common::bitcoin_hashes::Hash;
 use nakamoto_common::block::store;
diff --git a/p2p/src/fsm/tests.rs b/p2p/src/fsm/tests.rs
index 36823fda..c5deb1cb 100644
--- a/p2p/src/fsm/tests.rs
+++ b/p2p/src/fsm/tests.rs
@@ -7,10 +7,12 @@ use std::io;
 use std::iter;
 use std::net;
 use std::ops::Bound;
+use std::str::FromStr;
 use std::sync::Arc;
 
 use log::*;
 use nakamoto_common::bitcoin::network::message_blockdata::GetHeadersMessage;
+use nakamoto_common::bitcoin::network::Magic;
 
 use super::{addrmgr, cbfmgr, invmgr, peermgr, pingmgr, syncmgr};
 use super::{
@@ -170,7 +172,7 @@ fn test_inv_getheaders() {
 
     // Some hash for a nonexistent block.
     let hash =
-        BlockHash::from_hex("0000000000b7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
+        BlockHash::from_str("0000000000b7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
             .unwrap();
 
     peer.connect_addr(&remote, Link::Outbound);
@@ -195,7 +197,7 @@ fn test_bad_magic() {
     peer.received_raw(
         &remote,
         RawNetworkMessage {
-            magic: 999,
+            magic: Magic::BITCOIN,
             payload: NetworkMessage::Ping(1),
         },
     );
@@ -266,7 +268,7 @@ fn test_getheaders_retry() {
 
     // Some hash for a nonexistent block.
     let hash =
-        BlockHash::from_hex("0000000000b7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
+        BlockHash::from_str("0000000000b7b2c71f2a345e3a4fc328bf5bbb436012afca590b1a11466e2206")
             .unwrap();
 
     let mut alice = Peer::genesis("alice", [49, 40, 43, 40], network, vec![], rng);
diff --git a/p2p/src/stream.rs b/p2p/src/stream.rs
index 91975be4..0b3abf35 100644
--- a/p2p/src/stream.rs
+++ b/p2p/src/stream.rs
@@ -44,7 +44,13 @@ impl Decoder {
 #[cfg(test)]
 mod test {
     use super::*;
-    use nakamoto_common::bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
+    use nakamoto_common::{
+        bitcoin::network::{
+            message::{NetworkMessage, RawNetworkMessage},
+            Magic,
+        },
+        block::Work,
+    };
     use quickcheck_macros::quickcheck;
 
     const MSG_VERACK: [u8; 24] = [
@@ -82,14 +88,14 @@ mod test {
         assert_eq!(
             msgs[0],
             RawNetworkMessage {
-                magic: 3652501241,
+                magic: Magic::REGTEST,
                 payload: NetworkMessage::Verack
             }
         );
         assert_eq!(
             msgs[1],
             RawNetworkMessage {
-                magic: 3652501241,
+                magic: Magic::REGTEST,
                 payload: NetworkMessage::Ping(100),
             }
         );
diff --git a/test/src/block.rs b/test/src/block.rs
index d8bee761..47873ff2 100644
--- a/test/src/block.rs
+++ b/test/src/block.rs
@@ -8,7 +8,7 @@ pub use nakamoto_common::block::*;
 /// Solve a block's proof of work puzzle.
 pub fn solve(header: &mut BlockHeader) {
     let target = header.target();
-    while header.validate_pow(&target).is_err() {
+    while header.validate_pow(target).is_err() {
         header.nonce = header.nonce.wrapping_add(1);
     }
 }
@@ -59,16 +59,19 @@ impl UtxoSet {
 pub mod gen {
     use std::collections::HashMap;
 
-    use bitcoin::blockdata::script::Script;
+    use bitcoin::bip158;
     use bitcoin::blockdata::transaction::{OutPoint, TxIn, TxOut};
     use bitcoin::consensus::Decodable;
-    use bitcoin::hash_types::{PubkeyHash, TxMerkleNode, Txid};
-    use bitcoin::util::bip158;
-    use bitcoin::util::uint::Uint256;
+    use bitcoin::hash_types::{TxMerkleNode, Txid};
 
-    use nakamoto_common::bitcoin::{self, PackedLockTime, Sequence, Witness};
+    use nakamoto_common::bitcoin::absolute::LockTime;
+    use nakamoto_common::bitcoin::block::Version;
+    use nakamoto_common::bitcoin::{
+        self, merkle_tree, Amount, PubkeyHash, ScriptBuf, Sequence, Witness,
+    };
     use nakamoto_common::bitcoin_hashes::{hash160, Hash as _};
     use nakamoto_common::block::filter::{BlockFilter, FilterHash, FilterHeader};
+    use nakamoto_common::block::BlockHeader;
     use nakamoto_common::block::*;
     use nakamoto_common::nonempty::NonEmpty;
 
@@ -91,7 +94,7 @@ pub mod gen {
                     txid,
                     vout: rng.u32(0..16),
                 },
-                script_sig: Script::new(),
+                script_sig: ScriptBuf::new(),
                 sequence: Sequence::MAX,
                 witness: Witness::new(),
             };
@@ -105,8 +108,8 @@ pub mod gen {
         }
 
         Transaction {
-            version: 1,
-            lock_time: PackedLockTime::ZERO,
+            version: bitcoin::transaction::Version(1),
+            lock_time: LockTime::ZERO,
             input,
             output,
         }
@@ -123,7 +126,7 @@ pub mod gen {
         let mut output = Vec::with_capacity(rng.usize(1..8));
         let input = TxIn {
             previous_output,
-            script_sig: Script::new(),
+            script_sig: ScriptBuf::new(),
             sequence: Sequence::MAX,
             witness: Witness::new(),
         };
@@ -136,7 +139,7 @@ pub mod gen {
             let v = rng.u64(1..=allowance);
 
             output.push(TxOut {
-                value: v,
+                value: Amount(v),
                 script_pubkey,
             });
 
@@ -148,21 +151,21 @@ pub mod gen {
         assert!(output.iter().map(|o| o.value).sum::<u64>() <= value);
 
         Transaction {
-            version: 1,
-            lock_time: PackedLockTime::ZERO,
+            version: bitcoin::transaction::Version(1),
+            lock_time: LockTime::ZERO,
             input: vec![input],
             output,
         }
     }
 
-    pub fn script(rng: &mut fastrand::Rng) -> Script {
+    pub fn script(rng: &mut fastrand::Rng) -> ScriptBuf {
         let bytes = std::iter::repeat_with(|| rng.u8(..))
             .take(20)
             .collect::<Vec<_>>();
         let hash = hash160::Hash::from_slice(bytes.as_slice()).unwrap();
-        let pkh = PubkeyHash::from_hash(hash);
+        let pkh = PubkeyHash::from_raw_hash(hash);
 
-        Script::new_p2pkh(&pkh)
+        ScriptBuf::new_p2pkh(&pkh)
     }
 
     /// Generate a random transaction output.
@@ -181,13 +184,13 @@ pub mod gen {
 
         let input = TxIn {
             previous_output: OutPoint::null(),
-            script_sig: Script::new(),
+            script_sig: ScriptBuf::new(),
             sequence: Sequence::MAX,
             witness: Witness::new(),
         };
         Transaction {
-            version: 1,
-            lock_time: PackedLockTime::ZERO,
+            version: bitcoin::transaction::Version(1),
+            lock_time: LockTime::ZERO,
             input: vec![input],
             output,
         }
@@ -210,9 +213,9 @@ pub mod gen {
         rng: &mut fastrand::Rng,
     ) -> Block {
         let merkle_root =
-            bitcoin::util::hash::bitcoin_merkle_root(txdata.iter().map(|tx| tx.txid().as_hash()));
+            merkle_tree::calculate_root(txdata.iter().map(|tx| tx.txid().as_raw_hash().to_owned()));
         let merkle_root = match merkle_root {
-            Some(hash) => TxMerkleNode::from_hash(hash),
+            Some(hash) => TxMerkleNode::from_raw_hash(hash),
             None => TxMerkleNode::all_zeros(),
         };
         let header = header(prev_header, merkle_root, rng);
@@ -230,13 +233,13 @@ pub mod gen {
         let delta = rng.u32(target_spacing - 60..target_spacing + 60);
 
         let time = prev_header.time + delta;
-        let bits = BlockHeader::compact_target_from_u256(&prev_header.target());
+        let bits = &prev_header.target().to_compact_lossy();
 
         let mut header = BlockHeader {
-            version: 1,
+            version: Version::ONE,
             time,
             nonce: rng.u32(..),
-            bits,
+            bits: *bits,
             merkle_root,
             prev_blockhash: prev_header.block_hash(),
         };
@@ -249,22 +252,17 @@ pub mod gen {
     pub fn genesis(rng: &mut fastrand::Rng) -> Block {
         let txdata = vec![coinbase(rng)];
         let merkle_root =
-            bitcoin::util::hash::bitcoin_merkle_root(txdata.iter().map(|tx| tx.txid().as_hash()));
+            merkle_tree::calculate_root(txdata.iter().map(|tx| tx.txid().as_raw_hash().to_owned()));
         let merkle_root = match merkle_root {
-            Some(hash) => TxMerkleNode::from_hash(hash),
+            Some(hash) => TxMerkleNode::from_raw_hash(hash),
             None => TxMerkleNode::all_zeros(),
         };
 
-        let target = Uint256([
-            0xffffffffffffffffu64,
-            0xffffffffffffffffu64,
-            0xffffffffffffffffu64,
-            0x7fffffffffffffffu64,
-        ]);
-        let bits = BlockHeader::compact_target_from_u256(&target);
+        let target = Target::ZERO;
+        let bits = target.to_compact_lossy();
 
         let mut header = BlockHeader {
-            version: 1,
+            version: Version::ONE,
             time: 0,
             nonce: 0,
             bits,
@@ -424,7 +422,7 @@ pub mod gen {
         birth: Height,
         chain: impl Iterator<Item = &'a Block>,
         rng: &mut fastrand::Rng,
-    ) -> (Vec<Script>, Vec<Height>, u64) {
+    ) -> (Vec<ScriptBuf>, Vec<Height>, u64) {
         let mut watchlist = Vec::new();
         let mut blocks = Vec::new();
         let mut balance = 0;
@@ -448,7 +446,7 @@ pub mod gen {
     pub fn watchlist<'a>(
         birth: Height,
         chain: impl Iterator<Item = &'a Block>,
-    ) -> (Vec<Script>, u64) {
+    ) -> (Vec<ScriptBuf>, u64) {
         let mut watchlist = Vec::new();
         let mut balance = 0;
 
diff --git a/test/src/block/cache/model.rs b/test/src/block/cache/model.rs
index c6e3841e..70afa4e0 100644
--- a/test/src/block/cache/model.rs
+++ b/test/src/block/cache/model.rs
@@ -7,14 +7,13 @@ use nakamoto_common::bitcoin_hashes::Hash;
 use nakamoto_common::block::filter::{self, BlockFilter, FilterHash, FilterHeader, Filters};
 use nakamoto_common::block::iter::Iter;
 use nakamoto_common::block::tree::{BlockReader, BlockTree, Branch, Error, ImportResult};
-use nakamoto_common::block::Height;
+use nakamoto_common::block::{Height, Work};
 use nakamoto_common::nonempty::NonEmpty;
 
 use std::collections::{BTreeMap, HashMap, VecDeque};
 
-use nakamoto_common::bitcoin::blockdata::block::BlockHeader;
+use nakamoto_common::bitcoin::blockdata::block::Header as BlockHeader;
 use nakamoto_common::bitcoin::hash_types::BlockHash;
-use nakamoto_common::bitcoin::util::uint::Uint256;
 
 #[derive(Debug, Clone)]
 pub struct Cache {
@@ -183,8 +182,8 @@ impl BlockReader for Cache {
         None
     }
 
-    fn chain_work(&self) -> Uint256 {
-        let mut work = Uint256::default();
+    fn chain_work(&self) -> Work {
+        let mut work = Work::REGTEST_MIN;
 
         for block in self.chain.iter() {
             work = work + block.work();
diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs
index 390f9dea..74c24ff3 100644
--- a/wallet/src/lib.rs
+++ b/wallet/src/lib.rs
@@ -15,7 +15,7 @@ use nakamoto_client::chan;
 use nakamoto_client::handle::Handle;
 use nakamoto_client::Network;
 use nakamoto_client::{Client, Config};
-use nakamoto_common::bitcoin::util::bip32::DerivationPath;
+use nakamoto_common::bitcoin::bip32::DerivationPath;
 use nakamoto_common::block::Height;
 
 use crate::error::Error;
diff --git a/wallet/src/main.rs b/wallet/src/main.rs
index 23f4d198..96fe46de 100644
--- a/wallet/src/main.rs
+++ b/wallet/src/main.rs
@@ -3,7 +3,8 @@ use std::path::PathBuf;
 
 use argh::FromArgs;
 
-use nakamoto_common::bitcoin::util::bip32::DerivationPath;
+use nakamoto_common::bitcoin::address::NetworkUnchecked;
+use nakamoto_common::bitcoin::bip32::DerivationPath;
 use nakamoto_common::bitcoin::Address;
 use nakamoto_common::block::Height;
 use nakamoto_common::network::Network;
@@ -14,7 +15,7 @@ use nakamoto_wallet::logger;
 pub struct Options {
     /// watch the following addresses
     #[argh(option)]
-    pub addresses: Vec<Address>,
+    pub addresses: Vec<Address<NetworkUnchecked>>,
     /// wallet birth height, from which to start scanning
     #[argh(option)]
     pub birth_height: Height,
diff --git a/wallet/src/wallet.rs b/wallet/src/wallet.rs
index 13f482d7..f368ab6b 100644
--- a/wallet/src/wallet.rs
+++ b/wallet/src/wallet.rs
@@ -12,7 +12,7 @@ use termion::event::Event;
 
 use nakamoto_client as client;
 use nakamoto_client::handle::Handle;
-use nakamoto_common::bitcoin::Address;
+use nakamoto_common::bitcoin::{Address, ScriptBuf};
 use nakamoto_common::bitcoin::{OutPoint, Script, Transaction, TxOut};
 use nakamoto_common::block::Height;
 
@@ -55,7 +55,7 @@ impl<H: Handle> Wallet<H> {
     }
 
     /// Apply a transaction to the wallet's UTXO set.
-    pub fn apply(&mut self, tx: &Transaction, scripts: &[Script]) {
+    pub fn apply(&mut self, tx: &Transaction, scripts: &[ScriptBuf]) {
         // Look for outputs.
         for (vout, output) in tx.output.iter().enumerate() {
             // Received coin. Mark the address as *used*, and update the balance for that
@@ -224,7 +224,7 @@ impl<H: Handle> Wallet<H> {
     fn handle_client_event<W: io::Write>(
         &mut self,
         event: client::Event,
-        watch: &[Script],
+        watch: &[ScriptBuf],
         offline: bool,
         term: &mut W,
     ) -> Result<ControlFlow<()>, Error> {
diff --git a/wallet/src/wallet/db.rs b/wallet/src/wallet/db.rs
index e61ea012..dd3768ec 100644
--- a/wallet/src/wallet/db.rs
+++ b/wallet/src/wallet/db.rs
@@ -8,6 +8,7 @@ use nakamoto_common::bitcoin::OutPoint;
 use nakamoto_common::bitcoin::TxOut;
 use nakamoto_common::bitcoin::Txid;
 
+use nakamoto_common::bitcoin::address::NetworkUnchecked;
 use sqlite as sql;
 
 pub use types::*;
@@ -88,6 +89,7 @@ impl Read for Db {
             let address = row.get::<String, _>("address");
             let script_pubkey = Address::from_str(&address)
                 .map_err(|_| Error::Decoding("address"))?
+                .payload
                 .script_pubkey();
             let value = row.get::<i64, _>("value") as u64;
 
@@ -114,7 +116,7 @@ impl Read for Db {
                 row.try_into()?;
             let txid = txid.parse().map_err(|_| Error::Decoding("txid"))?;
             let address = address
-                .parse::<Address>()
+                .parse::<Address<NetworkUnchecked>>()
                 .map_err(|_| Error::Decoding("address"))?;
 
             utxos.push((
@@ -123,7 +125,7 @@ impl Read for Db {
                     vout: vout as u32,
                 },
                 TxOut {
-                    script_pubkey: address.script_pubkey(),
+                    script_pubkey: address.payload.script_pubkey(),
                     value: *value,
                 },
             ));
diff --git a/wallet/src/wallet/db/types.rs b/wallet/src/wallet/db/types.rs
index 67bf326b..a82eeb75 100644
--- a/wallet/src/wallet/db/types.rs
+++ b/wallet/src/wallet/db/types.rs
@@ -1,6 +1,8 @@
-use nakamoto_common::bitcoin::Address;
 use sqlite as sql;
 
+use nakamoto_common::bitcoin::address::NetworkUnchecked;
+use nakamoto_common::bitcoin::Address;
+
 use super::Error;
 
 /// Wraps a type, enabling it to be converted to SQL types.
@@ -70,12 +72,13 @@ impl<'a> TryFrom<&'a sql::Row> for AddressRecord {
     type Error = Error;
 
     fn try_from(row: &'a sql::Row) -> Result<Self, Self::Error> {
+        let addr: Address<NetworkUnchecked> = row
+            .get::<String, _>(0)
+            .as_str()
+            .parse()
+            .map_err(|_| Error::Decoding("address"))?;
         Ok(Self {
-            address: row
-                .get::<String, _>(0)
-                .as_str()
-                .parse()
-                .map_err(|_| Error::Decoding("address"))?,
+            address: addr.assume_checked(),
             index: row.get::<i64, _>(1) as usize,
             label: row.get(2),
             received: row.get::<i64, _>(3) as u64,
diff --git a/wallet/src/wallet/hw.rs b/wallet/src/wallet/hw.rs
index adbc5c14..6220be30 100644
--- a/wallet/src/wallet/hw.rs
+++ b/wallet/src/wallet/hw.rs
@@ -1,7 +1,8 @@
-use std::{ops::Range, str::FromStr};
+use std::ops::Range;
 
-use bitcoin::{util::bip32::DerivationPath, Address};
+use bitcoin::{bip32::DerivationPath, Address};
 use nakamoto_common::bitcoin;
+use nakamoto_common::bitcoin::address::NetworkUnchecked;
 
 pub use coldcard::protocol::AddressFormat;
 
@@ -14,7 +15,7 @@ pub enum Error {
     #[error("failed to open hardware device")]
     Open,
     #[error("failed to decode address from device")]
-    Address(#[from] bitcoin::util::address::Error),
+    Address(#[from] bitcoin::address::Error),
     #[error("derivation path error")]
     DerivationPath(coldcard::protocol::derivation_path::Error),
     #[error("device error: {0}")]
@@ -73,7 +74,8 @@ impl Hw {
                 .map_err(Error::DerivationPath)?;
             // TODO: This should be made to return `Address` type.
             let addr = device.address(child, format)?;
-            let addr = Address::from_str(addr.as_str())?;
+            let addr: Address<NetworkUnchecked> = addr.as_str().parse()?;
+            let addr = addr.assume_checked();
 
             log::debug!("Loaded address {addr} from device");