From c03497434b0551b050839b24838f91d1fcb71775 Mon Sep 17 00:00:00 2001
From: Yapcheekian <yapcheekian96@gmail.com>
Date: Mon, 7 Apr 2025 13:42:09 +0800
Subject: [PATCH] feat: upgrade `rust-bitcoin` crate

---
 Cargo.lock                      | 119 +++++++++++++++++-
 Cargo.toml                      |   2 +-
 src/bin/electrs.rs              |   3 +-
 src/bin/tx-fingerprint-stats.rs |  37 ++++--
 src/chain.rs                    |  19 ++-
 src/daemon.rs                   |  68 ++++++-----
 src/new_index/fetch.rs          |  13 +-
 src/new_index/mempool.rs        |  11 +-
 src/new_index/query.rs          |   2 +-
 src/new_index/schema.rs         |  22 ++--
 src/rest.rs                     | 207 +++++++++++++++-----------------
 src/util/block.rs               |  16 ++-
 src/util/fees.rs                |  11 +-
 src/util/mod.rs                 |  10 +-
 src/util/script.rs              |  38 +++---
 src/util/transaction.rs         |  37 +++---
 16 files changed, 369 insertions(+), 246 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 77a44d0d..d84875d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "addr2line"
@@ -32,6 +32,12 @@ version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
 
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "ascii"
 version = "1.0.0"
@@ -79,6 +85,16 @@ dependencies = [
  "rustc-demangle",
 ]
 
+[[package]]
+name = "base58ck"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c8d66485a3a2ea485c1913c4572ce0256067a5377ac8c75c4960e1cda98605f"
+dependencies = [
+ "bitcoin-internals",
+ "bitcoin_hashes 0.14.0",
+]
+
 [[package]]
 name = "base64"
 version = "0.10.1"
@@ -100,6 +116,12 @@ version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf9ff0bbfd639f15c74af777d81383cf53efb7c93613f6cab67c6c11e05bbf8b"
 
+[[package]]
+name = "bech32"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d965446196e3b7decd44aa7ee49e31d630118f90ef12f97900f262eb915c951d"
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -136,7 +158,7 @@ version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a41df6ad9642c5c15ae312dd3d074de38fd3eb7cc87ad4ce10f90292a83fe4d"
 dependencies = [
- "bech32",
+ "bech32 0.8.1",
  "bitcoin_hashes 0.10.0",
  "secp256k1 0.20.3",
  "serde",
@@ -148,12 +170,55 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42b2a9a8e3c7544f5ce2b475f2f56580a3102b37e0ee001558ad4faedcf56cf4"
 dependencies = [
- "bech32",
+ "bech32 0.8.1",
  "bitcoin_hashes 0.10.0",
  "secp256k1 0.22.1",
  "serde",
 ]
 
+[[package]]
+name = "bitcoin"
+version = "0.32.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6bc65742dea50536e35ad42492b234c27904a27f0abdcbce605015cb4ea026"
+dependencies = [
+ "base58ck",
+ "bech32 0.11.0",
+ "bitcoin-internals",
+ "bitcoin-io",
+ "bitcoin-units",
+ "bitcoin_hashes 0.14.0",
+ "hex-conservative",
+ "hex_lit",
+ "secp256k1 0.29.1",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30bdbe14aa07b06e6cfeffc529a1f099e5fbe249524f8125358604df99a4bed2"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-io"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+
+[[package]]
+name = "bitcoin-units"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5285c8bcaa25876d07f37e3d30c303f2609179716e11d688f51e8f1fe70063e2"
+dependencies = [
+ "bitcoin-internals",
+ "serde",
+]
+
 [[package]]
 name = "bitcoin_hashes"
 version = "0.7.6"
@@ -169,6 +234,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative",
+ "serde",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -582,6 +658,21 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hex-conservative"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5313b072ce3c597065a808dbf612c4c8e8590bdbf8b579508bf7a762c5eae6cd"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hex_lit"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
+
 [[package]]
 name = "http"
 version = "0.2.6"
@@ -827,7 +918,7 @@ dependencies = [
  "arrayref",
  "base64 0.13.0",
  "bincode",
- "bitcoin 0.28.0",
+ "bitcoin 0.32.5",
  "bounded-vec-deque",
  "clap",
  "crossbeam-channel",
@@ -1384,6 +1475,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "secp256k1"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
+dependencies = [
+ "bitcoin_hashes 0.14.0",
+ "secp256k1-sys 0.10.1",
+ "serde",
+]
+
 [[package]]
 name = "secp256k1-sys"
 version = "0.4.2"
@@ -1402,6 +1504,15 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "secp256k1-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "secp256k1-zkp"
 version = "0.6.0"
diff --git a/Cargo.toml b/Cargo.toml
index c5ec87b2..83e1978f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ electrum-discovery = ["electrum-client"]
 arrayref = "0.3.6"
 base64 = "0.13.0"
 bincode-do-not-use-directly = { version = "1.3.1", package = "bincode" }
-bitcoin = { version = "0.28", features = [ "use-serde" ] }
+bitcoin = { version = "0.32", features = [ "serde" ] }
 bounded-vec-deque = "0.1.1"
 clap = "2.33.3"
 crossbeam-channel = "0.5.0"
diff --git a/src/bin/electrs.rs b/src/bin/electrs.rs
index 0c649355..094fcc25 100644
--- a/src/bin/electrs.rs
+++ b/src/bin/electrs.rs
@@ -4,6 +4,7 @@ extern crate log;
 
 extern crate electrs;
 
+use bitcoin::p2p::Magic;
 use error_chain::ChainedError;
 use std::process;
 use std::sync::{Arc, RwLock};
@@ -50,7 +51,7 @@ fn run_server(config: Arc<Config>) -> Result<()> {
         config.daemon_rpc_addr,
         config.cookie_getter(),
         config.network_type,
-        config.magic,
+        config.magic.map(|m| Magic::from_bytes(m.to_be_bytes())),
         signal.clone(),
         &metrics,
     )?);
diff --git a/src/bin/tx-fingerprint-stats.rs b/src/bin/tx-fingerprint-stats.rs
index 5b38561f..ab8c0f46 100644
--- a/src/bin/tx-fingerprint-stats.rs
+++ b/src/bin/tx-fingerprint-stats.rs
@@ -9,8 +9,9 @@ fn main() {
     use std::collections::HashSet;
     use std::sync::Arc;
 
-    use bitcoin::blockdata::script::Script;
     use bitcoin::consensus::encode::deserialize;
+    use bitcoin::p2p::Magic;
+    use bitcoin::ScriptBuf;
     use electrs::{
         chain::Transaction,
         config::Config,
@@ -35,7 +36,7 @@ fn main() {
             config.daemon_rpc_addr,
             config.cookie_getter(),
             config.network_type,
-            config.magic,
+            config.magic.map(|m| Magic::from_bytes(m.to_be_bytes())),
             signal,
             &metrics,
         )
@@ -62,7 +63,7 @@ fn main() {
         }
 
         let tx: Transaction = deserialize(value).expect("failed to parse Transaction");
-        let txid = tx.txid();
+        let txid = tx.compute_txid();
 
         iter.next();
 
@@ -71,7 +72,7 @@ fn main() {
             continue;
         }
         // skip coinbase txs
-        if tx.is_coin_base() {
+        if tx.is_coinbase() {
             continue;
         }
 
@@ -91,12 +92,26 @@ fn main() {
                 .collect(),
         );
 
-        let total_out: u64 = tx.output.iter().map(|out| out.value).sum();
-        let small_out = tx.output.iter().map(|out| out.value).min().unwrap();
-        let large_out = tx.output.iter().map(|out| out.value).max().unwrap();
-
-        let total_in: u64 = prevouts.values().map(|out| out.value).sum();
-        let smallest_in = prevouts.values().map(|out| out.value).min().unwrap();
+        let total_out: u64 = tx.output.iter().map(|out| out.value.to_sat()).sum();
+        let small_out = tx
+            .output
+            .iter()
+            .map(|out| out.value.to_sat())
+            .min()
+            .unwrap();
+        let large_out = tx
+            .output
+            .iter()
+            .map(|out| out.value.to_sat())
+            .max()
+            .unwrap();
+
+        let total_in: u64 = prevouts.values().map(|out| out.value.to_sat()).sum();
+        let smallest_in = prevouts
+            .values()
+            .map(|out| out.value.to_sat())
+            .min()
+            .unwrap();
 
         let fee = total_in - total_out;
 
@@ -119,7 +134,7 @@ fn main() {
 
         // test for sending back to one of the spent spks
         let has_reuse = {
-            let prev_spks: HashSet<Script> = prevouts
+            let prev_spks: HashSet<ScriptBuf> = prevouts
                 .values()
                 .map(|out| out.script_pubkey.clone())
                 .collect();
diff --git a/src/chain.rs b/src/chain.rs
index 6a23c465..6b3ebe23 100644
--- a/src/chain.rs
+++ b/src/chain.rs
@@ -2,11 +2,11 @@ use std::str::FromStr;
 
 #[cfg(not(feature = "liquid"))] // use regular Bitcoin data structures
 pub use bitcoin::{
+    address,
+    block::Header as BlockHeader,
     blockdata::{opcodes, script, witness::Witness},
     consensus::deserialize,
-    hashes,
-    util::address,
-    Block, BlockHash, BlockHeader, OutPoint, Script, Transaction, TxIn, TxOut, Txid,
+    hashes, Block, BlockHash, Opcode, OutPoint, Script, Transaction, TxIn, TxOut, Txid,
 };
 
 #[cfg(feature = "liquid")]
@@ -20,7 +20,8 @@ pub use {
 };
 
 use bitcoin::blockdata::constants::genesis_block;
-pub use bitcoin::network::constants::Network as BNetwork;
+use bitcoin::p2p::Magic;
+pub use bitcoin::Network as BNetwork;
 
 #[cfg(not(feature = "liquid"))]
 pub type Value = u64;
@@ -59,15 +60,11 @@ pub const LIQUID_TESTNET_PARAMS: address::AddressParams = address::AddressParams
 
 /// Magic for testnet4, 0x1c163f28 (from BIP94) with flipped endianness.
 #[cfg(not(feature = "liquid"))]
-const TESTNET4_MAGIC: u32 = 0x283f161c;
 
 impl Network {
     #[cfg(not(feature = "liquid"))]
-    pub fn magic(self) -> u32 {
-        match self {
-            Self::Testnet4 => TESTNET4_MAGIC,
-            _ => BNetwork::from(self).magic(),
-        }
+    pub fn magic(self) -> Magic {
+        BNetwork::from(self).magic()
     }
 
     #[cfg(feature = "liquid")]
@@ -234,8 +231,10 @@ impl From<BNetwork> for Network {
         match network {
             BNetwork::Bitcoin => Network::Bitcoin,
             BNetwork::Testnet => Network::Testnet,
+            BNetwork::Testnet4 => Network::Testnet4,
             BNetwork::Regtest => Network::Regtest,
             BNetwork::Signet => Network::Signet,
+            _ => panic!("unknown network"),
         }
     }
 }
diff --git a/src/daemon.rs b/src/daemon.rs
index 4c398f32..0a95bd8c 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -6,7 +6,8 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use base64;
-use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::hashes::Hash;
+use bitcoin::p2p::Magic;
 use glob;
 use hex;
 use itertools::Itertools;
@@ -24,18 +25,6 @@ use crate::util::HeaderList;
 
 use crate::errors::*;
 
-fn parse_hash<T>(value: &Value) -> Result<T>
-where
-    T: FromHex,
-{
-    T::from_hex(
-        value
-            .as_str()
-            .chain_err(|| format!("non-string value: {}", value))?,
-    )
-    .chain_err(|| format!("non-hex value: {}", value))
-}
-
 fn header_from_value(value: Value) -> Result<BlockHeader> {
     let header_hex = value
         .as_str()
@@ -312,7 +301,7 @@ pub struct Daemon {
     daemon_dir: PathBuf,
     blocks_dir: PathBuf,
     network: Network,
-    magic: Option<u32>,
+    magic: Option<Magic>,
     conn: Mutex<Connection>,
     message_id: Counter, // for monotonic JSONRPC 'id'
     signal: Waiter,
@@ -330,7 +319,7 @@ impl Daemon {
         daemon_rpc_addr: SocketAddr,
         cookie_getter: Arc<dyn CookieGetter>,
         network: Network,
-        magic: Option<u32>,
+        magic: Option<Magic>,
         signal: Waiter,
         metrics: &Metrics,
     ) -> Result<Daemon> {
@@ -419,7 +408,7 @@ impl Daemon {
         Ok(paths)
     }
 
-    pub fn magic(&self) -> u32 {
+    pub fn magic(&self) -> Magic {
         self.magic.unwrap_or_else(|| self.network.magic())
     }
 
@@ -537,13 +526,21 @@ impl Daemon {
     }
 
     pub fn getbestblockhash(&self) -> Result<BlockHash> {
-        parse_hash(&self.request("getbestblockhash", json!([]))?)
+        let maybe_value = &self.request("getbestblockhash", json!([]))?;
+
+        let value = maybe_value
+            .as_str()
+            .chain_err(|| format!("non-string value: {}", maybe_value))?;
+
+        Ok(BlockHash::from_raw_hash(
+            value.parse().chain_err(|| "invalid hash")?,
+        ))
     }
 
     pub fn getblockheader(&self, blockhash: &BlockHash) -> Result<BlockHeader> {
         header_from_value(self.request(
             "getblockheader",
-            json!([blockhash.to_hex(), /*verbose=*/ false]),
+            json!([blockhash.to_raw_hash().to_string(), /*verbose=*/ false]),
         )?)
     }
 
@@ -562,21 +559,25 @@ impl Daemon {
     }
 
     pub fn getblock(&self, blockhash: &BlockHash) -> Result<Block> {
-        let block = block_from_value(
-            self.request("getblock", json!([blockhash.to_hex(), /*verbose=*/ false]))?,
-        )?;
+        let block = block_from_value(self.request(
+            "getblock",
+            json!([blockhash.to_raw_hash().to_string(), /*verbose=*/ false]),
+        )?)?;
         assert_eq!(block.block_hash(), *blockhash);
         Ok(block)
     }
 
     pub fn getblock_raw(&self, blockhash: &BlockHash, verbose: u32) -> Result<Value> {
-        self.request("getblock", json!([blockhash.to_hex(), verbose]))
+        self.request(
+            "getblock",
+            json!([blockhash.to_raw_hash().to_string(), verbose]),
+        )
     }
 
     pub fn getblocks(&self, blockhashes: &[BlockHash]) -> Result<Vec<Block>> {
         let params_list: Vec<Value> = blockhashes
             .iter()
-            .map(|hash| json!([hash.to_hex(), /*verbose=*/ false]))
+            .map(|hash| json!([hash.to_raw_hash().to_string(), /*verbose=*/ false]))
             .collect();
         let values = self.requests("getblock", &params_list)?;
         let mut blocks = vec![];
@@ -589,7 +590,7 @@ impl Daemon {
     pub fn gettransactions(&self, txhashes: &[&Txid]) -> Result<Vec<Transaction>> {
         let params_list: Vec<Value> = txhashes
             .iter()
-            .map(|txhash| json!([txhash.to_hex(), /*verbose=*/ false]))
+            .map(|txhash| json!([txhash.to_raw_hash().to_string(), /*verbose=*/ false]))
             .collect();
         let values = self.retry_request_batch("getrawtransaction", &params_list, 0.25)?;
         let mut txs = vec![];
@@ -608,14 +609,14 @@ impl Daemon {
     ) -> Result<Value> {
         self.request(
             "getrawtransaction",
-            json!([txid.to_hex(), verbose, blockhash]),
+            json!([txid.to_raw_hash().to_string(), verbose, blockhash]),
         )
     }
 
     pub fn getmempooltx(&self, txhash: &Txid) -> Result<Transaction> {
         let value = self.request(
             "getrawtransaction",
-            json!([txhash.to_hex(), /*verbose=*/ false]),
+            json!([txhash.to_raw_hash().to_string(), /*verbose=*/ false]),
         )?;
         tx_from_value(value)
     }
@@ -631,8 +632,12 @@ impl Daemon {
 
     pub fn broadcast_raw(&self, txhex: &str) -> Result<Txid> {
         let txid = self.request("sendrawtransaction", json!([txhex]))?;
-        Txid::from_hex(txid.as_str().chain_err(|| "non-string txid")?)
-            .chain_err(|| "failed to parse txid")
+
+        let txid = txid.as_str().chain_err(|| "non-string txid")?;
+
+        Ok(Txid::from_raw_hash(
+            txid.parse().chain_err(|| "failed to parse txid")?,
+        ))
     }
 
     pub fn test_mempool_accept(
@@ -703,7 +708,7 @@ impl Daemon {
     }
 
     fn get_all_headers(&self, tip: &BlockHash) -> Result<Vec<BlockHeader>> {
-        let info: Value = self.request("getblockheader", json!([tip.to_hex()]))?;
+        let info: Value = self.request("getblockheader", json!([tip.to_raw_hash().to_string()]))?;
         let tip_height = info
             .get("height")
             .expect("missing height")
@@ -719,11 +724,12 @@ impl Daemon {
             result.append(&mut headers);
         }
 
-        let mut blockhash = BlockHash::default();
+        let mut blockhash = BlockHash::all_zeros();
         for header in &result {
             assert_eq!(header.prev_blockhash, blockhash);
             blockhash = header.block_hash();
         }
+
         assert_eq!(blockhash, *tip);
         Ok(result)
     }
@@ -745,7 +751,7 @@ impl Daemon {
             bestblockhash,
         );
         let mut new_headers = vec![];
-        let null_hash = BlockHash::default();
+        let null_hash = BlockHash::all_zeros();
         let mut blockhash = *bestblockhash;
         while blockhash != null_hash {
             if indexed_headers.header_by_blockhash(&blockhash).is_some() {
diff --git a/src/new_index/fetch.rs b/src/new_index/fetch.rs
index 04d873bf..e86644d5 100644
--- a/src/new_index/fetch.rs
+++ b/src/new_index/fetch.rs
@@ -1,3 +1,4 @@
+use bitcoin::p2p::Magic;
 use rayon::prelude::*;
 
 #[cfg(not(feature = "liquid"))]
@@ -82,7 +83,7 @@ pub fn bitcoind_sequential_fetcher(
                     .zip(entries)
                     .map(|(block, entry)| BlockEntry {
                         entry: entry.clone(), // TODO: remove this clone()
-                        size: block.size() as u32,
+                        size: block.total_size() as u32,
                         block,
                     })
                     .collect();
@@ -138,7 +139,7 @@ fn bitcoind_fetcher(
                     .zip(entries)
                     .map(|(block, entry)| BlockEntry {
                         entry: entry.clone(), // TODO: remove this clone()
-                        size: block.size() as u32,
+                        size: block.total_size() as u32,
                         block,
                     })
                     .collect();
@@ -235,7 +236,7 @@ fn blkfiles_reader(blk_files: Vec<PathBuf>) -> Fetcher<Vec<u8>> {
     )
 }
 
-fn blkfiles_parser(blobs: Fetcher<Vec<u8>>, magic: u32) -> Fetcher<Vec<SizedBlock>> {
+fn blkfiles_parser(blobs: Fetcher<Vec<u8>>, magic: Magic) -> Fetcher<Vec<SizedBlock>> {
     let chan = SyncChannel::new(1);
     let sender = chan.sender();
 
@@ -253,7 +254,7 @@ fn blkfiles_parser(blobs: Fetcher<Vec<u8>>, magic: u32) -> Fetcher<Vec<SizedBloc
     )
 }
 
-fn parse_blocks(blob: Vec<u8>, magic: u32) -> Result<Vec<SizedBlock>> {
+fn parse_blocks(blob: Vec<u8>, magic: Magic) -> Result<Vec<SizedBlock>> {
     let mut cursor = Cursor::new(&blob);
     let mut slices = vec![];
     let max_pos = blob.len() as u64;
@@ -262,7 +263,7 @@ fn parse_blocks(blob: Vec<u8>, magic: u32) -> Result<Vec<SizedBlock>> {
         let offset = cursor.position();
         match u32::consensus_decode(&mut cursor) {
             Ok(value) => {
-                if magic != value {
+                if u32::from_be_bytes(magic.to_bytes()) != value {
                     cursor.set_position(offset + 1);
                     continue;
                 }
@@ -279,7 +280,7 @@ fn parse_blocks(blob: Vec<u8>, magic: u32) -> Result<Vec<SizedBlock>> {
         // by peeking the cursor (and skipping previous `magic` and `block_size`).
         match u32::consensus_decode(&mut cursor) {
             Ok(value) => {
-                if magic == value {
+                if u32::from_be_bytes(magic.to_bytes()) != value {
                     cursor.set_position(start);
                     continue;
                 }
diff --git a/src/new_index/mempool.rs b/src/new_index/mempool.rs
index 7d5d3406..c7edbe6f 100644
--- a/src/new_index/mempool.rs
+++ b/src/new_index/mempool.rs
@@ -481,7 +481,7 @@ impl Mempool {
         let mut txids = Vec::with_capacity(txs.len());
         // Phase 1: add to txstore
         for tx in txs {
-            let txid = tx.txid();
+            let txid = tx.compute_txid();
             // Only push if it doesn't already exist.
             // This is important now that update doesn't lock during
             // the entire function body.
@@ -526,7 +526,10 @@ impl Mempool {
                 fee: feeinfo.fee,
                 vsize: feeinfo.vsize,
                 #[cfg(not(feature = "liquid"))]
-                value: prevouts.values().map(|prevout| prevout.value).sum(),
+                value: prevouts
+                    .values()
+                    .map(|prevout| prevout.value.to_sat())
+                    .sum(),
             });
 
             self.feeinfo.insert(txid, feeinfo);
@@ -541,7 +544,7 @@ impl Mempool {
                         vin: input_index,
                         prev_txid: full_hash(&txi.previous_output.txid[..]),
                         prev_vout: txi.previous_output.vout,
-                        value: prevout.value,
+                        value: prevout.value.to_sat(),
                     }),
                 )
             });
@@ -560,7 +563,7 @@ impl Mempool {
                         TxHistoryInfo::Funding(FundingInfo {
                             txid: txid_bytes,
                             vout: index as u32,
-                            value: txo.value,
+                            value: txo.value.to_sat(),
                         }),
                     )
                 });
diff --git a/src/new_index/query.rs b/src/new_index/query.rs
index 545f8b76..9f2bd10a 100644
--- a/src/new_index/query.rs
+++ b/src/new_index/query.rs
@@ -161,7 +161,7 @@ impl Query {
     }
 
     pub fn lookup_tx_spends(&self, tx: Transaction) -> Vec<Option<SpendingInput>> {
-        let txid = tx.txid();
+        let txid = tx.compute_txid();
 
         tx.output
             .par_iter()
diff --git a/src/new_index/schema.rs b/src/new_index/schema.rs
index 6536b634..3d549b69 100644
--- a/src/new_index/schema.rs
+++ b/src/new_index/schema.rs
@@ -1,6 +1,6 @@
 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 #[cfg(not(feature = "liquid"))]
-use bitcoin::util::merkleblock::MerkleBlock;
+use bitcoin::MerkleBlock;
 use bitcoin::VarInt;
 use itertools::Itertools;
 use rayon::prelude::*;
@@ -1228,7 +1228,7 @@ impl ChainQuery {
         let _timer = self.start_timer("lookup_txn");
         self.lookup_raw_txn(txid, blockhash).map(|rawtx| {
             let txn: Transaction = deserialize(&rawtx).expect("failed to parse Transaction");
-            assert_eq!(*txid, txn.txid());
+            assert_eq!(*txid, txn.compute_txid());
             txn
         })
     }
@@ -1385,7 +1385,7 @@ fn add_blocks(block_entries: &[BlockEntry], iconfig: &IndexerConfig) -> Vec<DBRo
         .map(|b| {
             let mut rows = vec![];
             let blockhash = full_hash(&b.entry.hash()[..]);
-            let txids: Vec<Txid> = b.block.txdata.iter().map(|tx| tx.txid()).collect();
+            let txids: Vec<Txid> = b.block.txdata.iter().map(|tx| tx.compute_txid()).collect();
             for tx in &b.block.txdata {
                 add_transaction(tx, blockhash, &mut rows, iconfig);
             }
@@ -1415,7 +1415,7 @@ fn add_transaction(
         rows.push(TxRow::new(tx).into_row());
     }
 
-    let txid = full_hash(&tx.txid()[..]);
+    let txid = full_hash(&tx.compute_txid()[..]);
     for (txo_index, txo) in tx.output.iter().enumerate() {
         if is_spendable(txo) {
             rows.push(TxOutRow::new(&txid, txo_index, txo).into_row());
@@ -1547,7 +1547,7 @@ fn index_transaction(
     //      H{funding-scripthash}{funding-height}{funding-block-pos}F{funding-txid:vout} → ""
     // persist "edges" for fast is-this-TXO-spent check
     //      S{funding-txid:vout}{spending-txid:vin} → ""
-    let txid = full_hash(&tx.txid()[..]);
+    let txid = full_hash(&tx.compute_txid()[..]);
     let script_callback = |script_hash| {
         if let Operation::DeleteBlocksWithHistory(tx) = op {
             tx.send(script_hash).expect("unbounded channel won't fail");
@@ -1562,14 +1562,14 @@ fn index_transaction(
                 TxHistoryInfo::Funding(FundingInfo {
                     txid,
                     vout: txo_index as u32,
-                    value: txo.value,
+                    value: txo.value.to_sat(),
                 }),
             );
             script_callback(history.key.hash);
             rows.push(history.into_row());
 
             if iconfig.address_search {
-                if let Some(row) = addr_search_row(&txo.script_pubkey, iconfig.network) {
+                if let Ok(row) = addr_search_row(&txo.script_pubkey, iconfig.network) {
                     rows.push(row);
                 }
             }
@@ -1592,7 +1592,7 @@ fn index_transaction(
                 vin: txi_index as u32,
                 prev_txid: full_hash(&txi.previous_output.txid[..]),
                 prev_vout: txi.previous_output.vout,
-                value: prev_txo.value,
+                value: prev_txo.value.to_sat(),
             }),
         );
         script_callback(history.key.hash);
@@ -1620,7 +1620,7 @@ fn index_transaction(
     );
 }
 
-fn addr_search_row(spk: &Script, network: Network) -> Option<DBRow> {
+fn addr_search_row(spk: &Script, network: Network) -> Result<DBRow> {
     spk.to_address_str(network).map(|address| DBRow {
         key: [b"a", address.as_bytes()].concat(),
         value: vec![],
@@ -1659,7 +1659,7 @@ struct TxRow {
 
 impl TxRow {
     fn new(txn: &Transaction) -> TxRow {
-        let txid = full_hash(&txn.txid()[..]);
+        let txid = full_hash(&txn.compute_txid()[..]);
         TxRow {
             key: TxRowKey { code: b'T', txid },
             value: serialize(txn),
@@ -1692,7 +1692,7 @@ struct TxConfRow {
 
 impl TxConfRow {
     fn new(txn: &Transaction, blockhash: FullHash) -> TxConfRow {
-        let txid = full_hash(&txn.txid()[..]);
+        let txid = full_hash(&txn.compute_txid()[..]);
         TxConfRow {
             key: TxConfKey {
                 code: b'C',
diff --git a/src/rest.rs b/src/rest.rs
index 70726a9e..2616287b 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -13,8 +13,9 @@ use crate::util::{
 use {bitcoin::consensus::encode, std::str::FromStr};
 
 use bitcoin::blockdata::opcodes;
-use bitcoin::hashes::hex::{FromHex, ToHex};
-use bitcoin::hashes::Error as HashError;
+use bitcoin::hashes::Hash;
+use bitcoin::hex::HexToArrayError;
+use bitcoin::ScriptBuf;
 use hex::{self, FromHexError};
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Response, Server, StatusCode};
@@ -33,7 +34,7 @@ use {
     },
 };
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use serde_json;
 use std::collections::HashMap;
 use std::num::ParseIntError;
@@ -89,28 +90,28 @@ impl BlockValue {
     fn new(blockhm: BlockHeaderMeta) -> Self {
         let header = blockhm.header_entry.header();
         BlockValue {
-            id: header.block_hash().to_hex(),
+            id: header.block_hash().to_raw_hash().to_string(),
             height: blockhm.header_entry.height() as u32,
             version: {
                 #[allow(clippy::unnecessary_cast)]
                 {
-                    header.version as u32
+                    header.version.to_consensus() as u32
                 }
             },
             timestamp: header.time,
             tx_count: blockhm.meta.tx_count,
             size: blockhm.meta.size,
             weight: blockhm.meta.weight,
-            merkle_root: header.merkle_root.to_hex(),
-            previousblockhash: if header.prev_blockhash != BlockHash::default() {
-                Some(header.prev_blockhash.to_hex())
+            merkle_root: header.merkle_root.to_raw_hash().to_string(),
+            previousblockhash: if header.prev_blockhash != BlockHash::all_zeros() {
+                Some(header.prev_blockhash.to_raw_hash().to_string())
             } else {
                 None
             },
             mediantime: blockhm.mtp,
 
             #[cfg(not(feature = "liquid"))]
-            bits: header.bits,
+            bits: header.bits.to_consensus(),
             #[cfg(not(feature = "liquid"))]
             nonce: header.nonce,
             #[cfg(not(feature = "liquid"))]
@@ -127,9 +128,9 @@ impl BlockValue {
 ///
 /// https://github.com/bitcoin/bitcoin/blob/v25.0/src/rpc/blockchain.cpp#L75-L97
 #[cfg_attr(feature = "liquid", allow(dead_code))]
-fn difficulty_new(bh: &bitcoin::BlockHeader) -> f64 {
-    let mut n_shift = bh.bits >> 24 & 0xff;
-    let mut d_diff = (0x0000ffff as f64) / ((bh.bits & 0x00ffffff) as f64);
+fn difficulty_new(bh: &bitcoin::block::Header) -> f64 {
+    let mut n_shift = bh.bits.to_consensus() >> 24 & 0xff;
+    let mut d_diff = (0x0000ffff as f64) / ((bh.bits.to_consensus() & 0x00ffffff) as f64);
 
     while n_shift < 29 {
         d_diff *= 256.0;
@@ -187,13 +188,13 @@ impl TransactionValue {
 
         #[allow(clippy::unnecessary_cast)]
         Ok(TransactionValue {
-            txid: tx.txid(),
-            version: tx.version as u32,
-            locktime: tx.lock_time,
+            txid: tx.compute_txid(),
+            version: tx.version.0 as u32,
+            locktime: tx.lock_time.to_consensus_u32(),
             vin: vins,
             vout: vouts,
-            size: tx.size() as u32,
-            weight: tx.weight() as u32,
+            size: tx.total_size() as u32,
+            weight: tx.weight().to_wu() as u32,
             sigops,
             fee,
             status: Some(TransactionStatus::from(blockid)),
@@ -206,7 +207,7 @@ struct TxInValue {
     txid: Txid,
     vout: u32,
     prevout: Option<TxOutValue>,
-    scriptsig: Script,
+    scriptsig: ScriptBuf,
     scriptsig_asm: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     witness: Option<Vec<String>>,
@@ -258,7 +259,7 @@ impl TxInValue {
                 .map(ScriptToAsm::to_asm),
 
             is_coinbase,
-            sequence: txin.sequence,
+            sequence: txin.sequence.to_consensus_u32(),
             #[cfg(feature = "liquid")]
             is_pegin: txin.is_pegin,
             #[cfg(feature = "liquid")]
@@ -275,7 +276,7 @@ impl TxInValue {
 
 #[derive(Serialize, Deserialize, Clone)]
 struct TxOutValue {
-    scriptpubkey: Script,
+    scriptpubkey: ScriptBuf,
     scriptpubkey_asm: String,
     scriptpubkey_type: String,
 
@@ -337,7 +338,7 @@ impl TxOutValue {
 
         let script = &txout.script_pubkey;
         let script_asm = script.to_asm();
-        let script_addr = script.to_address_str(config.network_type);
+        let script_addr = script.to_address_str(config.network_type).ok();
 
         // TODO should the following something to put inside rust-elements lib?
         let script_type = if is_fee {
@@ -352,9 +353,9 @@ impl TxOutValue {
             "p2pkh"
         } else if script.is_p2sh() {
             "p2sh"
-        } else if script.is_v0_p2wpkh() {
+        } else if script.is_p2wpkh() {
             "v0_p2wpkh"
-        } else if script.is_v0_p2wsh() {
+        } else if script.is_p2wsh() {
             "v0_p2wsh"
         } else if is_v1_p2tr(script) {
             "v1_p2tr"
@@ -376,7 +377,7 @@ impl TxOutValue {
             scriptpubkey_asm: script_asm,
             scriptpubkey_address: script_addr,
             scriptpubkey_type: script_type.to_string(),
-            value,
+            value: value.to_sat(),
             #[cfg(feature = "liquid")]
             valuecommitment,
             #[cfg(feature = "liquid")]
@@ -390,8 +391,8 @@ impl TxOutValue {
 }
 fn is_v1_p2tr(script: &Script) -> bool {
     script.len() == 34
-        && script[0] == opcodes::all::OP_PUSHNUM_1.into_u8()
-        && script[1] == opcodes::all::OP_PUSHBYTES_32.into_u8()
+        && script.as_bytes()[0] == opcodes::all::OP_PUSHNUM_1.to_u8()
+        && script.as_bytes()[1] == opcodes::all::OP_PUSHBYTES_32.to_u8()
 }
 fn is_bare_multisig(script: &Script) -> bool {
     let len = script.len();
@@ -403,20 +404,20 @@ fn is_bare_multisig(script: &Script) -> bool {
     //   OP_M ... OP_N OP_CHECKMULTISIG
     // is bare multisig
     len >= 37
-        && script[len - 1] == opcodes::all::OP_CHECKMULTISIG.into_u8()
-        && script[len - 2] >= opcodes::all::OP_PUSHNUM_1.into_u8()
-        && script[len - 2] <= opcodes::all::OP_PUSHNUM_15.into_u8()
-        && script[0] >= opcodes::all::OP_PUSHNUM_1.into_u8()
-        && script[0] <= script[len - 2]
+        && script.as_bytes()[len - 1] == opcodes::all::OP_CHECKMULTISIG.to_u8()
+        && script.as_bytes()[len - 2] >= opcodes::all::OP_PUSHNUM_1.to_u8()
+        && script.as_bytes()[len - 2] <= opcodes::all::OP_PUSHNUM_15.to_u8()
+        && script.as_bytes()[0] >= opcodes::all::OP_PUSHNUM_1.to_u8()
+        && script.as_bytes()[0] <= script.as_bytes()[len - 2]
 }
 
 fn is_anchor(script: &Script) -> bool {
     let len = script.len();
     len == 4
-        && script[0] == opcodes::all::OP_PUSHNUM_1.into_u8()
-        && script[1] == opcodes::all::OP_PUSHBYTES_2.into_u8()
-        && script[2] == 0x4e
-        && script[3] == 0x73
+        && script.as_bytes()[0] == opcodes::all::OP_PUSHNUM_1.to_u8()
+        && script.as_bytes()[1] == opcodes::all::OP_PUSHBYTES_2.to_u8()
+        && script.as_bytes()[2] == 0x4e
+        && script.as_bytes()[3] == 0x73
 }
 
 #[derive(Serialize)]
@@ -734,7 +735,7 @@ fn handle_request(
     ) {
         (&Method::GET, Some(&"blocks"), Some(&"tip"), Some(&"hash"), None, None) => http_message(
             StatusCode::OK,
-            query.chain().best_hash().to_hex(),
+            query.chain().best_hash().to_raw_hash().to_string(),
             TTL_SHORT,
         ),
 
@@ -755,10 +756,10 @@ fn handle_request(
                 .header_by_height(height)
                 .ok_or_else(|| HttpError::not_found("Block not found".to_string()))?;
             let ttl = ttl_by_depth(Some(height), query);
-            http_message(StatusCode::OK, header.hash().to_hex(), ttl)
+            http_message(StatusCode::OK, header.hash().to_raw_hash().to_string(), ttl)
         }
         (&Method::GET, Some(&"block"), Some(hash), None, None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let blockhm = query
                 .chain()
                 .get_block_with_meta(&hash)
@@ -767,13 +768,13 @@ fn handle_request(
             json_response(block_value, TTL_LONG)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"status"), None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let status = query.chain().get_block_status(&hash);
             let ttl = ttl_by_depth(status.height, query);
             json_response(status, ttl)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"txids"), None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let txids = query
                 .chain()
                 .get_block_txids(&hash)
@@ -781,7 +782,7 @@ fn handle_request(
             json_response(txids, TTL_LONG)
         }
         (&Method::GET, Some(&INTERNAL_PREFIX), Some(&"block"), Some(hash), Some(&"txs"), None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let block_id = query.chain().blockid_by_hash(&hash);
             let txs = query
                 .chain()
@@ -795,7 +796,7 @@ fn handle_request(
             json_response(prepare_txs(txs, query, config), ttl)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"header"), None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let header = query
                 .chain()
                 .get_block_header(&hash)
@@ -805,7 +806,7 @@ fn handle_request(
             http_message(StatusCode::OK, header_hex, TTL_LONG)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"raw"), None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let raw = query
                 .chain()
                 .get_block_raw(&hash)
@@ -820,7 +821,7 @@ fn handle_request(
                 .unwrap())
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"txid"), Some(index), None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let index: usize = index.parse()?;
             let txids = query
                 .chain()
@@ -829,10 +830,14 @@ fn handle_request(
             if index >= txids.len() {
                 bail!(HttpError::not_found("tx index out of range".to_string()));
             }
-            http_message(StatusCode::OK, txids[index].to_hex(), TTL_LONG)
+            http_message(
+                StatusCode::OK,
+                txids[index].to_raw_hash().to_string(),
+                TTL_LONG,
+            )
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"txs"), start_index, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = hash.parse()?;
             let txids = query
                 .chain()
                 .get_block_txids(&hash)
@@ -1098,7 +1103,7 @@ fn handle_request(
             last_seen_txid,
         ) => {
             let script_hash = to_scripthash(script_type, script_str, config.network_type)?;
-            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_hex(txid).ok());
+            let last_seen_txid = last_seen_txid.and_then(|txid| txid.parse().ok());
             let max_txs = query_params
                 .get("max_txs")
                 .and_then(|s| s.parse::<usize>().ok())
@@ -1144,7 +1149,7 @@ fn handle_request(
             last_seen_txid,
         ) => {
             let script_hash = to_scripthash(script_type, script_str, config.network_type)?;
-            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_hex(txid).ok());
+            let last_seen_txid = last_seen_txid.and_then(|txid| txid.parse().ok());
             let max_txs = cmp::min(
                 config.rest_default_max_address_summary_txs,
                 query_params
@@ -1225,7 +1230,7 @@ fn handle_request(
                 })
                 .collect();
 
-            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_hex(txid).ok());
+            let last_seen_txid = last_seen_txid.and_then(|txid| txid.parse().ok());
             let max_txs = cmp::min(
                 config.rest_default_max_address_summary_txs,
                 query_params
@@ -1325,7 +1330,7 @@ fn handle_request(
             json_response(results, TTL_SHORT)
         }
         (&Method::GET, Some(&"tx"), Some(hash), None, None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
             let tx = query
                 .lookup_txn(&hash)
                 .ok_or_else(|| HttpError::not_found("Transaction not found".to_string()))?;
@@ -1350,7 +1355,7 @@ fn handle_request(
 
             match txid_strings
                 .into_iter()
-                .map(|txid| Txid::from_hex(&txid))
+                .map(|txid| txid.parse())
                 .collect::<Result<Vec<Txid>, _>>()
             {
                 Ok(txids) => {
@@ -1369,7 +1374,7 @@ fn handle_request(
         }
         (&Method::GET, Some(&"tx"), Some(hash), Some(out_type @ &"hex"), None, None)
         | (&Method::GET, Some(&"tx"), Some(hash), Some(out_type @ &"raw"), None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
             let rawtx = query
                 .lookup_raw_txn(&hash)
                 .ok_or_else(|| HttpError::not_found("Transaction not found".to_string()))?;
@@ -1390,20 +1395,20 @@ fn handle_request(
                 .unwrap())
         }
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"status"), None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
             let status = query.get_tx_status(&hash);
             let ttl = ttl_by_depth(status.block_height, query);
             json_response(status, ttl)
         }
 
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"merkle-proof"), None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
             let blockid = query.chain().tx_confirming_block(&hash).ok_or_else(|| {
                 HttpError::not_found("Transaction not found or is unconfirmed".to_string())
             })?;
             let (merkle, pos) =
                 electrum_merkle::get_tx_merkle_proof(query.chain(), &hash, &blockid.hash)?;
-            let merkle: Vec<String> = merkle.into_iter().map(|txid| txid.to_hex()).collect();
+            let merkle: Vec<String> = merkle.into_iter().map(|txid| txid.to_string()).collect();
             let ttl = ttl_by_depth(Some(blockid.height), query);
             json_response(
                 json!({ "block_height": blockid.height, "merkle": merkle, "pos": pos }),
@@ -1412,7 +1417,7 @@ fn handle_request(
         }
         #[cfg(not(feature = "liquid"))]
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"merkleblock-proof"), None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
 
             let merkleblock = query.chain().get_merkleblock_proof(&hash).ok_or_else(|| {
                 HttpError::not_found("Transaction not found or is unconfirmed".to_string())
@@ -1429,7 +1434,7 @@ fn handle_request(
             )
         }
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"outspend"), Some(index), None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
             let outpoint = OutPoint {
                 txid: hash,
                 vout: index.parse::<u32>()?,
@@ -1444,7 +1449,7 @@ fn handle_request(
             json_response(spend, ttl)
         }
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"outspends"), None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = hash.parse()?;
             let tx = query
                 .lookup_txn(&hash)
                 .ok_or_else(|| HttpError::not_found("Transaction not found".to_string()))?;
@@ -1471,7 +1476,7 @@ fn handle_request(
             let txid = query
                 .broadcast_raw(&txhex)
                 .map_err(|err| HttpError::from(err.description().to_string()))?;
-            http_message(StatusCode::OK, txid.to_hex(), 0)
+            http_message(StatusCode::OK, txid.to_raw_hash().to_string(), 0)
         }
         (&Method::POST, Some(&"txs"), Some(&"test"), None, None, None) => {
             let txhexes: Vec<String> =
@@ -1501,7 +1506,7 @@ fn handle_request(
                     )))
                 } else {
                     // must be a valid hex string
-                    Vec::<u8>::from_hex(txhex)
+                    hex::decode(txhex)
                         .map_err(|_| {
                             HttpError::from(format!("Invalid transaction hex for item {}", index))
                         })
@@ -1551,7 +1556,7 @@ fn handle_request(
                     )))
                 } else {
                     // must be a valid hex string
-                    Vec::<u8>::from_hex(txhex)
+                    hex::decode(txhex)
                         .map_err(|_| {
                             HttpError::from(format!("Invalid transaction hex for item {}", index))
                         })
@@ -1580,7 +1585,8 @@ fn handle_request(
             let spends: Vec<Vec<SpendingValue>> = txid_strings
                 .into_iter()
                 .map(|txid_str| {
-                    Txid::from_hex(txid_str)
+                    txid_str
+                        .parse()
                         .ok()
                         .and_then(|txid| query.lookup_txn(&txid))
                         .map_or_else(Vec::new, |tx| {
@@ -1611,7 +1617,8 @@ fn handle_request(
             let spends: Vec<Vec<SpendingValue>> = txid_strings
                 .into_iter()
                 .map(|txid_str| {
-                    Txid::from_hex(&txid_str)
+                    txid_str
+                        .parse()
                         .ok()
                         .and_then(|txid| query.lookup_txn(&txid))
                         .map_or_else(Vec::new, |tx| {
@@ -1647,7 +1654,7 @@ fn handle_request(
                     let index_part = parts.next();
 
                     if let (Some(hash), Some(index)) = (hash_part, index_part) {
-                        if let (Ok(txid), Ok(vout)) = (Txid::from_hex(hash), index.parse::<u32>()) {
+                        if let (Ok(txid), Ok(vout)) = (hash.parse(), index.parse::<u32>()) {
                             let outpoint = OutPoint { txid, vout };
                             return query
                                 .lookup_spend(&outpoint)
@@ -1668,7 +1675,7 @@ fn handle_request(
             json_response(query.mempool().txids(), TTL_SHORT)
         }
         (&Method::GET, Some(&"mempool"), Some(&"txids"), Some(&"page"), last_seen_txid, None) => {
-            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_hex(txid).ok());
+            let last_seen_txid = last_seen_txid.and_then(|txid| txid.parse().ok());
             let max_txs = query_params
                 .get("max_txs")
                 .and_then(|s| s.parse::<usize>().ok())
@@ -1701,7 +1708,7 @@ fn handle_request(
 
             match txid_strings
                 .into_iter()
-                .map(|txid| Txid::from_hex(&txid))
+                .map(|txid| txid.parse())
                 .collect::<Result<Vec<Txid>, _>>()
             {
                 Ok(txids) => {
@@ -1726,7 +1733,7 @@ fn handle_request(
             last_seen_txid,
             None,
         ) => {
-            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_hex(txid).ok());
+            let last_seen_txid = last_seen_txid.and_then(|txid| txid.parse().ok());
             let max_txs = query_params
                 .get("max_txs")
                 .and_then(|s| s.parse::<usize>().ok())
@@ -1834,7 +1841,7 @@ fn handle_request(
             last_seen_txid,
         ) => {
             let asset_id = AssetId::from_hex(asset_str)?;
-            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_hex(txid).ok());
+            let last_seen_txid = last_seen_txid.and_then(|txid| txid.parse().ok());
 
             let mut txs = query
                 .chain()
@@ -2010,18 +2017,7 @@ fn address_to_scripthash(addr: &str, network: Network) -> Result<FullHash, HttpE
     let addr = address::Address::parse_with_params(addr, network.address_params())?;
 
     #[cfg(not(feature = "liquid"))]
-    let is_expected_net = {
-        let addr_network = Network::from(addr.network);
-
-        // Testnet, Regtest and Signet all share the same version bytes,
-        // `addr_network` will be detected as Testnet for all of them.
-        addr_network == network
-            || (addr_network == Network::Testnet
-                && matches!(
-                    network,
-                    Network::Regtest | Network::Signet | Network::Testnet4
-                ))
-    };
+    let is_expected_net = { addr.clone().is_valid_for_network(network.into()) };
 
     #[cfg(feature = "liquid")]
     let is_expected_net = addr.params == network.address_params();
@@ -2030,6 +2026,8 @@ fn address_to_scripthash(addr: &str, network: Network) -> Result<FullHash, HttpE
         bail!(HttpError::from("Address on invalid network".to_string()))
     }
 
+    let addr = addr.assume_checked();
+
     Ok(compute_script_hash(&addr.script_pubkey()))
 }
 
@@ -2071,8 +2069,8 @@ impl From<ParseIntError> for HttpError {
         HttpError::from("Invalid number".to_string())
     }
 }
-impl From<HashError> for HttpError {
-    fn from(_e: HashError) -> Self {
+impl From<HexToArrayError> for HttpError {
+    fn from(_e: HexToArrayError) -> Self {
         //HttpError::from(e.description().to_string())
         HttpError::from("Invalid hash string".to_string())
     }
@@ -2083,14 +2081,8 @@ impl From<FromHexError> for HttpError {
         HttpError::from("Invalid hex string".to_string())
     }
 }
-impl From<bitcoin::hashes::hex::Error> for HttpError {
-    fn from(_e: bitcoin::hashes::hex::Error) -> Self {
-        //HttpError::from(e.description().to_string())
-        HttpError::from("Invalid hex string".to_string())
-    }
-}
-impl From<bitcoin::util::address::Error> for HttpError {
-    fn from(_e: bitcoin::util::address::Error) -> Self {
+impl From<bitcoin::address::ParseError> for HttpError {
+    fn from(_e: bitcoin::address::ParseError) -> Self {
         //HttpError::from(e.description().to_string())
         HttpError::from("Invalid Bitcoin address".to_string())
     }
@@ -2131,6 +2123,7 @@ impl From<address::AddressError> for HttpError {
 #[cfg(test)]
 mod tests {
     use crate::rest::HttpError;
+    use bitcoin::{block::Version, CompactTarget};
     use serde_json::Value;
     use std::collections::HashMap;
 
@@ -2203,7 +2196,7 @@ mod tests {
         let vectors = [
             (
                 // bits in header
-                0x17053894,
+                CompactTarget::from_consensus(0x17053894),
                 // expected output (Rust)
                 53911173001054.586,
                 // Block hash where found (for getblockheader)
@@ -2212,93 +2205,93 @@ mod tests {
                 "53911173001054.59",
             ),
             (
-                0x1a0c2a12,
+                CompactTarget::from_consensus(0x1a0c2a12),
                 1379192.2882280778,
                 "0000000000000bc7636ffbc1cf90cf4a2674de7fcadbc6c9b63d31f07cb3c2c2",
                 "1379192.288228078",
             ),
             (
-                0x19262222,
+                CompactTarget::from_consensus(0x19262222),
                 112628548.66634709,
                 "000000000000000996b1f06771a81bcf7b15c5f859b6f8329016f01b0442ca72",
                 "112628548.6663471",
             ),
             (
-                0x1d00c428,
+                CompactTarget::from_consensus(0x1d00c428),
                 1.3050621315915245,
                 "0000000034014d731a3e1ad6078662ce19b08179dcc7ec0f5f717d4b58060736",
                 "1.305062131591525",
             ),
             (
-                0,
+                CompactTarget::from_consensus(0),
                 f64::INFINITY,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking edge cases]",
             ),
             (
-                0x00000001,
+                CompactTarget::from_consensus(0x00000001),
                 4.523059468369196e74,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking edge cases]",
             ),
             (
-                0x1d00ffff,
+                CompactTarget::from_consensus(0x1d00ffff),
                 1.0,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET]",
             ),
             (
-                0x1c7fff80,
+                CompactTarget::from_consensus(0x1c7fff80),
                 2.0,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET >> 1]",
             ),
             (
-                0x1b00ffff,
+                CompactTarget::from_consensus(0x1b00ffff),
                 65536.0,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET >> 16]",
             ),
             (
-                0x1a7fff80,
+                CompactTarget::from_consensus(0x1a7fff80),
                 131072.0,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET >> 17]",
             ),
             (
-                0x1d01fffe,
+                CompactTarget::from_consensus(0x1d01fffe),
                 0.5,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET << 1]",
             ),
             (
-                0x1f000080,
+                CompactTarget::from_consensus(0x1f000080),
                 0.007812380790710449,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking 2**255]",
             ),
             (
-                0x1e00ffff,
+                CompactTarget::from_consensus(0x1e00ffff),
                 0.00390625, // 2.0**-8
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET << 8]",
             ),
             (
-                0x1e00ff00,
+                CompactTarget::from_consensus(0x1e00ff00),
                 0.0039215087890625,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET << 8 - two `f` chars]",
             ),
             (
-                0x1f0000ff,
+                CompactTarget::from_consensus(0x1f0000ff),
                 0.0039215087890625,
                 "[No Blockhash]",
                 "[No Core difficulty, just checking MAX_TARGET << 8]",
             ),
         ];
 
-        let to_bh = |b| bitcoin::BlockHeader {
-            version: 1,
+        let to_bh = |b| bitcoin::block::Header {
+            version: Version::from_consensus(1),
             prev_blockhash: "0000000000000000000000000000000000000000000000000000000000000000"
                 .parse()
                 .unwrap(),
diff --git a/src/util/block.rs b/src/util/block.rs
index e1f3900d..2fe9b7b6 100644
--- a/src/util/block.rs
+++ b/src/util/block.rs
@@ -2,6 +2,7 @@ use crate::chain::{BlockHash, BlockHeader};
 use crate::errors::*;
 use crate::new_index::BlockEntry;
 
+use bitcoin::hashes::Hash;
 use std::collections::HashMap;
 use std::fmt;
 use std::iter::FromIterator;
@@ -73,7 +74,7 @@ impl HeaderList {
         HeaderList {
             headers: vec![],
             heights: HashMap::new(),
-            tip: BlockHash::default(),
+            tip: BlockHash::all_zeros(),
         }
     }
 
@@ -89,7 +90,7 @@ impl HeaderList {
 
         let mut blockhash = tip_hash;
         let mut headers_chain: Vec<BlockHeader> = vec![];
-        let null_hash = BlockHash::default();
+        let null_hash = BlockHash::all_zeros();
 
         while blockhash != null_hash {
             let header = headers_map.remove(&blockhash).unwrap_or_else(|| {
@@ -136,7 +137,7 @@ impl HeaderList {
             Some(h) => h.header.prev_blockhash,
             None => return vec![], // hashed_headers is empty
         };
-        let null_hash = BlockHash::default();
+        let null_hash = BlockHash::all_zeros();
         let new_height: usize = if prev_blockhash == null_hash {
             0
         } else {
@@ -175,7 +176,7 @@ impl HeaderList {
                 let expected_prev_blockhash = if height > 0 {
                     *self.headers[height - 1].hash()
                 } else {
-                    BlockHash::default()
+                    BlockHash::all_zeros()
                 };
                 assert_eq!(entry.header().prev_blockhash, expected_prev_blockhash);
                 height
@@ -230,7 +231,10 @@ impl HeaderList {
     pub fn tip(&self) -> &BlockHash {
         assert_eq!(
             self.tip,
-            self.headers.last().map(|h| *h.hash()).unwrap_or_default()
+            self.headers
+                .last()
+                .map(|h| *h.hash())
+                .unwrap_or_else(|| BlockHash::all_zeros())
         );
         &self.tip
     }
@@ -308,7 +312,7 @@ impl From<&BlockEntry> for BlockMeta {
     fn from(b: &BlockEntry) -> BlockMeta {
         BlockMeta {
             tx_count: b.block.txdata.len() as u32,
-            weight: b.block.weight() as u32,
+            weight: b.block.weight().to_wu() as u32,
             size: b.size,
         }
     }
diff --git a/src/util/fees.rs b/src/util/fees.rs
index 828be6cd..0a5556eb 100644
--- a/src/util/fees.rs
+++ b/src/util/fees.rs
@@ -12,7 +12,7 @@ pub struct TxFeeInfo {
 impl TxFeeInfo {
     pub fn new(tx: &Transaction, prevouts: &HashMap<u32, &TxOut>, network: Network) -> Self {
         let fee = get_tx_fee(tx, prevouts, network);
-        let vsize = tx.weight() / 4;
+        let vsize = tx.weight().to_vbytes_floor();
 
         TxFeeInfo {
             fee,
@@ -24,12 +24,15 @@ impl TxFeeInfo {
 
 #[cfg(not(feature = "liquid"))]
 pub fn get_tx_fee(tx: &Transaction, prevouts: &HashMap<u32, &TxOut>, _network: Network) -> u64 {
-    if tx.is_coin_base() {
+    if tx.is_coinbase() {
         return 0;
     }
 
-    let total_in: u64 = prevouts.values().map(|prevout| prevout.value).sum();
-    let total_out: u64 = tx.output.iter().map(|vout| vout.value).sum();
+    let total_in: u64 = prevouts
+        .values()
+        .map(|prevout| prevout.value.to_sat())
+        .sum();
+    let total_out: u64 = tx.output.iter().map(|vout| vout.value.to_sat()).sum();
     total_in - total_out
 }
 
diff --git a/src/util/mod.rs b/src/util/mod.rs
index b7c7de4f..9c76ed4c 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -194,34 +194,32 @@ pub fn create_socket(addr: &SocketAddr) -> Socket {
 ///
 /// Copied from https://github.com/rust-bitcoin/rust-bitcoincore-rpc/blob/master/json/src/lib.rs
 pub mod serde_hex {
-    use bitcoin::hashes::hex::{FromHex, ToHex};
     use serde::de::Error;
     use serde::{Deserializer, Serializer};
 
     pub fn serialize<S: Serializer>(b: &[u8], s: S) -> Result<S::Ok, S::Error> {
-        s.serialize_str(&b.to_hex())
+        s.serialize_str(&hex::encode(b))
     }
 
     pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
         let hex_str: String = ::serde::Deserialize::deserialize(d)?;
-        FromHex::from_hex(&hex_str).map_err(D::Error::custom)
+        hex::decode(&hex_str).map_err(D::Error::custom)
     }
 
     pub mod opt {
-        use bitcoin::hashes::hex::{FromHex, ToHex};
         use serde::de::Error;
         use serde::{Deserializer, Serializer};
 
         pub fn serialize<S: Serializer>(b: &Option<Vec<u8>>, s: S) -> Result<S::Ok, S::Error> {
             match *b {
                 None => s.serialize_none(),
-                Some(ref b) => s.serialize_str(&b.to_hex()),
+                Some(ref b) => s.serialize_str(&hex::encode(b)),
             }
         }
 
         pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Vec<u8>>, D::Error> {
             let hex_str: String = ::serde::Deserialize::deserialize(d)?;
-            Ok(Some(FromHex::from_hex(&hex_str).map_err(D::Error::custom)?))
+            Ok(Some(hex::decode(&hex_str).map_err(D::Error::custom)?))
         }
     }
 }
diff --git a/src/util/script.rs b/src/util/script.rs
index 8774edcf..54653a6c 100644
--- a/src/util/script.rs
+++ b/src/util/script.rs
@@ -1,12 +1,13 @@
 #[cfg(feature = "liquid")]
 use elements::address as elements_address;
 
-use crate::chain::{script, Network, Script, TxIn, TxOut};
+use crate::chain::{script, BNetwork, Network, Script, TxIn, TxOut};
+use crate::errors;
 use script::Instruction::PushBytes;
 
-pub struct InnerScripts {
-    pub redeem_script: Option<Script>,
-    pub witness_script: Option<Script>,
+pub struct InnerScripts<'a> {
+    pub redeem_script: Option<&'a Script>,
+    pub witness_script: Option<&'a Script>,
 }
 
 pub trait ScriptToAsm: std::fmt::Debug {
@@ -16,16 +17,19 @@ pub trait ScriptToAsm: std::fmt::Debug {
     }
 }
 impl ScriptToAsm for bitcoin::Script {}
+impl ScriptToAsm for &bitcoin::Script {}
 #[cfg(feature = "liquid")]
 impl ScriptToAsm for elements::Script {}
 
 pub trait ScriptToAddr {
-    fn to_address_str(&self, network: Network) -> Option<String>;
+    fn to_address_str(&self, network: Network) -> Result<String, errors::Error>;
 }
 #[cfg(not(feature = "liquid"))]
 impl ScriptToAddr for bitcoin::Script {
-    fn to_address_str(&self, network: Network) -> Option<String> {
-        bitcoin::Address::from_script(self, network.into()).map(|s| s.to_string())
+    fn to_address_str(&self, network: Network) -> Result<String, errors::Error> {
+        bitcoin::Address::from_script(self, BNetwork::from(network))
+            .map_err(|e| format!("Failed to convert script to an address: {e}").into())
+            .map(|s| s.to_string())
     }
 }
 #[cfg(feature = "liquid")]
@@ -37,11 +41,11 @@ impl ScriptToAddr for elements::Script {
 }
 
 // Returns the witnessScript in the case of p2wsh, or the redeemScript in the case of p2sh.
-pub fn get_innerscripts(txin: &TxIn, prevout: &TxOut) -> InnerScripts {
+pub fn get_innerscripts<'a>(txin: &'a TxIn, prevout: &TxOut) -> InnerScripts<'a> {
     // Wrapped redeemScript for P2SH spends
     let redeem_script = if prevout.script_pubkey.is_p2sh() {
         if let Some(Ok(PushBytes(redeemscript))) = txin.script_sig.instructions().last() {
-            Some(Script::from(redeemscript.to_vec()))
+            Some(Script::from_bytes(redeemscript.as_bytes()))
         } else {
             None
         }
@@ -50,21 +54,15 @@ pub fn get_innerscripts(txin: &TxIn, prevout: &TxOut) -> InnerScripts {
     };
 
     // Wrapped witnessScript for P2WSH or P2SH-P2WSH spends
-    let witness_script = if prevout.script_pubkey.is_v0_p2wsh()
-        || prevout.script_pubkey.is_v1_p2tr()
-        || redeem_script.as_ref().map_or(false, |s| s.is_v0_p2wsh())
+    let witness_script = if prevout.script_pubkey.is_p2wsh()
+        || prevout.script_pubkey.is_p2tr()
+        || redeem_script.as_ref().map_or(false, |s| s.is_p2wsh())
     {
         let witness = &txin.witness;
         #[cfg(feature = "liquid")]
         let witness = &witness.script_witness;
 
-        // rust-bitcoin returns witness items as a [u8] slice, while rust-elements returns a Vec<u8>
-        #[cfg(not(feature = "liquid"))]
-        let wit_to_vec = Vec::from;
-        #[cfg(feature = "liquid")]
-        let wit_to_vec = Clone::clone;
-
-        let inner_script_slice = if prevout.script_pubkey.is_v1_p2tr() {
+        let inner_script_slice = if prevout.script_pubkey.is_p2tr() {
             // Witness stack is potentially very large
             // so we avoid to_vec() or iter().collect() for performance
             let w_len = witness.len();
@@ -96,7 +94,7 @@ pub fn get_innerscripts(txin: &TxIn, prevout: &TxOut) -> InnerScripts {
             witness.last()
         };
 
-        inner_script_slice.map(wit_to_vec).map(Script::from)
+        inner_script_slice.map(Script::from_bytes)
     } else {
         None
     };
diff --git a/src/util/transaction.rs b/src/util/transaction.rs
index d1a8cc2c..78cf5901 100644
--- a/src/util/transaction.rs
+++ b/src/util/transaction.rs
@@ -117,13 +117,9 @@ where
 
 pub(super) mod sigops {
     use crate::chain::{
-        hashes::hex::FromHex,
-        opcodes::{
-            all::{OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY, OP_CHECKSIG, OP_CHECKSIGVERIFY},
-            All,
-        },
+        opcodes::all::{OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY, OP_CHECKSIG, OP_CHECKSIGVERIFY},
         script::{self, Instruction},
-        Transaction, TxOut, Witness,
+        Opcode, Transaction, TxOut, Witness,
     };
     use std::collections::HashMap;
 
@@ -136,7 +132,7 @@ pub(super) mod sigops {
         let mut prevouts = Vec::with_capacity(input_count);
 
         #[cfg(not(feature = "liquid"))]
-        let is_coinbase_or_pegin = tx.is_coin_base();
+        let is_coinbase_or_pegin = tx.is_coinbase();
         #[cfg(feature = "liquid")]
         let is_coinbase_or_pegin = tx.is_coinbase() || tx.input.iter().any(|input| input.is_pegin);
 
@@ -154,10 +150,10 @@ pub(super) mod sigops {
         get_sigop_cost(tx, &prevouts, true, true)
     }
 
-    fn decode_pushnum(op: &All) -> Option<u8> {
+    fn decode_pushnum(op: &Opcode) -> Option<u8> {
         // 81 = OP_1, 96 = OP_16
         // 81 -> 1, so... 81 - 80 -> 1
-        let self_u8 = op.into_u8();
+        let self_u8 = op.to_u8();
         match self_u8 {
             81..=96 => Some(self_u8 - 80),
             _ => None,
@@ -216,7 +212,7 @@ pub(super) mod sigops {
 
     fn get_p2sh_sigop_count(tx: &Transaction, previous_outputs: &[&TxOut]) -> usize {
         #[cfg(not(feature = "liquid"))]
-        if tx.is_coin_base() {
+        if tx.is_coinbase() {
             return 0;
         }
         #[cfg(feature = "liquid")]
@@ -229,8 +225,7 @@ pub(super) mod sigops {
                 if let Some(Ok(script::Instruction::PushBytes(redeem))) =
                     input.script_sig.instructions().last()
                 {
-                    let script =
-                        script::Script::from_byte_iter(redeem.iter().map(|v| Ok(*v))).unwrap(); // I only return Ok, so it won't error
+                    let script = script::Script::from_bytes(redeem.as_bytes());
                     n += count_sigops(&script, true);
                 }
             }
@@ -256,7 +251,7 @@ pub(super) mod sigops {
         #[inline]
         fn last_pushdata(script: &script::Script) -> Option<&[u8]> {
             match script.instructions().last() {
-                Some(Ok(Instruction::PushBytes(bytes))) => Some(bytes),
+                Some(Ok(Instruction::PushBytes(bytes))) => Some(bytes.as_bytes()),
                 _ => None,
             }
         }
@@ -275,18 +270,15 @@ pub(super) mod sigops {
                 && is_push_only(script_sig)
                 && !script_sig.is_empty()
             {
-                script::Script::from_byte_iter(
-                    last_pushdata(script_sig).unwrap().iter().map(|v| Ok(*v)),
-                )
-                .unwrap()
+                script::Script::from_bytes(last_pushdata(script_sig).unwrap()).into()
             } else {
                 return 0;
             };
 
-            if script.is_v0_p2wsh() {
+            if script.is_p2wsh() {
                 let bytes = script.as_bytes();
                 n += sig_ops(witness, bytes[0], &bytes[2..]);
-            } else if script.is_v0_p2wpkh() {
+            } else if script.is_p2wpkh() {
                 n += 1;
             }
             n
@@ -307,7 +299,7 @@ pub(super) mod sigops {
     ) -> Result<usize, script::Error> {
         let mut n_sigop_cost = get_legacy_sigop_count(tx) * 4;
         #[cfg(not(feature = "liquid"))]
-        if tx.is_coin_base() {
+        if tx.is_coinbase() {
             return Ok(n_sigop_cost);
         }
         #[cfg(feature = "liquid")]
@@ -341,10 +333,9 @@ pub(super) mod sigops {
         match (witness_version, witness_program.len()) {
             (0, 20) => 1,
             (0, 32) => last_witness
-                .map(|sl| sl.iter().map(|v| Ok(*v)))
-                .map(script::Script::from_byte_iter)
+                .map(script::Script::from_bytes)
                 // I only return Ok 2 lines up, so there is no way to error
-                .map(|s| count_sigops(&s.unwrap(), true))
+                .map(|s| count_sigops(&s, true))
                 .unwrap_or_default(),
             _ => 0,
         }