From 30899e9e81489c385bac95bffd3e5175875e6073 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Tue, 8 Aug 2023 20:38:46 +0300
Subject: [PATCH 1/8] Update rust-bitcoin to v0.30.1
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Some API JSON data types were updated to match changes in the
underlying rust-bitcoin data types:

- vsize and weights were changed from u32 to u64 (in `GET /tx/:txid`,
  `GET /block/:hash`, `GET /mempool` and `GET /mempool/recent`)

- The `fee_histogram` was changed from [(f32,u32)] to [(f64,u64)]
  (in `GET /mempool` and Electrum's `mempool.get_fee_histogram`)

- Block mining difficulty was changed from u64 to u128
  (in GET `/block/:hash`)

The actual JSON string serialization should remain unchanged, as
serde-json serializes u64/u128/f64 as standard JSON numbers.

However, numbers over ECMAScript's MAX_SAFE_INTEGER (2⁵³-1) may now
produce JSON that some clients may fail to read correctly, while
previously they would overflow (or error) on the server side.

This shouldn't matter in practice because there shouldn't be such large
numbers for weights, vsizes or mining difficulty. And if there are, the
new behaviour seems (arguably?) better.

To retain DB compatibility, block weights are converted to a u32 for the
BlockMeta storage. This is OK because u32::MAX is far above MAX_BLOCK_WEIGHT.
---
 Cargo.lock                      |  75 ++++++++++++++++++-
 Cargo.toml                      |   3 +-
 src/bin/tx-fingerprint-stats.rs |   4 +-
 src/chain.rs                    |   8 +-
 src/daemon.rs                   |  44 +++++------
 src/electrum/client.rs          |  12 ++-
 src/new_index/mempool.rs        |   6 +-
 src/new_index/precache.rs       |   4 +-
 src/new_index/schema.rs         |   2 +-
 src/rest.rs                     | 129 ++++++++++++++------------------
 src/util/block.rs               |  27 +++++--
 src/util/fees.rs                |  15 ++--
 src/util/mod.rs                 |  19 ++---
 src/util/script.rs              |   8 +-
 14 files changed, 212 insertions(+), 144 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7fef399bf..d2a50dd3e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -106,6 +106,12 @@ version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf9ff0bbfd639f15c74af777d81383cf53efb7c93613f6cab67c6c11e05bbf8b"
 
+[[package]]
+name = "bech32"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445"
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -140,7 +146,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",
@@ -152,12 +158,32 @@ 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.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e99ff7289b20a7385f66a0feda78af2fc119d28fb56aea8886a9cd0a4abdd75"
+dependencies = [
+ "bech32 0.9.1",
+ "bitcoin-private",
+ "bitcoin_hashes 0.12.0",
+ "hex_lit",
+ "secp256k1 0.27.0",
+ "serde",
+]
+
+[[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.7.6"
@@ -173,6 +199,16 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bitcoin_hashes"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d7066118b13d4b20b23645932dfb3a81ce7e29f95726c2036fa33cd7b092501"
+dependencies = [
+ "bitcoin-private",
+ "serde",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -354,7 +390,7 @@ dependencies = [
  "arrayref",
  "base64 0.13.0",
  "bincode",
- "bitcoin 0.28.0",
+ "bitcoin 0.30.1",
  "clap",
  "crossbeam-channel",
  "dirs",
@@ -363,6 +399,7 @@ dependencies = [
  "error-chain",
  "glob",
  "hex",
+ "hex-conservative",
  "hyper",
  "hyperlocal",
  "itertools",
@@ -571,6 +608,18 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[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 = "http"
 version = "0.2.6"
@@ -1341,6 +1390,17 @@ dependencies = [
  "serde",
 ]
 
+[[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",
+ "serde",
+]
+
 [[package]]
 name = "secp256k1-sys"
 version = "0.4.2"
@@ -1359,6 +1419,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 = "secp256k1-zkp"
 version = "0.6.0"
diff --git a/Cargo.toml b/Cargo.toml
index 7b8ec562c..f3b5ccc43 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ arraydeque = "0.4"
 arrayref = "0.3.6"
 base64 = "0.13.0"
 bincode = "1.3.1"
-bitcoin = { version = "0.28", features = [ "use-serde" ] }
+bitcoin = { version = "0.30.1", features = [ "serde" ] }
 clap = "2.33.3"
 crossbeam-channel = "0.5.0"
 dirs = "4.0.0"
@@ -55,6 +55,7 @@ hyper = "0.14"
 hyperlocal = "0.8"
 # close to same tokio version as dependent by hyper v0.14 and hyperlocal 0.8 -- things can go awry if they mismatch
 tokio = { version = "1", features = ["sync", "macros"] }
+bhex = { package = "hex-conservative", version = "0.1.1" }
 
 # optional dependencies for electrum-discovery
 electrum-client = { version = "0.8", optional = true }
diff --git a/src/bin/tx-fingerprint-stats.rs b/src/bin/tx-fingerprint-stats.rs
index f3ccf45e0..da5318547 100644
--- a/src/bin/tx-fingerprint-stats.rs
+++ b/src/bin/tx-fingerprint-stats.rs
@@ -9,7 +9,7 @@ fn main() {
     use std::collections::HashSet;
     use std::sync::Arc;
 
-    use bitcoin::blockdata::script::Script;
+    use bitcoin::blockdata::script::ScriptBuf;
     use bitcoin::consensus::encode::deserialize;
     use electrs::{
         chain::Transaction,
@@ -118,7 +118,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 a7feb3ffd..3168a5be7 100644
--- a/src/chain.rs
+++ b/src/chain.rs
@@ -1,7 +1,7 @@
 #[cfg(not(feature = "liquid"))] // use regular Bitcoin data structures
 pub use bitcoin::{
-    blockdata::script, consensus::deserialize, util::address, Block, BlockHash, BlockHeader,
-    OutPoint, Script, Transaction, TxIn, TxOut, Txid,
+    address, blockdata::block::Header as BlockHeader, blockdata::script, consensus::deserialize,
+    Block, BlockHash, OutPoint, ScriptBuf as Script, Transaction, TxIn, TxOut, Txid,
 };
 
 #[cfg(feature = "liquid")]
@@ -52,7 +52,7 @@ pub const LIQUID_TESTNET_PARAMS: address::AddressParams = address::AddressParams
 impl Network {
     #[cfg(not(feature = "liquid"))]
     pub fn magic(self) -> u32 {
-        BNetwork::from(self).magic()
+        u32::from_le_bytes(BNetwork::from(self).magic().to_bytes())
     }
 
     #[cfg(feature = "liquid")]
@@ -141,6 +141,7 @@ pub fn bitcoin_genesis_hash(network: BNetwork) -> bitcoin::BlockHash {
         BNetwork::Testnet => *TESTNET_GENESIS,
         BNetwork::Regtest => *REGTEST_GENESIS,
         BNetwork::Signet => *SIGNET_GENESIS,
+        _ => panic!("unknown network {:?}", network),
     }
 }
 
@@ -206,6 +207,7 @@ impl From<BNetwork> for Network {
             BNetwork::Testnet => Network::Testnet,
             BNetwork::Regtest => Network::Regtest,
             BNetwork::Signet => Network::Signet,
+            _ => panic!("unknown network {:?}", network),
         }
     }
 }
diff --git a/src/daemon.rs b/src/daemon.rs
index 780ced933..497add9b2 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -2,11 +2,11 @@ use std::collections::{HashMap, HashSet};
 use std::io::{BufRead, BufReader, Lines, Write};
 use std::net::{SocketAddr, TcpStream};
 use std::path::PathBuf;
+use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use base64;
-use bitcoin::hashes::hex::{FromHex, ToHex};
 use glob;
 use hex;
 use itertools::Itertools;
@@ -20,15 +20,16 @@ use elements::encode::{deserialize, serialize};
 use crate::chain::{Block, BlockHash, BlockHeader, Network, Transaction, Txid};
 use crate::metrics::{HistogramOpts, HistogramVec, Metrics};
 use crate::signal::Waiter;
-use crate::util::HeaderList;
+use crate::util::{HeaderList, DEFAULT_BLOCKHASH};
 
 use crate::errors::*;
 
 fn parse_hash<T>(value: &Value) -> Result<T>
 where
-    T: FromHex,
+    T: FromStr,
+    T::Err: 'static + std::error::Error + Send,
 {
-    Ok(T::from_hex(
+    Ok(T::from_str(
         value
             .as_str()
             .chain_err(|| format!("non-string value: {}", value))?,
@@ -441,10 +442,7 @@ impl Daemon {
     }
 
     pub fn getblockheader(&self, blockhash: &BlockHash) -> Result<BlockHeader> {
-        header_from_value(self.request(
-            "getblockheader",
-            json!([blockhash.to_hex(), /*verbose=*/ false]),
-        )?)
+        header_from_value(self.request("getblockheader", json!([blockhash, /*verbose=*/ false]))?)
     }
 
     pub fn getblockheaders(&self, heights: &[usize]) -> Result<Vec<BlockHeader>> {
@@ -462,21 +460,20 @@ 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, /*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, 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, /*verbose=*/ false]))
             .collect();
         let values = self.requests("getblock", &params_list)?;
         let mut blocks = vec![];
@@ -489,7 +486,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, /*verbose=*/ false]))
             .collect();
 
         let values = self.requests("getrawtransaction", &params_list)?;
@@ -507,17 +504,11 @@ impl Daemon {
         blockhash: &BlockHash,
         verbose: bool,
     ) -> Result<Value> {
-        self.request(
-            "getrawtransaction",
-            json!([txid.to_hex(), verbose, blockhash]),
-        )
+        self.request("getrawtransaction", json!([txid, verbose, blockhash]))
     }
 
     pub fn getmempooltx(&self, txhash: &Txid) -> Result<Transaction> {
-        let value = self.request(
-            "getrawtransaction",
-            json!([txhash.to_hex(), /*verbose=*/ false]),
-        )?;
+        let value = self.request("getrawtransaction", json!([txhash, /*verbose=*/ false]))?;
         tx_from_value(value)
     }
 
@@ -533,7 +524,7 @@ impl Daemon {
     pub fn broadcast_raw(&self, txhex: &str) -> Result<Txid> {
         let txid = self.request("sendrawtransaction", json!([txhex]))?;
         Ok(
-            Txid::from_hex(txid.as_str().chain_err(|| "non-string txid")?)
+            Txid::from_str(txid.as_str().chain_err(|| "non-string txid")?)
                 .chain_err(|| "failed to parse txid")?,
         )
     }
@@ -573,7 +564,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]))?;
         let tip_height = info
             .get("height")
             .expect("missing height")
@@ -589,7 +580,7 @@ impl Daemon {
             result.append(&mut headers);
         }
 
-        let mut blockhash = BlockHash::default();
+        let mut blockhash = *DEFAULT_BLOCKHASH;
         for header in &result {
             assert_eq!(header.prev_blockhash, blockhash);
             blockhash = header.block_hash();
@@ -615,9 +606,8 @@ impl Daemon {
             bestblockhash,
         );
         let mut new_headers = vec![];
-        let null_hash = BlockHash::default();
         let mut blockhash = *bestblockhash;
-        while blockhash != null_hash {
+        while blockhash != *DEFAULT_BLOCKHASH {
             if indexed_headers.header_by_blockhash(&blockhash).is_some() {
                 break;
             }
diff --git a/src/electrum/client.rs b/src/electrum/client.rs
index 04d6ffba6..be99efe15 100644
--- a/src/electrum/client.rs
+++ b/src/electrum/client.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::convert::TryFrom;
 
-use bitcoin::hashes::Hash;
+use bitcoin::hashes::{sha256d, Hash};
 pub use electrum_client::client::Client;
 pub use electrum_client::Error as ElectrumError;
 pub use electrum_client::ServerFeaturesRes;
@@ -14,13 +14,17 @@ use crate::errors::{Error, ResultExt};
 // the electrum-client's one doesn't support the "hosts" key.
 impl TryFrom<ServerFeaturesRes> for ServerFeatures {
     type Error = Error;
-    fn try_from(mut features: ServerFeaturesRes) -> Result<Self, Self::Error> {
-        features.genesis_hash.reverse();
+    fn try_from(features: ServerFeaturesRes) -> Result<Self, Self::Error> {
+        let genesis_hash = {
+            let mut genesis_hash = features.genesis_hash;
+            genesis_hash.reverse();
+            BlockHash::from_raw_hash(sha256d::Hash::from_byte_array(genesis_hash))
+        };
 
         Ok(ServerFeatures {
             // electrum-client doesn't retain the hosts map data, but we already have it from the add_peer request
             hosts: HashMap::new(),
-            genesis_hash: BlockHash::from_inner(features.genesis_hash),
+            genesis_hash,
             server_version: features.server_version,
             protocol_min: features
                 .protocol_min
diff --git a/src/new_index/mempool.rs b/src/new_index/mempool.rs
index 9586c5168..28fe7ad05 100644
--- a/src/new_index/mempool.rs
+++ b/src/new_index/mempool.rs
@@ -56,7 +56,7 @@ pub struct Mempool {
 pub struct TxOverview {
     txid: Txid,
     fee: u64,
-    vsize: u32,
+    vsize: u64,
     #[cfg(not(feature = "liquid"))]
     value: u64,
 }
@@ -518,9 +518,9 @@ impl Mempool {
 #[derive(Serialize)]
 pub struct BacklogStats {
     pub count: u32,
-    pub vsize: u32,     // in virtual bytes (= weight/4)
+    pub vsize: u64,     // in virtual bytes (= weight/4)
     pub total_fee: u64, // in satoshis
-    pub fee_histogram: Vec<(f32, u32)>,
+    pub fee_histogram: Vec<(f64, u64)>,
 }
 
 impl BacklogStats {
diff --git a/src/new_index/precache.rs b/src/new_index/precache.rs
index 324598191..68b08fe90 100644
--- a/src/new_index/precache.rs
+++ b/src/new_index/precache.rs
@@ -63,7 +63,9 @@ fn to_scripthash(script_type: &str, script_str: &str) -> Result<FullHash> {
 }
 
 fn address_to_scripthash(addr: &str) -> Result<FullHash> {
-    let addr = Address::from_str(addr).chain_err(|| "invalid address")?;
+    let addr = Address::from_str(addr)
+        .chain_err(|| "invalid address")?
+        .assume_checked();
     Ok(compute_script_hash(&addr.script_pubkey().as_bytes()))
 }
 
diff --git a/src/new_index/schema.rs b/src/new_index/schema.rs
index 35e49f8de..9a8e0bd40 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::merkle_tree::MerkleBlock;
 use bitcoin::VarInt;
 use crypto::digest::Digest;
 use crypto::sha2::Sha256;
diff --git a/src/rest.rs b/src/rest.rs
index 108215634..05d2e956c 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -5,14 +5,13 @@ use crate::new_index::{compute_script_hash, Query, SpendingInput, Utxo};
 use crate::util::{
     create_socket, electrum_merkle, extract_tx_prevouts, full_hash, get_innerscripts, get_tx_fee,
     has_prevout, is_coinbase, BlockHeaderMeta, BlockId, FullHash, ScriptToAddr, ScriptToAsm,
-    TransactionStatus,
+    TransactionStatus, DEFAULT_BLOCKHASH,
 };
 
 #[cfg(not(feature = "liquid"))]
 use {bitcoin::consensus::encode, std::str::FromStr};
 
-use bitcoin::blockdata::opcodes;
-use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::blockdata;
 use bitcoin::hashes::Error as HashError;
 use hex::{self, FromHexError};
 use hyper::service::{make_service_fn, service_fn};
@@ -62,7 +61,7 @@ struct BlockValue {
     timestamp: u32,
     tx_count: u32,
     size: u32,
-    weight: u32,
+    weight: u64,
     merkle_root: String,
     previousblockhash: Option<String>,
     mediantime: u32,
@@ -70,9 +69,9 @@ struct BlockValue {
     #[cfg(not(feature = "liquid"))]
     nonce: u32,
     #[cfg(not(feature = "liquid"))]
-    bits: u32,
+    bits: bitcoin::pow::CompactTarget,
     #[cfg(not(feature = "liquid"))]
-    difficulty: u64,
+    difficulty: u128,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -81,19 +80,19 @@ struct BlockValue {
 
 impl BlockValue {
     #[cfg_attr(feature = "liquid", allow(unused_variables))]
-    fn new(blockhm: BlockHeaderMeta, network: Network) -> Self {
+    fn new(blockhm: BlockHeaderMeta) -> Self {
         let header = blockhm.header_entry.header();
         BlockValue {
-            id: header.block_hash().to_hex(),
+            id: header.block_hash().to_string(),
             height: blockhm.header_entry.height() as u32,
-            version: header.version as u32,
+            version: 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())
+            weight: blockhm.meta.weight as u64,
+            merkle_root: header.merkle_root.to_string(),
+            previousblockhash: if header.prev_blockhash != *DEFAULT_BLOCKHASH {
+                Some(header.prev_blockhash.to_string())
             } else {
                 None
             },
@@ -104,7 +103,7 @@ impl BlockValue {
             #[cfg(not(feature = "liquid"))]
             nonce: header.nonce,
             #[cfg(not(feature = "liquid"))]
-            difficulty: header.difficulty(bitcoin::Network::from(network)),
+            difficulty: header.difficulty(),
 
             #[cfg(feature = "liquid")]
             ext: Some(json!(header.ext)),
@@ -116,11 +115,11 @@ impl BlockValue {
 struct TransactionValue {
     txid: Txid,
     version: u32,
-    locktime: u32,
+    locktime: bitcoin::absolute::LockTime,
     vin: Vec<TxInValue>,
     vout: Vec<TxOutValue>,
     size: u32,
-    weight: u32,
+    weight: u64,
     fee: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
     status: Option<TransactionStatus>,
@@ -157,7 +156,7 @@ impl TransactionValue {
             vin: vins,
             vout: vouts,
             size: tx.size() as u32,
-            weight: tx.weight() as u32,
+            weight: tx.weight().to_wu(),
             fee,
             status: Some(TransactionStatus::from(blockid)),
         }
@@ -174,7 +173,7 @@ struct TxInValue {
     #[serde(skip_serializing_if = "Option::is_none")]
     witness: Option<Vec<String>>,
     is_coinbase: bool,
-    sequence: u32,
+    sequence: blockdata::transaction::Sequence,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     inner_redeemscript_asm: Option<String>,
@@ -284,7 +283,7 @@ impl TxOutValue {
 
         #[cfg(feature = "liquid")]
         let asset = match txout.asset {
-            Asset::Explicit(value) => Some(value.to_hex()),
+            Asset::Explicit(value) => Some(value.to_string()),
             _ => None,
         };
         #[cfg(feature = "liquid")]
@@ -319,7 +318,7 @@ impl TxOutValue {
             "v0_p2wpkh"
         } else if script.is_v0_p2wsh() {
             "v0_p2wsh"
-        } else if is_v1_p2tr(script) {
+        } else if script.is_v1_p2tr() {
             "v1_p2tr"
         } else if script.is_provably_unspendable() {
             "provably_unspendable"
@@ -347,11 +346,6 @@ 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()
-}
 
 #[derive(Serialize)]
 struct UtxoValue {
@@ -416,7 +410,7 @@ impl From<Utxo> for UtxoValue {
             },
             #[cfg(feature = "liquid")]
             asset: match utxo.asset {
-                Asset::Explicit(asset) => Some(asset.to_hex()),
+                Asset::Explicit(asset) => Some(asset.to_string()),
                 _ => None,
             },
             #[cfg(feature = "liquid")]
@@ -426,7 +420,7 @@ impl From<Utxo> for UtxoValue {
             },
             #[cfg(feature = "liquid")]
             nonce: match utxo.nonce {
-                Nonce::Explicit(nonce) => Some(nonce.to_hex()),
+                Nonce::Explicit(nonce) => Some(nonce.to_string()),
                 _ => None,
             },
             #[cfg(feature = "liquid")]
@@ -639,7 +633,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_string(),
             TTL_SHORT,
         ),
 
@@ -651,7 +645,7 @@ fn handle_request(
 
         (&Method::GET, Some(&"blocks"), start_height, None, None, None) => {
             let start_height = start_height.and_then(|height| height.parse::<usize>().ok());
-            blocks(&query, &config, start_height)
+            blocks(&query, start_height)
         }
         (&Method::GET, Some(&"block-height"), Some(height), None, None, None) => {
             let height = height.parse::<usize>()?;
@@ -660,25 +654,25 @@ 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_string(), ttl)
         }
         (&Method::GET, Some(&"block"), Some(hash), None, None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = BlockHash::from_str(hash)?;
             let blockhm = query
                 .chain()
                 .get_block_with_meta(&hash)
                 .ok_or_else(|| HttpError::not_found("Block not found".to_string()))?;
-            let block_value = BlockValue::new(blockhm, config.network_type);
+            let block_value = BlockValue::new(blockhm);
             json_response(block_value, TTL_LONG)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"status"), None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = BlockHash::from_str(hash)?;
             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 = BlockHash::from_str(hash)?;
             let txids = query
                 .chain()
                 .get_block_txids(&hash)
@@ -686,7 +680,7 @@ fn handle_request(
             json_response(txids, TTL_LONG)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"header"), None, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = BlockHash::from_str(hash)?;
             let header = query
                 .chain()
                 .get_block_header(&hash)
@@ -696,7 +690,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 = BlockHash::from_str(hash)?;
             let raw = query
                 .chain()
                 .get_block_raw(&hash)
@@ -710,7 +704,7 @@ fn handle_request(
                 .unwrap())
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"txid"), Some(index), None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = BlockHash::from_str(hash)?;
             let index: usize = index.parse()?;
             let txids = query
                 .chain()
@@ -719,10 +713,10 @@ 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_string(), TTL_LONG)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"txs"), start_index, None) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = BlockHash::from_str(hash)?;
             let txids = query
                 .chain()
                 .get_block_txids(&hash)
@@ -830,7 +824,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::from_str(txid).ok());
 
             let txs = query
                 .chain()
@@ -906,7 +900,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 = Txid::from_str(hash)?;
             let tx = query
                 .lookup_txn(&hash)
                 .ok_or_else(|| HttpError::not_found("Transaction not found".to_string()))?;
@@ -919,7 +913,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 = Txid::from_str(hash)?;
             let rawtx = query
                 .lookup_raw_txn(&hash)
                 .ok_or_else(|| HttpError::not_found("Transaction not found".to_string()))?;
@@ -939,20 +933,20 @@ fn handle_request(
                 .unwrap())
         }
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"status"), None, None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = Txid::from_str(hash)?;
             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 = Txid::from_str(hash)?;
             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 }),
@@ -961,7 +955,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 = Txid::from_str(hash)?;
 
             let merkleblock = query.chain().get_merkleblock_proof(&hash).ok_or_else(|| {
                 HttpError::not_found("Transaction not found or is unconfirmed".to_string())
@@ -978,7 +972,7 @@ fn handle_request(
             )
         }
         (&Method::GET, Some(&"tx"), Some(hash), Some(&"outspend"), Some(index), None) => {
-            let hash = Txid::from_hex(hash)?;
+            let hash = Txid::from_str(hash)?;
             let outpoint = OutPoint {
                 txid: hash,
                 vout: index.parse::<u32>()?,
@@ -996,7 +990,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 = Txid::from_str(hash)?;
             let tx = query
                 .lookup_txn(&hash)
                 .ok_or_else(|| HttpError::not_found("Transaction not found".to_string()))?;
@@ -1023,7 +1017,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_string(), 0)
         }
 
         (&Method::GET, Some(&"mempool"), None, None, None, None) => {
@@ -1070,7 +1064,7 @@ fn handle_request(
 
         #[cfg(feature = "liquid")]
         (&Method::GET, Some(&"asset"), Some(asset_str), None, None, None) => {
-            let asset_id = AssetId::from_hex(asset_str)?;
+            let asset_id = AssetId::from_str(asset_str)?;
             let asset_entry = query
                 .lookup_asset(&asset_id)?
                 .ok_or_else(|| HttpError::not_found("Asset id not found".to_string()))?;
@@ -1080,7 +1074,7 @@ fn handle_request(
 
         #[cfg(feature = "liquid")]
         (&Method::GET, Some(&"asset"), Some(asset_str), Some(&"txs"), None, None) => {
-            let asset_id = AssetId::from_hex(asset_str)?;
+            let asset_id = AssetId::from_str(asset_str)?;
 
             let mut txs = vec![];
 
@@ -1112,8 +1106,8 @@ fn handle_request(
             Some(&"chain"),
             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 asset_id = AssetId::from_str(asset_str)?;
+            let last_seen_txid = last_seen_txid.and_then(|txid| Txid::from_str(txid).ok());
 
             let txs = query
                 .chain()
@@ -1127,7 +1121,7 @@ fn handle_request(
 
         #[cfg(feature = "liquid")]
         (&Method::GET, Some(&"asset"), Some(asset_str), Some(&"txs"), Some(&"mempool"), None) => {
-            let asset_id = AssetId::from_hex(asset_str)?;
+            let asset_id = AssetId::from_str(asset_str)?;
 
             let txs = query
                 .mempool()
@@ -1141,7 +1135,7 @@ fn handle_request(
 
         #[cfg(feature = "liquid")]
         (&Method::GET, Some(&"asset"), Some(asset_str), Some(&"supply"), param, None) => {
-            let asset_id = AssetId::from_hex(asset_str)?;
+            let asset_id = AssetId::from_str(asset_str)?;
             let asset_entry = query
                 .lookup_asset(&asset_id)?
                 .ok_or_else(|| HttpError::not_found("Asset id not found".to_string()))?;
@@ -1187,11 +1181,7 @@ fn json_response<T: Serialize>(value: T, ttl: u32) -> Result<Response<Body>, Htt
         .unwrap())
 }
 
-fn blocks(
-    query: &Query,
-    config: &Config,
-    start_height: Option<usize>,
-) -> Result<Response<Body>, HttpError> {
+fn blocks(query: &Query, start_height: Option<usize>) -> Result<Response<Body>, HttpError> {
     let mut values = Vec::new();
     let mut current_hash = match start_height {
         Some(height) => *query
@@ -1211,7 +1201,7 @@ fn blocks(
         current_hash = blockhm.header_entry.header().prev_blockhash;
 
         #[allow(unused_mut)]
-        let mut value = BlockValue::new(blockhm, config.network_type);
+        let mut value = BlockValue::new(blockhm);
 
         #[cfg(feature = "liquid")]
         {
@@ -1246,15 +1236,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))
-    };
+    let is_expected_net = addr.is_valid_for_network(network.into());
 
     #[cfg(feature = "liquid")]
     let is_expected_net = addr.params == network.address_params();
@@ -1263,6 +1245,9 @@ fn address_to_scripthash(addr: &str, network: Network) -> Result<FullHash, HttpE
         bail!(HttpError::from("Address on invalid network".to_string()))
     }
 
+    #[cfg(not(feature = "liquid"))]
+    let addr = addr.assume_checked();
+
     Ok(compute_script_hash(&addr.script_pubkey()))
 }
 
@@ -1313,8 +1298,8 @@ impl From<bitcoin::hashes::hex::Error> for HttpError {
         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::Error> for HttpError {
+    fn from(_e: bitcoin::address::Error) -> Self {
         //HttpError::from(e.description().to_string())
         HttpError::from("Invalid Bitcoin address".to_string())
     }
diff --git a/src/util/block.rs b/src/util/block.rs
index 1f6b98508..2157beb19 100644
--- a/src/util/block.rs
+++ b/src/util/block.rs
@@ -11,6 +11,13 @@ use time::OffsetDateTime as DateTime;
 
 const MTP_SPAN: usize = 11;
 
+lazy_static! {
+    pub static ref DEFAULT_BLOCKHASH: BlockHash =
+        "0000000000000000000000000000000000000000000000000000000000000000"
+            .parse()
+            .unwrap();
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct BlockId {
     pub height: usize,
@@ -73,7 +80,7 @@ impl HeaderList {
         HeaderList {
             headers: vec![],
             heights: HashMap::new(),
-            tip: BlockHash::default(),
+            tip: *DEFAULT_BLOCKHASH,
         }
     }
 
@@ -89,9 +96,8 @@ impl HeaderList {
 
         let mut blockhash = tip_hash;
         let mut headers_chain: Vec<BlockHeader> = vec![];
-        let null_hash = BlockHash::default();
 
-        while blockhash != null_hash {
+        while blockhash != *DEFAULT_BLOCKHASH {
             let header = headers_map.remove(&blockhash).unwrap_or_else(|| {
                 panic!(
                     "missing expected blockhash in headers map: {:?}, pointed from: {:?}",
@@ -136,8 +142,7 @@ impl HeaderList {
             Some(h) => h.header.prev_blockhash,
             None => return vec![], // hashed_headers is empty
         };
-        let null_hash = BlockHash::default();
-        let new_height: usize = if prev_blockhash == null_hash {
+        let new_height: usize = if prev_blockhash == *DEFAULT_BLOCKHASH {
             0
         } else {
             self.header_by_blockhash(&prev_blockhash)
@@ -170,7 +175,7 @@ impl HeaderList {
                 let expected_prev_blockhash = if height > 0 {
                     *self.headers[height - 1].hash()
                 } else {
-                    BlockHash::default()
+                    *DEFAULT_BLOCKHASH
                 };
                 assert_eq!(entry.header().prev_blockhash, expected_prev_blockhash);
                 height
@@ -216,7 +221,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(*DEFAULT_BLOCKHASH)
         );
         &self.tip
     }
@@ -294,7 +302,10 @@ 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,
+            // To retain DB compatibility, block weights are converted from the u64
+            // representation used as of rust-bitcoin v0.30 back to a u32. This is OK
+            // because u32::MAX is far above MAX_BLOCK_WEIGHT.
+            weight: b.block.weight().to_wu() as u32,
             size: b.size,
         }
     }
diff --git a/src/util/fees.rs b/src/util/fees.rs
index 828be6cd1..b9c768cf7 100644
--- a/src/util/fees.rs
+++ b/src/util/fees.rs
@@ -1,23 +1,24 @@
 use crate::chain::{Network, Transaction, TxOut};
 use std::collections::HashMap;
 
-const VSIZE_BIN_WIDTH: u32 = 50_000; // in vbytes
+const VSIZE_BIN_WIDTH: u64 = 50_000; // in vbytes
 
 pub struct TxFeeInfo {
     pub fee: u64,   // in satoshis
-    pub vsize: u32, // in virtual bytes (= weight/4)
-    pub fee_per_vbyte: f32,
+    pub vsize: u64, // in virtual bytes (= weight/4)
+    pub fee_per_vbyte: f64,
 }
 
 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_ceil();
+        let vsize_float = tx.weight().to_wu() as f64 / 4f64; // for more accurate sat/vB
 
         TxFeeInfo {
             fee,
-            vsize: vsize as u32,
-            fee_per_vbyte: fee as f32 / vsize as f32,
+            vsize,
+            fee_per_vbyte: fee as f64 / vsize_float,
         }
     }
 }
@@ -38,7 +39,7 @@ pub fn get_tx_fee(tx: &Transaction, _prevouts: &HashMap<u32, &TxOut>, network: N
     tx.fee_in(*network.native_asset())
 }
 
-pub fn make_fee_histogram(mut entries: Vec<&TxFeeInfo>) -> Vec<(f32, u32)> {
+pub fn make_fee_histogram(mut entries: Vec<&TxFeeInfo>) -> Vec<(f64, u64)> {
     entries.sort_unstable_by(|e1, e2| e1.fee_per_vbyte.partial_cmp(&e2.fee_per_vbyte).unwrap());
 
     let mut histogram = vec![];
diff --git a/src/util/mod.rs b/src/util/mod.rs
index 233e3efea..c0d8534b0 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -5,7 +5,9 @@ mod transaction;
 pub mod electrum_merkle;
 pub mod fees;
 
-pub use self::block::{BlockHeaderMeta, BlockId, BlockMeta, BlockStatus, HeaderEntry, HeaderList};
+pub use self::block::{
+    BlockHeaderMeta, BlockId, BlockMeta, BlockStatus, HeaderEntry, HeaderList, DEFAULT_BLOCKHASH,
+};
 pub use self::fees::get_tx_fee;
 pub use self::script::{get_innerscripts, ScriptToAddr, ScriptToAsm};
 pub use self::transaction::{
@@ -135,35 +137,34 @@ pub fn create_socket(addr: &SocketAddr) -> Socket {
 /// The module is compatible with the serde attribute.
 ///
 /// 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 bhex::{DisplayHex, FromHex};
     use serde::de::Error;
     use serde::{Deserializer, Serializer};
 
     pub fn serialize<S: Serializer>(b: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
-        s.serialize_str(&b.to_hex())
+        s.serialize_str(&b.to_lower_hex_string())
     }
 
     pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
         let hex_str: String = ::serde::Deserialize::deserialize(d)?;
-        Ok(FromHex::from_hex(&hex_str).map_err(D::Error::custom)?)
+        Ok(Vec::from_hex(&hex_str).map_err(D::Error::custom)?)
     }
 
     pub mod opt {
-        use bitcoin::hashes::hex::{FromHex, ToHex};
-        use serde::de::Error;
-        use serde::{Deserializer, Serializer};
+        use super::*;
 
         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(&b.to_lower_hex_string()),
             }
         }
 
         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(Vec::from_hex(&hex_str).map_err(D::Error::custom)?))
         }
     }
 }
diff --git a/src/util/script.rs b/src/util/script.rs
index 61be03e65..edca3a737 100644
--- a/src/util/script.rs
+++ b/src/util/script.rs
@@ -15,7 +15,7 @@ pub trait ScriptToAsm: std::fmt::Debug {
         (&asm[7..asm.len() - 1]).to_string()
     }
 }
-impl ScriptToAsm for bitcoin::Script {}
+impl ScriptToAsm for bitcoin::ScriptBuf {}
 #[cfg(feature = "liquid")]
 impl ScriptToAsm for elements::Script {}
 
@@ -25,7 +25,9 @@ pub trait ScriptToAddr {
 #[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())
+        bitcoin::Address::from_script(self, network.into())
+            .map(|s| s.to_string())
+            .ok()
     }
 }
 #[cfg(feature = "liquid")]
@@ -41,7 +43,7 @@ pub fn get_innerscripts(txin: &TxIn, prevout: &TxOut) -> InnerScripts {
     // 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(redeemscript.as_bytes().to_vec()))
         } else {
             None
         }

From 9b34b24d49f6339304c35bfed7d26d00c2cb3994 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Tue, 15 Aug 2023 20:13:08 +0300
Subject: [PATCH 2/8] Update rust-elements to v0.23.0

Some REST API structs were changed to hold the underlying data type
directly (instead of unnecessary manual ToHex conversion, which is no
longer available in rust-bitcoin), but their JSON serialization should
remain unchanged.
---
 Cargo.lock                | 175 ++++++++------------------------------
 Cargo.toml                |   2 +-
 src/chain.rs              |  12 ++-
 src/elements/asset.rs     |  17 ++--
 src/elements/mod.rs       |  20 ++---
 src/elements/peg.rs       |  21 +++--
 src/elements/registry.rs  |   4 +-
 src/new_index/precache.rs |   8 +-
 src/rest.rs               |  33 ++++---
 src/util/block.rs         |   6 +-
 src/util/fees.rs          |  16 ++--
 src/util/script.rs        |   4 +-
 src/util/transaction.rs   |  13 +--
 13 files changed, 128 insertions(+), 203 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d2a50dd3e..77cb96aa4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -55,15 +55,6 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "autocfg"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dde43e75fd43e8a1bf86103336bc699aa8d17ad1be60c76c0bdfd4828e19b78"
-dependencies = [
- "autocfg 1.1.0",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -152,18 +143,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "bitcoin"
-version = "0.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42b2a9a8e3c7544f5ce2b475f2f56580a3102b37e0ee001558ad4faedcf56cf4"
-dependencies = [
- "bech32 0.8.1",
- "bitcoin_hashes 0.10.0",
- "secp256k1 0.22.1",
- "serde",
-]
-
 [[package]]
 name = "bitcoin"
 version = "0.30.1"
@@ -302,15 +281,6 @@ dependencies = [
  "vec_map",
 ]
 
-[[package]]
-name = "cloudabi"
-version = "0.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
-dependencies = [
- "bitflags",
-]
-
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.4"
@@ -338,7 +308,7 @@ version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1145cf131a2c6ba0615079ab6a638f7e1973ac9c2634fcbeaaad6114246efe8c"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
  "cfg-if",
  "crossbeam-utils",
  "lazy_static",
@@ -444,12 +414,11 @@ dependencies = [
 
 [[package]]
 name = "elements"
-version = "0.19.1"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c5ef61d480567b862631efcc22f704eeed7291dbf929ae008a8d5b7f5c4527"
+checksum = "686e85412860d3ac25988e55da4d65541714f1318bf10fd81711e08cbfdcf5b4"
 dependencies = [
- "bitcoin 0.28.0",
- "bitcoin_hashes 0.10.0",
+ "bitcoin 0.30.1",
  "secp256k1-zkp",
  "serde",
  "serde_json",
@@ -799,7 +768,7 @@ version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "327fa5b6a6940e4699ec49a9beae1ea4845c6bab9314e4f84ac68742139d8c53"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
  "scopeguard",
 ]
 
@@ -830,7 +799,7 @@ version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
 ]
 
 [[package]]
@@ -896,7 +865,7 @@ version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
  "num-traits",
 ]
 
@@ -906,7 +875,7 @@ version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
 ]
 
 [[package]]
@@ -1022,6 +991,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.37"
@@ -1086,31 +1061,23 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.6.5"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
- "autocfg 0.1.8",
  "libc",
  "rand_chacha",
- "rand_core 0.4.2",
- "rand_hc",
- "rand_isaac",
- "rand_jitter",
- "rand_os",
- "rand_pcg",
- "rand_xorshift",
- "winapi 0.3.9",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.1.1"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
- "autocfg 0.1.8",
- "rand_core 0.3.1",
+ "ppv-lite86",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -1129,65 +1096,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
 
 [[package]]
-name = "rand_hc"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4"
-dependencies = [
- "rand_core 0.3.1",
-]
-
-[[package]]
-name = "rand_isaac"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08"
-dependencies = [
- "rand_core 0.3.1",
-]
-
-[[package]]
-name = "rand_jitter"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b"
-dependencies = [
- "libc",
- "rand_core 0.4.2",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "rand_os"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
-dependencies = [
- "cloudabi",
- "fuchsia-cprng",
- "libc",
- "rand_core 0.4.2",
- "rdrand",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "rand_pcg"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
-dependencies = [
- "autocfg 0.1.8",
- "rand_core 0.4.2",
-]
-
-[[package]]
-name = "rand_xorshift"
-version = "0.1.1"
+name = "rand_core"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "rand_core 0.3.1",
+ "getrandom",
 ]
 
 [[package]]
@@ -1196,7 +1110,7 @@ version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd249e82c21598a9a426a4e00dd7adc1d640b22445ec8545feef801d1a74c221"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
  "crossbeam-deque",
  "either",
  "rayon-core",
@@ -1378,18 +1292,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "secp256k1"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26947345339603ae8395f68e2f3d85a6b0a8ddfe6315818e80b8504415099db0"
-dependencies = [
- "bitcoin_hashes 0.10.0",
- "rand 0.6.5",
- "secp256k1-sys 0.5.0",
- "serde",
-]
-
 [[package]]
 name = "secp256k1"
 version = "0.27.0"
@@ -1397,6 +1299,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "25996b82292a7a57ed3508f052cfff8640d38d32018784acd714758b43da9c8f"
 dependencies = [
  "bitcoin_hashes 0.12.0",
+ "rand 0.8.5",
  "secp256k1-sys 0.8.1",
  "serde",
 ]
@@ -1410,15 +1313,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "secp256k1-sys"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07b5b9d7322572e1f3aeed208668ce87789b3645dbb73082c5ce99a004103a35"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "secp256k1-sys"
 version = "0.8.1"
@@ -1430,24 +1324,25 @@ dependencies = [
 
 [[package]]
 name = "secp256k1-zkp"
-version = "0.6.0"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c724fda6aae465ed9a39320202bc6164e0adb3cdf9bc16d5af4be7eebaba75e5"
+checksum = "026efcdacb95ee6aae5cc19144dc1549973eac36a4972700c28493de1ee5d69f"
 dependencies = [
- "rand 0.6.5",
- "secp256k1 0.22.1",
+ "bitcoin-private",
+ "rand 0.8.5",
+ "secp256k1 0.27.0",
  "secp256k1-zkp-sys",
  "serde",
 ]
 
 [[package]]
 name = "secp256k1-zkp-sys"
-version = "0.6.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6f880412a627e79d3ce17355150ea1e0e76570efb7f0f70df51504cbe2582e3"
+checksum = "d03ab1ca75a18e1899e8d9b8d28b5998ae1ddcb42fec5956769718543293c723"
 dependencies = [
  "cc",
- "secp256k1-sys 0.5.0",
+ "secp256k1-sys 0.8.1",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index f3b5ccc43..d848ebf72 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ bitcoin = { version = "0.30.1", features = [ "serde" ] }
 clap = "2.33.3"
 crossbeam-channel = "0.5.0"
 dirs = "4.0.0"
-elements = { version = "0.19.1", features = [ "serde-feature" ], optional = true }
+elements = { version = "0.23.0", features = [ "serde" ], optional = true }
 error-chain = "0.12.4"
 glob = "0.3"
 hex = "0.4.2"
diff --git a/src/chain.rs b/src/chain.rs
index 3168a5be7..819cc5c06 100644
--- a/src/chain.rs
+++ b/src/chain.rs
@@ -1,7 +1,8 @@
 #[cfg(not(feature = "liquid"))] // use regular Bitcoin data structures
 pub use bitcoin::{
-    address, blockdata::block::Header as BlockHeader, blockdata::script, consensus::deserialize,
-    Block, BlockHash, OutPoint, ScriptBuf as Script, Transaction, TxIn, TxOut, Txid,
+    absolute::LockTime as AbsLockTime, address, blockdata::block::Header as BlockHeader,
+    blockdata::script, consensus::deserialize, Block, BlockHash, OutPoint, ScriptBuf as Script,
+    Sequence, Transaction, TxIn, TxOut, Txid,
 };
 
 #[cfg(feature = "liquid")]
@@ -9,7 +10,8 @@ pub use {
     crate::elements::asset,
     elements::{
         address, confidential, encode::deserialize, script, Address, AssetId, Block, BlockHash,
-        BlockHeader, OutPoint, Script, Transaction, TxIn, TxOut, Txid,
+        BlockHeader, LockTime as AbsLockTime, OutPoint, Script, Sequence, Transaction, TxIn, TxOut,
+        Txid,
     },
 };
 
@@ -147,6 +149,8 @@ pub fn bitcoin_genesis_hash(network: BNetwork) -> bitcoin::BlockHash {
 
 #[cfg(feature = "liquid")]
 pub fn liquid_genesis_hash(network: Network) -> elements::BlockHash {
+    use crate::util::DEFAULT_BLOCKHASH;
+
     lazy_static! {
         static ref LIQUID_GENESIS: BlockHash =
             "1466275836220db2944ca059a3a10ef6fd2ea684b0688d2c379296888a206003"
@@ -159,7 +163,7 @@ pub fn liquid_genesis_hash(network: Network) -> elements::BlockHash {
         // The genesis block for liquid regtest chains varies based on the chain configuration.
         // This instead uses an all zeroed-out hash, which doesn't matter in practice because its
         // only used for Electrum server discovery, which isn't active on regtest.
-        _ => Default::default(),
+        _ => *DEFAULT_BLOCKHASH,
     }
 }
 
diff --git a/src/elements/asset.rs b/src/elements/asset.rs
index f626996aa..8b88b3f5a 100644
--- a/src/elements/asset.rs
+++ b/src/elements/asset.rs
@@ -1,7 +1,7 @@
 use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, RwLock};
 
-use bitcoin::hashes::{hex::FromHex, sha256, Hash};
+use bitcoin::hashes::{sha256, Hash};
 use elements::confidential::{Asset, Value};
 use elements::encode::{deserialize, serialize};
 use elements::secp256k1_zkp::ZERO_TWEAK;
@@ -17,13 +17,16 @@ use crate::util::{full_hash, Bytes, FullHash, TransactionStatus, TxInput};
 
 lazy_static! {
     pub static ref NATIVE_ASSET_ID: AssetId =
-        AssetId::from_hex("6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d")
+        "6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d"
+            .parse()
             .unwrap();
     pub static ref NATIVE_ASSET_ID_TESTNET: AssetId =
-        AssetId::from_hex("144c654344aa716d6f3abcc1ca90e5641e4e2a7f633bc09fe3baf64585819a49")
+        "144c654344aa716d6f3abcc1ca90e5641e4e2a7f633bc09fe3baf64585819a49"
+            .parse()
             .unwrap();
     pub static ref NATIVE_ASSET_ID_REGTEST: AssetId =
-        AssetId::from_hex("5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225")
+        "5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225"
+            .parse()
             .unwrap();
 }
 
@@ -92,7 +95,7 @@ impl IssuedAsset {
         let reissuance_token = parse_asset_id(&asset.reissuance_token);
 
         let contract_hash = if issuance.asset_entropy != [0u8; 32] {
-            Some(ContractHash::from_inner(issuance.asset_entropy))
+            Some(ContractHash::from_byte_array(issuance.asset_entropy))
         } else {
             None
         };
@@ -271,7 +274,7 @@ fn index_tx_assets(
     for (txi_index, txi) in tx.input.iter().enumerate() {
         if let Some(pegin) = get_pegin_data(txi, network) {
             history.push((
-                pegin.asset.explicit().unwrap(),
+                pegin.asset,
                 TxHistoryInfo::Pegin(PeginInfo {
                     txid,
                     vin: txi_index as u16,
@@ -392,7 +395,7 @@ pub fn lookup_asset(
 }
 
 pub fn get_issuance_entropy(txin: &TxIn) -> Result<sha256::Midstate> {
-    if !txin.has_issuance {
+    if !txin.has_issuance() {
         bail!("input has no issuance");
     }
 
diff --git a/src/elements/mod.rs b/src/elements/mod.rs
index a73e4d0ea..33489c1cf 100644
--- a/src/elements/mod.rs
+++ b/src/elements/mod.rs
@@ -1,4 +1,4 @@
-use bitcoin::hashes::{hex::ToHex, Hash};
+use bitcoin::hashes::{sha256, Hash};
 use elements::secp256k1_zkp::ZERO_TWEAK;
 use elements::{confidential::Value, encode::serialize, issuance::ContractHash, AssetId, TxIn};
 
@@ -12,13 +12,13 @@ pub use registry::{AssetRegistry, AssetSorting};
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct IssuanceValue {
-    pub asset_id: String,
+    pub asset_id: AssetId,
     pub is_reissuance: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub asset_blinding_nonce: Option<String>,
+    pub asset_blinding_nonce: Option<elements::secp256k1_zkp::Tweak>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub contract_hash: Option<String>,
-    pub asset_entropy: String,
+    pub contract_hash: Option<ContractHash>,
+    pub asset_entropy: sha256::Midstate,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub assetamount: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -44,12 +44,12 @@ impl From<&TxIn> for IssuanceValue {
         };
 
         IssuanceValue {
-            asset_id: asset_id.to_hex(),
-            asset_entropy: asset_entropy.to_hex(),
-            contract_hash: contract_hash.map(|h| h.to_hex()),
+            asset_id,
+            asset_entropy,
+            contract_hash,
             is_reissuance,
             asset_blinding_nonce: if is_reissuance {
-                Some(hex::encode(issuance.asset_blinding_nonce.as_ref()))
+                Some(issuance.asset_blinding_nonce)
             } else {
                 None
             },
@@ -73,4 +73,4 @@ impl From<&TxIn> for IssuanceValue {
             },
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/elements/peg.rs b/src/elements/peg.rs
index 6efc074bd..69e7ad387 100644
--- a/src/elements/peg.rs
+++ b/src/elements/peg.rs
@@ -1,4 +1,3 @@
-use bitcoin::hashes::hex::ToHex;
 use elements::{confidential::Asset, PeginData, PegoutData, TxIn, TxOut};
 
 use crate::chain::{bitcoin_genesis_hash, BNetwork, Network};
@@ -8,7 +7,7 @@ pub fn get_pegin_data(txout: &TxIn, network: Network) -> Option<PeginData> {
     let pegged_asset_id = network.pegged_asset()?;
     txout
         .pegin_data()
-        .filter(|pegin| pegin.asset == Asset::Explicit(*pegged_asset_id))
+        .filter(|pegin| pegin.asset == *pegged_asset_id)
 }
 
 pub fn get_pegout_data(
@@ -23,14 +22,14 @@ pub fn get_pegout_data(
     })
 }
 
-// API representation of pegout data assocaited with an output
-#[derive(Serialize, Deserialize, Clone)]
+// API representation of pegout data associated with an output
+#[derive(Serialize, Clone)]
 pub struct PegoutValue {
-    pub genesis_hash: String,
-    pub scriptpubkey: bitcoin::Script,
+    pub genesis_hash: bitcoin::BlockHash,
+    pub scriptpubkey: bitcoin::ScriptBuf,
     pub scriptpubkey_asm: String,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub scriptpubkey_address: Option<String>,
+    pub scriptpubkey_address: Option<bitcoin::Address>,
 }
 
 impl PegoutValue {
@@ -38,13 +37,13 @@ impl PegoutValue {
         let pegoutdata = get_pegout_data(txout, network, parent_network)?;
 
         // pending https://github.com/ElementsProject/rust-elements/pull/69 is merged
-        let scriptpubkey = bitcoin::Script::from(pegoutdata.script_pubkey.into_bytes());
-        let address = bitcoin::Address::from_script(&scriptpubkey, parent_network);
+        let scriptpubkey = pegoutdata.script_pubkey;
+        let address = bitcoin::Address::from_script(&scriptpubkey, parent_network).ok();
 
         Some(PegoutValue {
-            genesis_hash: pegoutdata.genesis_hash.to_hex(),
+            genesis_hash: pegoutdata.genesis_hash,
             scriptpubkey_asm: scriptpubkey.to_asm(),
-            scriptpubkey_address: address.map(|s| s.to_string()),
+            scriptpubkey_address: address,
             scriptpubkey,
         })
     }
diff --git a/src/elements/registry.rs b/src/elements/registry.rs
index e0728320d..4a01f5a79 100644
--- a/src/elements/registry.rs
+++ b/src/elements/registry.rs
@@ -1,11 +1,11 @@
 use std::collections::HashMap;
+use std::str::FromStr;
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, SystemTime};
 use std::{cmp, fs, path, thread};
 
 use serde_json::Value as JsonValue;
 
-use bitcoin::hashes::hex::FromHex;
 use elements::AssetId;
 
 use crate::errors::*;
@@ -70,7 +70,7 @@ impl AssetRegistry {
                     continue;
                 }
 
-                let asset_id = AssetId::from_hex(
+                let asset_id = AssetId::from_str(
                     path.file_stem()
                         .unwrap() // cannot fail if extension() succeeded
                         .to_str()
diff --git a/src/new_index/precache.rs b/src/new_index/precache.rs
index 68b08fe90..c2ad4febd 100644
--- a/src/new_index/precache.rs
+++ b/src/new_index/precache.rs
@@ -63,9 +63,11 @@ fn to_scripthash(script_type: &str, script_str: &str) -> Result<FullHash> {
 }
 
 fn address_to_scripthash(addr: &str) -> Result<FullHash> {
-    let addr = Address::from_str(addr)
-        .chain_err(|| "invalid address")?
-        .assume_checked();
+    let addr = Address::from_str(addr).chain_err(|| "invalid address")?;
+
+    #[cfg(not(feature = "liquid"))]
+    let addr = addr.assume_checked();
+
     Ok(compute_script_hash(&addr.script_pubkey().as_bytes()))
 }
 
diff --git a/src/rest.rs b/src/rest.rs
index 05d2e956c..e8eef2bca 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -1,4 +1,7 @@
-use crate::chain::{address, BlockHash, Network, OutPoint, Script, Transaction, TxIn, TxOut, Txid};
+use crate::chain::{
+    address, AbsLockTime, BlockHash, Network, OutPoint, Script, Sequence, Transaction, TxIn, TxOut,
+    Txid,
+};
 use crate::config::Config;
 use crate::errors;
 use crate::new_index::{compute_script_hash, Query, SpendingInput, Utxo};
@@ -9,17 +12,18 @@ use crate::util::{
 };
 
 #[cfg(not(feature = "liquid"))]
-use {bitcoin::consensus::encode, std::str::FromStr};
+use bitcoin::consensus::encode;
 
-use bitcoin::blockdata;
 use bitcoin::hashes::Error as HashError;
 use hex::{self, FromHexError};
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Response, Server, StatusCode};
+use hyperlocal::UnixServerExt;
 use tokio::sync::oneshot;
 
-use hyperlocal::UnixServerExt;
 use std::fs;
+use std::str::FromStr;
+
 #[cfg(feature = "liquid")]
 use {
     crate::elements::{peg::PegoutValue, AssetSorting, IssuanceValue},
@@ -85,7 +89,10 @@ impl BlockValue {
         BlockValue {
             id: header.block_hash().to_string(),
             height: blockhm.header_entry.height() as u32,
+            #[cfg(not(feature = "liquid"))]
             version: header.version.to_consensus() as u32,
+            #[cfg(feature = "liquid")]
+            version: header.version,
             timestamp: header.time,
             tx_count: blockhm.meta.tx_count,
             size: blockhm.meta.size,
@@ -111,11 +118,11 @@ impl BlockValue {
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize)]
 struct TransactionValue {
     txid: Txid,
     version: u32,
-    locktime: bitcoin::absolute::LockTime,
+    locktime: AbsLockTime,
     vin: Vec<TxInValue>,
     vout: Vec<TxOutValue>,
     size: u32,
@@ -149,6 +156,10 @@ impl TransactionValue {
 
         let fee = get_tx_fee(&tx, &prevouts, config.network_type);
 
+        let weight = tx.weight();
+        #[cfg(not(feature = "liquid"))] // rust-bitcoin has a wrapper Weight type
+        let weight = weight.to_wu();
+
         TransactionValue {
             txid: tx.txid(),
             version: tx.version as u32,
@@ -156,14 +167,14 @@ impl TransactionValue {
             vin: vins,
             vout: vouts,
             size: tx.size() as u32,
-            weight: tx.weight().to_wu(),
+            weight: weight as u64,
             fee,
             status: Some(TransactionStatus::from(blockid)),
         }
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Clone)]
 struct TxInValue {
     txid: Txid,
     vout: u32,
@@ -173,7 +184,7 @@ struct TxInValue {
     #[serde(skip_serializing_if = "Option::is_none")]
     witness: Option<Vec<String>>,
     is_coinbase: bool,
-    sequence: blockdata::transaction::Sequence,
+    sequence: Sequence,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     inner_redeemscript_asm: Option<String>,
@@ -235,7 +246,7 @@ impl TxInValue {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Clone)]
 struct TxOutValue {
     scriptpubkey: Script,
     scriptpubkey_asm: String,
@@ -420,7 +431,7 @@ impl From<Utxo> for UtxoValue {
             },
             #[cfg(feature = "liquid")]
             nonce: match utxo.nonce {
-                Nonce::Explicit(nonce) => Some(nonce.to_string()),
+                Nonce::Explicit(nonce) => Some(hex::encode(&nonce)),
                 _ => None,
             },
             #[cfg(feature = "liquid")]
diff --git a/src/util/block.rs b/src/util/block.rs
index 2157beb19..18dc91c27 100644
--- a/src/util/block.rs
+++ b/src/util/block.rs
@@ -300,12 +300,16 @@ pub struct BlockHeaderMeta {
 
 impl From<&BlockEntry> for BlockMeta {
     fn from(b: &BlockEntry) -> BlockMeta {
+        let weight = b.block.weight();
+        #[cfg(not(feature = "liquid"))] // rust-bitcoin has a wrapper Weight type
+        let weight = weight.to_wu();
+
         BlockMeta {
             tx_count: b.block.txdata.len() as u32,
             // To retain DB compatibility, block weights are converted from the u64
             // representation used as of rust-bitcoin v0.30 back to a u32. This is OK
             // because u32::MAX is far above MAX_BLOCK_WEIGHT.
-            weight: b.block.weight().to_wu() as u32,
+            weight: weight as u32,
             size: b.size,
         }
     }
diff --git a/src/util/fees.rs b/src/util/fees.rs
index b9c768cf7..164b9c133 100644
--- a/src/util/fees.rs
+++ b/src/util/fees.rs
@@ -4,20 +4,24 @@ use std::collections::HashMap;
 const VSIZE_BIN_WIDTH: u64 = 50_000; // in vbytes
 
 pub struct TxFeeInfo {
-    pub fee: u64,   // in satoshis
-    pub vsize: u64, // in virtual bytes (= weight/4)
-    pub fee_per_vbyte: f64,
+    pub fee: u64,           // in satoshis
+    pub vsize: u64,         // in virtual bytes (= weight/4)
+    pub fee_per_vbyte: f64, // in sat/vb
 }
 
 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().to_vbytes_ceil();
-        let vsize_float = tx.weight().to_wu() as f64 / 4f64; // for more accurate sat/vB
+
+        let weight = tx.weight();
+        #[cfg(not(feature = "liquid"))] // rust-bitcoin has a wrapper Weight type
+        let weight = weight.to_wu();
+
+        let vsize_float = weight as f64 / 4f64; // for more accurate sat/vB
 
         TxFeeInfo {
             fee,
-            vsize,
+            vsize: vsize_float.ceil() as u64,
             fee_per_vbyte: fee as f64 / vsize_float,
         }
     }
diff --git a/src/util/script.rs b/src/util/script.rs
index edca3a737..f7a2a65f3 100644
--- a/src/util/script.rs
+++ b/src/util/script.rs
@@ -43,7 +43,9 @@ pub fn get_innerscripts(txin: &TxIn, prevout: &TxOut) -> InnerScripts {
     // 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.as_bytes().to_vec()))
+            #[cfg(not(feature = "liquid"))] // rust-bitcoin has a PushBytes wrapper type
+            let redeemscript = redeemscript.as_bytes();
+            Some(Script::from(redeemscript.to_vec()))
         } else {
             None
         }
diff --git a/src/util/transaction.rs b/src/util/transaction.rs
index ec0c28a6b..dda5e4f7c 100644
--- a/src/util/transaction.rs
+++ b/src/util/transaction.rs
@@ -3,18 +3,19 @@ use crate::util::BlockId;
 
 use std::collections::HashMap;
 
-#[cfg(feature = "liquid")]
-use bitcoin::hashes::hex::FromHex;
-
 #[cfg(feature = "liquid")]
 lazy_static! {
     static ref REGTEST_INITIAL_ISSUANCE_PREVOUT: Txid =
-        Txid::from_hex("50cdc410c9d0d61eeacc531f52d2c70af741da33af127c364e52ac1ee7c030a5").unwrap();
+        "50cdc410c9d0d61eeacc531f52d2c70af741da33af127c364e52ac1ee7c030a5"
+            .parse()
+            .unwrap();
     static ref TESTNET_INITIAL_ISSUANCE_PREVOUT: Txid =
-        Txid::from_hex("0c52d2526a5c9f00e9fb74afd15dd3caaf17c823159a514f929ae25193a43a52").unwrap();
+        "0c52d2526a5c9f00e9fb74afd15dd3caaf17c823159a514f929ae25193a43a52"
+            .parse()
+            .unwrap();
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct TransactionStatus {
     pub confirmed: bool,
     #[serde(skip_serializing_if = "Option::is_none")]

From e251b43587bdd4a2b84986f4837a91ebde0762e5 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Fri, 18 Aug 2023 23:13:09 +0300
Subject: [PATCH 3/8] Simplify JSON serialization, remove use of 'hex' crate
 and 'serde_hex'

Use the underlying rust-bitcoin data types directly in more places to
avoid unnecessary manual JSON string serialization.

For cases where manual conversion is necessary, use the
'hex-conservative' crate (already dependant on by rust-bitcoin) instead
of the 'hex' crate, which is now removed.
---
 Cargo.lock                 |   1 -
 Cargo.toml                 |   3 +-
 src/bin/popular-scripts.rs |   9 ++-
 src/chain.rs               |   8 +--
 src/daemon.rs              |  14 ++--
 src/electrum/server.rs     |  25 ++++---
 src/elements/mod.rs        |  32 +++------
 src/new_index/precache.rs  |  10 ++-
 src/new_index/schema.rs    |  11 +--
 src/rest.rs                | 142 +++++++++++++------------------------
 src/util/mod.rs            |  37 ----------
 11 files changed, 99 insertions(+), 193 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 77cb96aa4..4c2ce8b81 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -368,7 +368,6 @@ dependencies = [
  "elements",
  "error-chain",
  "glob",
- "hex",
  "hex-conservative",
  "hyper",
  "hyperlocal",
diff --git a/Cargo.toml b/Cargo.toml
index d848ebf72..7c4d2da86 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ dirs = "4.0.0"
 elements = { version = "0.23.0", features = [ "serde" ], optional = true }
 error-chain = "0.12.4"
 glob = "0.3"
-hex = "0.4.2"
+hex = { package = "hex-conservative", version = "0.1.1" }
 itertools = "0.10"
 lazy_static = "1.3.0"
 libc = "0.2.81"
@@ -55,7 +55,6 @@ hyper = "0.14"
 hyperlocal = "0.8"
 # close to same tokio version as dependent by hyper v0.14 and hyperlocal 0.8 -- things can go awry if they mismatch
 tokio = { version = "1", features = ["sync", "macros"] }
-bhex = { package = "hex-conservative", version = "0.1.1" }
 
 # optional dependencies for electrum-discovery
 electrum-client = { version = "0.8", optional = true }
diff --git a/src/bin/popular-scripts.rs b/src/bin/popular-scripts.rs
index 3c75e3e35..0f0976449 100644
--- a/src/bin/popular-scripts.rs
+++ b/src/bin/popular-scripts.rs
@@ -5,6 +5,7 @@ use electrs::{
     config::Config,
     new_index::{Store, TxHistoryKey},
 };
+use hex::DisplayHex;
 
 fn main() {
     let config = Config::from_args();
@@ -30,7 +31,11 @@ fn main() {
 
         if curr_scripthash != entry.hash {
             if total_entries > 100 {
-                println!("{} {}", hex::encode(&curr_scripthash), total_entries);
+                println!(
+                    "{} {}",
+                    curr_scripthash.to_lower_hex_string(),
+                    total_entries
+                );
             }
 
             curr_scripthash = entry.hash;
@@ -45,7 +50,7 @@ fn main() {
     if total_entries >= 4000 {
         println!(
             "scripthash,{},{}",
-            hex::encode(&curr_scripthash),
+            curr_scripthash.to_lower_hex_string(),
             total_entries
         );
     }
diff --git a/src/chain.rs b/src/chain.rs
index 819cc5c06..b03f234c8 100644
--- a/src/chain.rs
+++ b/src/chain.rs
@@ -1,8 +1,8 @@
 #[cfg(not(feature = "liquid"))] // use regular Bitcoin data structures
 pub use bitcoin::{
     absolute::LockTime as AbsLockTime, address, blockdata::block::Header as BlockHeader,
-    blockdata::script, consensus::deserialize, Block, BlockHash, OutPoint, ScriptBuf as Script,
-    Sequence, Transaction, TxIn, TxOut, Txid,
+    blockdata::script, consensus::deserialize, hash_types::TxMerkleNode, Block, BlockHash,
+    OutPoint, ScriptBuf as Script, Sequence, Transaction, TxIn, TxOut, Txid,
 };
 
 #[cfg(feature = "liquid")]
@@ -10,8 +10,8 @@ pub use {
     crate::elements::asset,
     elements::{
         address, confidential, encode::deserialize, script, Address, AssetId, Block, BlockHash,
-        BlockHeader, LockTime as AbsLockTime, OutPoint, Script, Sequence, Transaction, TxIn, TxOut,
-        Txid,
+        BlockHeader, LockTime as AbsLockTime, OutPoint, Script, Sequence, Transaction, TxIn,
+        TxMerkleNode, TxOut, Txid,
     },
 };
 
diff --git a/src/daemon.rs b/src/daemon.rs
index 497add9b2..5abdba80b 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -8,14 +8,14 @@ use std::time::Duration;
 
 use base64;
 use glob;
-use hex;
+use hex::FromHex;
 use itertools::Itertools;
 use serde_json::{from_str, from_value, Value};
 
 #[cfg(not(feature = "liquid"))]
-use bitcoin::consensus::encode::{deserialize, serialize};
+use bitcoin::consensus::encode::{deserialize, serialize_hex};
 #[cfg(feature = "liquid")]
-use elements::encode::{deserialize, serialize};
+use elements::encode::{deserialize, serialize_hex};
 
 use crate::chain::{Block, BlockHash, BlockHeader, Network, Transaction, Txid};
 use crate::metrics::{HistogramOpts, HistogramVec, Metrics};
@@ -41,7 +41,7 @@ fn header_from_value(value: Value) -> Result<BlockHeader> {
     let header_hex = value
         .as_str()
         .chain_err(|| format!("non-string header: {}", value))?;
-    let header_bytes = hex::decode(header_hex).chain_err(|| "non-hex header")?;
+    let header_bytes = Vec::from_hex(header_hex).chain_err(|| "non-hex header")?;
     Ok(
         deserialize(&header_bytes)
             .chain_err(|| format!("failed to parse header {}", header_hex))?,
@@ -50,13 +50,13 @@ fn header_from_value(value: Value) -> Result<BlockHeader> {
 
 fn block_from_value(value: Value) -> Result<Block> {
     let block_hex = value.as_str().chain_err(|| "non-string block")?;
-    let block_bytes = hex::decode(block_hex).chain_err(|| "non-hex block")?;
+    let block_bytes = Vec::from_hex(block_hex).chain_err(|| "non-hex block")?;
     Ok(deserialize(&block_bytes).chain_err(|| format!("failed to parse block {}", block_hex))?)
 }
 
 fn tx_from_value(value: Value) -> Result<Transaction> {
     let tx_hex = value.as_str().chain_err(|| "non-string tx")?;
-    let tx_bytes = hex::decode(tx_hex).chain_err(|| "non-hex tx")?;
+    let tx_bytes = Vec::from_hex(tx_hex).chain_err(|| "non-hex tx")?;
     Ok(deserialize(&tx_bytes).chain_err(|| format!("failed to parse tx {}", tx_hex))?)
 }
 
@@ -518,7 +518,7 @@ impl Daemon {
     }
 
     pub fn broadcast(&self, tx: &Transaction) -> Result<Txid> {
-        self.broadcast_raw(&hex::encode(serialize(tx)))
+        self.broadcast_raw(&serialize_hex(tx))
     }
 
     pub fn broadcast_raw(&self, txhex: &str) -> Result<Txid> {
diff --git a/src/electrum/server.rs b/src/electrum/server.rs
index 30092bd28..939893b75 100644
--- a/src/electrum/server.rs
+++ b/src/electrum/server.rs
@@ -9,13 +9,13 @@ use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 use crypto::digest::Digest;
 use crypto::sha2::Sha256;
 use error_chain::ChainedError;
-use hex;
+use hex::{self, DisplayHex};
 use serde_json::{from_str, Value};
 
 #[cfg(not(feature = "liquid"))]
-use bitcoin::consensus::encode::serialize;
+use bitcoin::consensus::encode::serialize_hex;
 #[cfg(feature = "liquid")]
-use elements::encode::serialize;
+use elements::encode::serialize_hex;
 
 use crate::chain::Txid;
 use crate::config::Config;
@@ -25,8 +25,7 @@ use crate::metrics::{Gauge, HistogramOpts, HistogramVec, MetricOpts, Metrics};
 use crate::new_index::{Query, Utxo};
 use crate::util::electrum_merkle::{get_header_merkle_proof, get_id_from_pos, get_tx_merkle_proof};
 use crate::util::{
-    create_socket, full_hash, spawn_thread, BlockId, BoolThen, Channel, FullHash, HeaderEntry,
-    SyncChannel,
+    create_socket, spawn_thread, BlockId, BoolThen, Channel, FullHash, HeaderEntry, SyncChannel,
 };
 
 const ELECTRS_VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -129,7 +128,7 @@ impl Connection {
 
     fn blockchain_headers_subscribe(&mut self) -> Result<Value> {
         let entry = self.query.chain().best_header();
-        let hex_header = hex::encode(serialize(entry.header()));
+        let hex_header = serialize_hex(entry.header());
         let result = json!({"hex": hex_header, "height": entry.height()});
         self.last_header_entry = Some(entry);
         Ok(result)
@@ -201,7 +200,7 @@ impl Connection {
             .query
             .chain()
             .header_by_height(height)
-            .map(|entry| hex::encode(&serialize(entry.header())))
+            .map(|entry| serialize_hex(entry.header()))
             .chain_err(|| "missing header")?;
 
         if cp_height == 0 {
@@ -227,7 +226,7 @@ impl Connection {
                 self.query
                     .chain()
                     .header_by_height(height)
-                    .map(|entry| hex::encode(&serialize(entry.header())))
+                    .map(|entry| serialize_hex(entry.header()))
             })
             .collect();
 
@@ -272,7 +271,7 @@ impl Connection {
 
         let history_txids = get_history(&self.query, &script_hash[..], self.txs_limit)?;
         let status_hash = get_status_hash(history_txids, &self.query)
-            .map_or(Value::Null, |h| json!(hex::encode(full_hash(&h[..]))));
+            .map_or(Value::Null, |h| json!(h.to_lower_hex_string()));
 
         if let None = self.status_hashes.insert(script_hash, status_hash.clone()) {
             self.stats.subscriptions.inc();
@@ -359,11 +358,11 @@ impl Connection {
             bail!("verbose transactions are currently unsupported");
         }
 
-        let tx = self
+        let rawtx = self
             .query
             .lookup_raw_txn(&tx_hash)
             .chain_err(|| "missing transaction")?;
-        Ok(json!(hex::encode(tx)))
+        Ok(json!(rawtx.to_lower_hex_string()))
     }
 
     fn blockchain_transaction_get_merkle(&self, params: &[Value]) -> Result<Value> {
@@ -466,7 +465,7 @@ impl Connection {
             let entry = self.query.chain().best_header();
             if *last_entry != entry {
                 *last_entry = entry;
-                let hex_header = hex::encode(serialize(last_entry.header()));
+                let hex_header = serialize_hex(last_entry.header());
                 let header = json!({"hex": hex_header, "height": last_entry.height()});
                 result.push(json!({
                     "jsonrpc": "2.0",
@@ -477,7 +476,7 @@ impl Connection {
         for (script_hash, status_hash) in self.status_hashes.iter_mut() {
             let history_txids = get_history(&self.query, &script_hash[..], self.txs_limit)?;
             let new_status_hash = get_status_hash(history_txids, &self.query)
-                .map_or(Value::Null, |h| json!(hex::encode(full_hash(&h[..]))));
+                .map_or(Value::Null, |h| json!(h.to_lower_hex_string()));
             if new_status_hash == *status_hash {
                 continue;
             }
diff --git a/src/elements/mod.rs b/src/elements/mod.rs
index 33489c1cf..884284708 100644
--- a/src/elements/mod.rs
+++ b/src/elements/mod.rs
@@ -1,6 +1,6 @@
 use bitcoin::hashes::{sha256, Hash};
-use elements::secp256k1_zkp::ZERO_TWEAK;
-use elements::{confidential::Value, encode::serialize, issuance::ContractHash, AssetId, TxIn};
+use elements::secp256k1_zkp::{PedersenCommitment, Tweak, ZERO_TWEAK};
+use elements::{issuance::ContractHash, AssetId, TxIn};
 
 pub mod asset;
 pub mod peg;
@@ -15,18 +15,18 @@ pub struct IssuanceValue {
     pub asset_id: AssetId,
     pub is_reissuance: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub asset_blinding_nonce: Option<elements::secp256k1_zkp::Tweak>,
+    pub asset_blinding_nonce: Option<Tweak>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub contract_hash: Option<ContractHash>,
     pub asset_entropy: sha256::Midstate,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub assetamount: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub assetamountcommitment: Option<String>,
+    pub assetamountcommitment: Option<PedersenCommitment>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tokenamount: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub tokenamountcommitment: Option<String>,
+    pub tokenamountcommitment: Option<PedersenCommitment>,
 }
 
 impl From<&TxIn> for IssuanceValue {
@@ -53,24 +53,10 @@ impl From<&TxIn> for IssuanceValue {
             } else {
                 None
             },
-            assetamount: match issuance.amount {
-                Value::Explicit(value) => Some(value),
-                Value::Null => Some(0),
-                Value::Confidential(..) => None,
-            },
-            assetamountcommitment: match issuance.amount {
-                Value::Confidential(..) => Some(hex::encode(serialize(&issuance.amount))),
-                _ => None,
-            },
-            tokenamount: match issuance.inflation_keys {
-                Value::Explicit(value) => Some(value),
-                Value::Null => Some(0),
-                Value::Confidential(..) => None,
-            },
-            tokenamountcommitment: match issuance.inflation_keys {
-                Value::Confidential(..) => Some(hex::encode(serialize(&issuance.inflation_keys))),
-                _ => None,
-            },
+            assetamount: issuance.amount.explicit(),
+            assetamountcommitment: issuance.amount.commitment(),
+            tokenamount: issuance.inflation_keys.explicit(),
+            tokenamountcommitment: issuance.inflation_keys.commitment(),
         }
     }
 }
diff --git a/src/new_index/precache.rs b/src/new_index/precache.rs
index c2ad4febd..4db40c27d 100644
--- a/src/new_index/precache.rs
+++ b/src/new_index/precache.rs
@@ -1,13 +1,13 @@
 use crate::chain::address::Address;
 use crate::errors::*;
 use crate::new_index::ChainQuery;
-use crate::util::{full_hash, FullHash};
+use crate::util::FullHash;
 
 use crypto::digest::Digest;
 use crypto::sha2::Sha256;
 use rayon::prelude::*;
 
-use hex;
+use hex::FromHex;
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
@@ -52,11 +52,9 @@ pub fn scripthashes_from_file(path: String) -> Result<Vec<FullHash>> {
 fn to_scripthash(script_type: &str, script_str: &str) -> Result<FullHash> {
     match script_type {
         "address" => address_to_scripthash(script_str),
-        "scripthash" => Ok(full_hash(
-            &hex::decode(script_str).chain_err(|| "invalid hex")?,
-        )),
+        "scripthash" => Ok(FullHash::from_hex(script_str).chain_err(|| "invalid hex")?),
         "scriptpubkey" => Ok(compute_script_hash(
-            &hex::decode(script_str).chain_err(|| "invalid hex")?,
+            &Vec::from_hex(script_str).chain_err(|| "invalid hex")?,
         )),
         _ => bail!("Invalid script type".to_string()),
     }
diff --git a/src/new_index/schema.rs b/src/new_index/schema.rs
index 9a8e0bd40..800eabf12 100644
--- a/src/new_index/schema.rs
+++ b/src/new_index/schema.rs
@@ -4,6 +4,7 @@ use bitcoin::merkle_tree::MerkleBlock;
 use bitcoin::VarInt;
 use crypto::digest::Digest;
 use crypto::sha2::Sha256;
+use hex::FromHex;
 use itertools::Itertools;
 use rayon::prelude::*;
 
@@ -402,8 +403,9 @@ impl ChainQuery {
         let _timer = self.start_timer("get_block_raw");
 
         if self.light_mode {
-            let blockhex = self.daemon.getblock_raw(hash, 0).ok()?;
-            Some(hex::decode(blockhex.as_str().unwrap()).unwrap())
+            let blockval = self.daemon.getblock_raw(hash, 0).ok()?;
+            let blockhex = blockval.as_str().expect("valid block from bitcoind");
+            Some(Vec::from_hex(blockhex).expect("valid block from bitcoind"))
         } else {
             let entry = self.header_by_hash(hash)?;
             let meta = self.get_block_meta(hash)?;
@@ -833,11 +835,12 @@ impl ChainQuery {
                 blockhash.map_or_else(|| self.tx_confirming_block(txid).map(|b| b.hash), |_| None);
             let blockhash = blockhash.or_else(|| queried_blockhash.as_ref())?;
             // TODO fetch transaction as binary from REST API instead of as hex
-            let txhex = self
+            let txval = self
                 .daemon
                 .gettransaction_raw(txid, blockhash, false)
                 .ok()?;
-            Some(hex::decode(txhex.as_str().unwrap()).unwrap())
+            let txhex = txval.as_str().expect("valid tx from bitcoind");
+            Some(Bytes::from_hex(txhex).expect("valid tx from bitcoind"))
         } else {
             self.store.txstore_db.get(&TxRow::key(&txid[..]))
         }
diff --git a/src/rest.rs b/src/rest.rs
index e8eef2bca..ccd49dff6 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -1,21 +1,21 @@
 use crate::chain::{
-    address, AbsLockTime, BlockHash, Network, OutPoint, Script, Sequence, Transaction, TxIn, TxOut,
-    Txid,
+    address, AbsLockTime, BlockHash, Network, OutPoint, Script, Sequence, Transaction, TxIn,
+    TxMerkleNode, TxOut, Txid,
 };
 use crate::config::Config;
 use crate::errors;
 use crate::new_index::{compute_script_hash, Query, SpendingInput, Utxo};
 use crate::util::{
-    create_socket, electrum_merkle, extract_tx_prevouts, full_hash, get_innerscripts, get_tx_fee,
-    has_prevout, is_coinbase, BlockHeaderMeta, BlockId, FullHash, ScriptToAddr, ScriptToAsm,
-    TransactionStatus, DEFAULT_BLOCKHASH,
+    create_socket, electrum_merkle, extract_tx_prevouts, get_innerscripts, get_tx_fee, has_prevout,
+    is_coinbase, BlockHeaderMeta, BlockId, FullHash, ScriptToAddr, ScriptToAsm, TransactionStatus,
+    DEFAULT_BLOCKHASH,
 };
 
 #[cfg(not(feature = "liquid"))]
 use bitcoin::consensus::encode;
 
 use bitcoin::hashes::Error as HashError;
-use hex::{self, FromHexError};
+use hex::{DisplayHex, FromHex, HexToBytesError};
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Response, Server, StatusCode};
 use hyperlocal::UnixServerExt;
@@ -27,10 +27,7 @@ use std::str::FromStr;
 #[cfg(feature = "liquid")]
 use {
     crate::elements::{peg::PegoutValue, AssetSorting, IssuanceValue},
-    elements::{
-        confidential::{Asset, Nonce, Value},
-        encode, AssetId,
-    },
+    elements::{encode, secp256k1_zkp as zkp, AssetId},
 };
 
 use serde::Serialize;
@@ -59,15 +56,15 @@ const CONF_FINAL: usize = 10; // reorgs deeper than this are considered unlikely
 
 #[derive(Serialize, Deserialize)]
 struct BlockValue {
-    id: String,
+    id: BlockHash,
     height: u32,
     version: u32,
     timestamp: u32,
     tx_count: u32,
     size: u32,
     weight: u64,
-    merkle_root: String,
-    previousblockhash: Option<String>,
+    merkle_root: TxMerkleNode,
+    previousblockhash: Option<BlockHash>,
     mediantime: u32,
 
     #[cfg(not(feature = "liquid"))]
@@ -79,7 +76,7 @@ struct BlockValue {
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    ext: Option<serde_json::Value>,
+    ext: Option<elements::BlockExtData>,
 }
 
 impl BlockValue {
@@ -87,7 +84,7 @@ impl BlockValue {
     fn new(blockhm: BlockHeaderMeta) -> Self {
         let header = blockhm.header_entry.header();
         BlockValue {
-            id: header.block_hash().to_string(),
+            id: header.block_hash(),
             height: blockhm.header_entry.height() as u32,
             #[cfg(not(feature = "liquid"))]
             version: header.version.to_consensus() as u32,
@@ -97,9 +94,9 @@ impl BlockValue {
             tx_count: blockhm.meta.tx_count,
             size: blockhm.meta.size,
             weight: blockhm.meta.weight as u64,
-            merkle_root: header.merkle_root.to_string(),
+            merkle_root: header.merkle_root,
             previousblockhash: if header.prev_blockhash != *DEFAULT_BLOCKHASH {
-                Some(header.prev_blockhash.to_string())
+                Some(header.prev_blockhash)
             } else {
                 None
             },
@@ -113,7 +110,7 @@ impl BlockValue {
             difficulty: header.difficulty(),
 
             #[cfg(feature = "liquid")]
-            ext: Some(json!(header.ext)),
+            ext: Some(header.ext.clone()),
         }
     }
 }
@@ -205,7 +202,12 @@ impl TxInValue {
         let witness = &witness.script_witness;
 
         let witness = if !witness.is_empty() {
-            Some(witness.iter().map(hex::encode).collect())
+            Some(
+                witness
+                    .iter()
+                    .map(DisplayHex::to_lower_hex_string)
+                    .collect(),
+            )
         } else {
             None
         };
@@ -264,15 +266,15 @@ struct TxOutValue {
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    valuecommitment: Option<String>,
+    valuecommitment: Option<zkp::PedersenCommitment>,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    asset: Option<String>,
+    asset: Option<AssetId>,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    assetcommitment: Option<String>,
+    assetcommitment: Option<zkp::Generator>,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -283,25 +285,8 @@ impl TxOutValue {
     fn new(txout: &TxOut, config: &Config) -> Self {
         #[cfg(not(feature = "liquid"))]
         let value = txout.value;
-
         #[cfg(feature = "liquid")]
         let value = txout.value.explicit();
-        #[cfg(feature = "liquid")]
-        let valuecommitment = match txout.value {
-            Value::Confidential(..) => Some(hex::encode(encode::serialize(&txout.value))),
-            _ => None,
-        };
-
-        #[cfg(feature = "liquid")]
-        let asset = match txout.asset {
-            Asset::Explicit(value) => Some(value.to_string()),
-            _ => None,
-        };
-        #[cfg(feature = "liquid")]
-        let assetcommitment = match txout.asset {
-            Asset::Confidential(..) => Some(hex::encode(encode::serialize(&txout.asset))),
-            _ => None,
-        };
 
         #[cfg(not(feature = "liquid"))]
         let is_fee = false;
@@ -347,11 +332,11 @@ impl TxOutValue {
             scriptpubkey_type: script_type.to_string(),
             value,
             #[cfg(feature = "liquid")]
-            valuecommitment,
+            valuecommitment: txout.value.commitment(),
             #[cfg(feature = "liquid")]
-            asset,
+            asset: txout.asset.explicit(),
             #[cfg(feature = "liquid")]
-            assetcommitment,
+            assetcommitment: txout.asset.commitment(),
             #[cfg(feature = "liquid")]
             pegout,
         }
@@ -373,31 +358,28 @@ struct UtxoValue {
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    valuecommitment: Option<String>,
+    valuecommitment: Option<zkp::PedersenCommitment>,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    asset: Option<String>,
+    asset: Option<AssetId>,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    assetcommitment: Option<String>,
+    assetcommitment: Option<zkp::Generator>,
 
+    // nonces are never explicit
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    nonce: Option<String>,
+    noncecommitment: Option<zkp::PublicKey>,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    noncecommitment: Option<String>,
-
-    #[cfg(feature = "liquid")]
-    #[serde(skip_serializing_if = "Vec::is_empty", with = "crate::util::serde_hex")]
-    surjection_proof: Vec<u8>,
+    surjection_proof: Option<zkp::SurjectionProof>,
 
     #[cfg(feature = "liquid")]
-    #[serde(skip_serializing_if = "Vec::is_empty", with = "crate::util::serde_hex")]
-    range_proof: Vec<u8>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    range_proof: Option<zkp::RangeProof>,
 }
 impl From<Utxo> for UtxoValue {
     fn from(utxo: Utxo) -> Self {
@@ -410,42 +392,19 @@ impl From<Utxo> for UtxoValue {
             value: utxo.value,
 
             #[cfg(feature = "liquid")]
-            value: match utxo.value {
-                Value::Explicit(value) => Some(value),
-                _ => None,
-            },
-            #[cfg(feature = "liquid")]
-            valuecommitment: match utxo.value {
-                Value::Confidential(..) => Some(hex::encode(encode::serialize(&utxo.value))),
-                _ => None,
-            },
+            value: utxo.value.explicit(),
             #[cfg(feature = "liquid")]
-            asset: match utxo.asset {
-                Asset::Explicit(asset) => Some(asset.to_string()),
-                _ => None,
-            },
+            valuecommitment: utxo.value.commitment(),
             #[cfg(feature = "liquid")]
-            assetcommitment: match utxo.asset {
-                Asset::Confidential(..) => Some(hex::encode(encode::serialize(&utxo.asset))),
-                _ => None,
-            },
+            asset: utxo.asset.explicit(),
             #[cfg(feature = "liquid")]
-            nonce: match utxo.nonce {
-                Nonce::Explicit(nonce) => Some(hex::encode(&nonce)),
-                _ => None,
-            },
+            assetcommitment: utxo.asset.commitment(),
             #[cfg(feature = "liquid")]
-            noncecommitment: match utxo.nonce {
-                Nonce::Confidential(..) => Some(hex::encode(encode::serialize(&utxo.nonce))),
-                _ => None,
-            },
+            noncecommitment: utxo.nonce.commitment(),
             #[cfg(feature = "liquid")]
-            surjection_proof: utxo
-                .witness
-                .surjection_proof
-                .map_or(vec![], |p| (*p).serialize()),
+            surjection_proof: utxo.witness.surjection_proof.map(|p| *p),
             #[cfg(feature = "liquid")]
-            range_proof: utxo.witness.rangeproof.map_or(vec![], |p| (*p).serialize()),
+            range_proof: utxo.witness.rangeproof.map(|p| *p),
         }
     }
 }
@@ -697,7 +656,7 @@ fn handle_request(
                 .get_block_header(&hash)
                 .ok_or_else(|| HttpError::not_found("Block not found".to_string()))?;
 
-            let header_hex = hex::encode(encode::serialize(&header));
+            let header_hex = encode::serialize_hex(&header);
             http_message(StatusCode::OK, header_hex, TTL_LONG)
         }
         (&Method::GET, Some(&"block"), Some(hash), Some(&"raw"), None, None) => {
@@ -931,7 +890,7 @@ fn handle_request(
 
             let (content_type, body) = match *out_type {
                 "raw" => ("application/octet-stream", Body::from(rawtx)),
-                "hex" => ("text/plain", Body::from(hex::encode(rawtx))),
+                "hex" => ("text/plain", Body::from(rawtx.to_lower_hex_string())),
                 _ => unreachable!(),
             };
             let ttl = ttl_by_depth(query.get_tx_status(&hash).block_height, query);
@@ -978,7 +937,7 @@ fn handle_request(
 
             http_message(
                 StatusCode::OK,
-                hex::encode(encode::serialize(&merkleblock)),
+                encode::serialize_hex(&merkleblock),
                 ttl_by_depth(height, query),
             )
         }
@@ -1263,12 +1222,7 @@ fn address_to_scripthash(addr: &str, network: Network) -> Result<FullHash, HttpE
 }
 
 fn parse_scripthash(scripthash: &str) -> Result<FullHash, HttpError> {
-    let bytes = hex::decode(scripthash)?;
-    if bytes.len() != 32 {
-        Err(HttpError::from("Invalid scripthash".to_string()))
-    } else {
-        Ok(full_hash(&bytes))
-    }
+    FullHash::from_hex(scripthash).map_err(|_| HttpError::from("Invalid scripthash".to_string()))
 }
 
 #[derive(Debug)]
@@ -1297,8 +1251,8 @@ impl From<HashError> for HttpError {
         HttpError::from("Invalid hash string".to_string())
     }
 }
-impl From<FromHexError> for HttpError {
-    fn from(_e: FromHexError) -> Self {
+impl From<HexToBytesError> for HttpError {
+    fn from(_e: HexToBytesError) -> Self {
         //HttpError::from(e.description().to_string())
         HttpError::from("Invalid hex string".to_string())
     }
diff --git a/src/util/mod.rs b/src/util/mod.rs
index c0d8534b0..fbfaf7f97 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -131,40 +131,3 @@ pub fn create_socket(addr: &SocketAddr) -> Socket {
 
     socket
 }
-
-/// A module used for serde serialization of bytes in hexadecimal format.
-///
-/// The module is compatible with the serde attribute.
-///
-/// Copied from https://github.com/rust-bitcoin/rust-bitcoincore-rpc/blob/master/json/src/lib.rs
-
-pub mod serde_hex {
-    use bhex::{DisplayHex, FromHex};
-    use serde::de::Error;
-    use serde::{Deserializer, Serializer};
-
-    pub fn serialize<S: Serializer>(b: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
-        s.serialize_str(&b.to_lower_hex_string())
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
-        let hex_str: String = ::serde::Deserialize::deserialize(d)?;
-        Ok(Vec::from_hex(&hex_str).map_err(D::Error::custom)?)
-    }
-
-    pub mod opt {
-        use super::*;
-
-        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_lower_hex_string()),
-            }
-        }
-
-        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(Vec::from_hex(&hex_str).map_err(D::Error::custom)?))
-        }
-    }
-}

From 8fe41c005bf177ae90905f7b497efc8b0a323bc8 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Fri, 18 Aug 2023 23:51:44 +0300
Subject: [PATCH 4/8] Return difficulty as a float in `GET /block/:hash`

Made available in rust-bitcoin as of https://github.com/rust-bitcoin/rust-bitcoin/pull/1707
---
 src/rest.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/rest.rs b/src/rest.rs
index ccd49dff6..cbfa8d7b2 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -72,7 +72,7 @@ struct BlockValue {
     #[cfg(not(feature = "liquid"))]
     bits: bitcoin::pow::CompactTarget,
     #[cfg(not(feature = "liquid"))]
-    difficulty: u128,
+    difficulty: f64,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -107,7 +107,7 @@ impl BlockValue {
             #[cfg(not(feature = "liquid"))]
             nonce: header.nonce,
             #[cfg(not(feature = "liquid"))]
-            difficulty: header.difficulty(),
+            difficulty: header.difficulty_float(),
 
             #[cfg(feature = "liquid")]
             ext: Some(header.ext.clone()),

From 8206eb3f095bab235c6706439ed9cf4cfb42a498 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Thu, 31 Aug 2023 05:20:29 +0300
Subject: [PATCH 5/8] Add script for checking HTTP API stablity

---
 contrib/check-api-stablity.sh | 89 +++++++++++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 contrib/check-api-stablity.sh

diff --git a/contrib/check-api-stablity.sh b/contrib/check-api-stablity.sh
new file mode 100644
index 000000000..fe965d04b
--- /dev/null
+++ b/contrib/check-api-stablity.sh
@@ -0,0 +1,89 @@
+#!/bin/bash
+
+set -eo pipefail
+shopt -s expand_aliases 
+
+# A simple script for checking HTTP API stability by comparing the responses
+# between two running electrs instances connected to a regtest node backend.
+
+: ${NODE_DIR?missing NODE_DIR} # for bitcoind/elementds
+: ${ELECTRS1_URL?missing ELECTRS1_URL}
+: ${ELECTRS2_URL?missing ELECTRS2_URL}
+# Set ELEMENTS_CHAIN for Elements-based chains (e.g. to 'elementsregtest')
+
+alias cli="$([[ -z $ELEMENTS_CHAIN ]] && echo bitcoin-cli -regtest || echo elements-cli -chain=$ELEMENTS_CHAIN) -datadir=$NODE_DIR"
+
+check() {
+    echo "Checking GET $1 ..."
+    local res1=$(curl -f -s "$ELECTRS1_URL$1" || echo "Request to ELECTRS1 failed")
+    local res2=$(curl -f -s "$ELECTRS2_URL$1" || echo "Request to ELECTRS2 failed")
+    { if [[ "$res1" = "{"* || "$res1" = "["* ]]; then
+        # Use `jq` for canonicalized ordering and to display a diff of beautified JSON
+        diff -u1 <(jq --sort-keys <<< $res1) <(jq --sort-keys <<< $res2)
+    else
+        diff -u1 <(echo "$res1") <(echo "$res2")
+    fi } && echo OK || echo No match
+}
+
+sync() { pkill -USR1 electrs; sleep 1; }
+
+# Ensure both electrs instances are connected to the same node backend
+check /blocks/tip/hash
+
+# Send an unconfirmed transaction
+address=$(cli getnewaddress)
+txid=$(cli sendtoaddress $address 1.234)
+sync
+check /address/$address
+check /address/$address/txs
+check /address/$address/utxo
+check /tx/$txid
+check /mempool
+check /mempool/recent
+
+# Mine a block confirming the transaction
+blockhash=$(cli -generate 1 | jq -r .blocks[0])
+sync
+check /block/$blockhash
+check /block/$blockhash/txs
+check /blocks
+check /address/$address
+check /address/$address/txs
+check /address/$address/utxo
+check /tx/$txid
+
+# Elements-only tests
+if [[ -n $ELEMENTS_CHAIN ]]; then
+    # Test non-confidential transaction
+    uc_address=$(cli getaddressinfo $address | jq -r .unconfidential)
+    uc_txid=$(cli sendtoaddress $uc_address 5.678)
+    sync 
+    check /address/$uc_address
+    check /tx/$uc_txid
+
+    # Test asset issuance (blinded w/o contract hash & unblinded w/ contract hash)
+    asset1=$(cli issueasset 10 20 true)
+    asset2=$(cli issueasset 30 40 false 3333333333333333333333333333333333333333333333333333333333333333)
+    sync 
+    check_asset() {
+        check /asset/$(jq -r .asset <<< $1)
+        check /tx/$(jq -r .txid <<< $1) # issuance tx
+    }
+    check_asset "$asset1"
+    check_asset "$asset2"
+    cli -generate 1 > /dev/null
+    sync 
+    check_asset "$asset1"
+    check_asset "$asset2"
+
+    # Test transactions transferring an issued asset (confidential & non-confidential)
+    asset1_id=$(jq -r .asset <<< $asset1)
+    asset2_id=$(jq -r .asset <<< $asset2)
+    i_txid=$(cli    -named sendtoaddress address=$address    amount=0.987 assetlabel=$asset1_id)
+    i_uc_txid=$(cli -named sendtoaddress address=$uc_address amount=0.654 assetlabel=$asset2_id)
+    sync 
+    check /tx/$i_txid
+    check /tx/$i_uc_txid
+    check /address/$uc_address
+    check /address/$uc_address/utxo
+fi
\ No newline at end of file

From 95272ab31ae378c0af2150e5ecc146ac38b18595 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Thu, 31 Aug 2023 05:28:11 +0300
Subject: [PATCH 6/8] Change back to explicitly encode locktimes as a u32 in
 JSON responses

This matches the behavior of bitcoin::LockTime, however
elements::LockTime uses serde-json's tagged enum serialization format,
which broke API compatibility.

This was detected by the check-api-stablity script:

Checking GET /tx/f89e3ec661950493e833beeba13bcd80e907a56c5f0e9ab47dc4f0810488a8e8 ...
@@ -2,3 +2,5 @@
   "fee": 24910,
-  "locktime": 73,
+  "locktime": {
+    "Blocks": 73
+  },
   "size": 8942,
---
 src/chain.rs | 9 ++++-----
 src/rest.rs  | 8 ++++----
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/chain.rs b/src/chain.rs
index b03f234c8..737244efe 100644
--- a/src/chain.rs
+++ b/src/chain.rs
@@ -1,8 +1,8 @@
 #[cfg(not(feature = "liquid"))] // use regular Bitcoin data structures
 pub use bitcoin::{
-    absolute::LockTime as AbsLockTime, address, blockdata::block::Header as BlockHeader,
-    blockdata::script, consensus::deserialize, hash_types::TxMerkleNode, Block, BlockHash,
-    OutPoint, ScriptBuf as Script, Sequence, Transaction, TxIn, TxOut, Txid,
+    address, blockdata::block::Header as BlockHeader, blockdata::script, consensus::deserialize,
+    hash_types::TxMerkleNode, Block, BlockHash, OutPoint, ScriptBuf as Script, Sequence,
+    Transaction, TxIn, TxOut, Txid,
 };
 
 #[cfg(feature = "liquid")]
@@ -10,8 +10,7 @@ pub use {
     crate::elements::asset,
     elements::{
         address, confidential, encode::deserialize, script, Address, AssetId, Block, BlockHash,
-        BlockHeader, LockTime as AbsLockTime, OutPoint, Script, Sequence, Transaction, TxIn,
-        TxMerkleNode, TxOut, Txid,
+        BlockHeader, OutPoint, Script, Sequence, Transaction, TxIn, TxMerkleNode, TxOut, Txid,
     },
 };
 
diff --git a/src/rest.rs b/src/rest.rs
index cbfa8d7b2..c5ac02d8d 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -1,6 +1,6 @@
 use crate::chain::{
-    address, AbsLockTime, BlockHash, Network, OutPoint, Script, Sequence, Transaction, TxIn,
-    TxMerkleNode, TxOut, Txid,
+    address, BlockHash, Network, OutPoint, Script, Sequence, Transaction, TxIn, TxMerkleNode,
+    TxOut, Txid,
 };
 use crate::config::Config;
 use crate::errors;
@@ -119,7 +119,7 @@ impl BlockValue {
 struct TransactionValue {
     txid: Txid,
     version: u32,
-    locktime: AbsLockTime,
+    locktime: u32,
     vin: Vec<TxInValue>,
     vout: Vec<TxOutValue>,
     size: u32,
@@ -160,7 +160,7 @@ impl TransactionValue {
         TransactionValue {
             txid: tx.txid(),
             version: tx.version as u32,
-            locktime: tx.lock_time,
+            locktime: tx.lock_time.to_consensus_u32(),
             vin: vins,
             vout: vouts,
             size: tx.size() as u32,

From e46972dddf37179fa9c23798247cd7bc2bcc3edc Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Thu, 8 Feb 2024 12:55:21 +0200
Subject: [PATCH 7/8] Canonicalize JSON response arrays order in
 check-api-stablity

Without this, this would sometimes report false positives due to
non-deterministic array ordering in some of the endpoint (primarly
mempool-related).
---
 contrib/check-api-stablity.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/contrib/check-api-stablity.sh b/contrib/check-api-stablity.sh
index fe965d04b..0884c948a 100644
--- a/contrib/check-api-stablity.sh
+++ b/contrib/check-api-stablity.sh
@@ -19,7 +19,8 @@ check() {
     local res2=$(curl -f -s "$ELECTRS2_URL$1" || echo "Request to ELECTRS2 failed")
     { if [[ "$res1" = "{"* || "$res1" = "["* ]]; then
         # Use `jq` for canonicalized ordering and to display a diff of beautified JSON
-        diff -u1 <(jq --sort-keys <<< $res1) <(jq --sort-keys <<< $res2)
+        local sort_arr='walk(if type == "array" then sort else . end)'
+        diff -u1 <(jq --sort-keys "$sort_arr" <<< $res1) <(jq --sort-keys "$sort_arr" <<< $res2)
     else
         diff -u1 <(echo "$res1") <(echo "$res2")
     fi } && echo OK || echo No match

From 4a2d465f1704a71e531fd31eb9143aae82973a03 Mon Sep 17 00:00:00 2001
From: Nadav Ivgi <nadav@shesek.info>
Date: Thu, 8 Feb 2024 13:08:22 +0200
Subject: [PATCH 8/8] Add test to check-api-stablity

Of an issuance with no reissuance tokens,
following https://github.com/Blockstream/electrs/pull/59#pullrequestreview-1865515610.

Previously this was reported as 0 and now as None (serializes to JSON
without the field).
---
 contrib/check-api-stablity.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/contrib/check-api-stablity.sh b/contrib/check-api-stablity.sh
index 0884c948a..23e77b083 100644
--- a/contrib/check-api-stablity.sh
+++ b/contrib/check-api-stablity.sh
@@ -87,4 +87,7 @@ if [[ -n $ELEMENTS_CHAIN ]]; then
     check /tx/$i_uc_txid
     check /address/$uc_address
     check /address/$uc_address/utxo
+
+    # Test issuance with no reissuance tokens
+    check_asset "$(cli issueasset 10 0 false && sync)"
 fi
\ No newline at end of file