diff --git a/Cargo.lock b/Cargo.lock
index 7fef399bf..4c2ce8b81 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"
@@ -106,6 +97,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 +137,7 @@ version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a41df6ad9642c5c15ae312dd3d074de38fd3eb7cc87ad4ce10f90292a83fe4d"
 dependencies = [
- "bech32",
+ "bech32 0.8.1",
  "bitcoin_hashes 0.10.0",
  "secp256k1 0.20.3",
  "serde",
@@ -148,16 +145,24 @@ dependencies = [
 
 [[package]]
 name = "bitcoin"
-version = "0.28.0"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42b2a9a8e3c7544f5ce2b475f2f56580a3102b37e0ee001558ad4faedcf56cf4"
+checksum = "4e99ff7289b20a7385f66a0feda78af2fc119d28fb56aea8886a9cd0a4abdd75"
 dependencies = [
- "bech32",
- "bitcoin_hashes 0.10.0",
- "secp256k1 0.22.1",
+ "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 +178,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"
@@ -266,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"
@@ -302,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",
@@ -354,7 +360,7 @@ dependencies = [
  "arrayref",
  "base64 0.13.0",
  "bincode",
- "bitcoin 0.28.0",
+ "bitcoin 0.30.1",
  "clap",
  "crossbeam-channel",
  "dirs",
@@ -362,7 +368,7 @@ dependencies = [
  "elements",
  "error-chain",
  "glob",
- "hex",
+ "hex-conservative",
  "hyper",
  "hyperlocal",
  "itertools",
@@ -407,12 +413,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",
@@ -571,6 +576,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"
@@ -750,7 +767,7 @@ version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "327fa5b6a6940e4699ec49a9beae1ea4845c6bab9314e4f84ac68742139d8c53"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
  "scopeguard",
 ]
 
@@ -781,7 +798,7 @@ version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
 ]
 
 [[package]]
@@ -847,7 +864,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",
 ]
 
@@ -857,7 +874,7 @@ version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg",
 ]
 
 [[package]]
@@ -973,6 +990,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"
@@ -1037,31 +1060,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]]
@@ -1080,65 +1095,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]]
@@ -1147,7 +1109,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",
@@ -1331,13 +1293,13 @@ dependencies = [
 
 [[package]]
 name = "secp256k1"
-version = "0.22.1"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26947345339603ae8395f68e2f3d85a6b0a8ddfe6315818e80b8504415099db0"
+checksum = "25996b82292a7a57ed3508f052cfff8640d38d32018784acd714758b43da9c8f"
 dependencies = [
- "bitcoin_hashes 0.10.0",
- "rand 0.6.5",
- "secp256k1-sys 0.5.0",
+ "bitcoin_hashes 0.12.0",
+ "rand 0.8.5",
+ "secp256k1-sys 0.8.1",
  "serde",
 ]
 
@@ -1352,33 +1314,34 @@ dependencies = [
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.5.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07b5b9d7322572e1f3aeed208668ce87789b3645dbb73082c5ce99a004103a35"
+checksum = "70a129b9e9efbfb223753b9163c4ab3b13cff7fd9c7f010fbac25ab4099fa07e"
 dependencies = [
  "cc",
 ]
 
 [[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 7b8ec562c..7c4d2da86 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,14 +22,14 @@ 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"
-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"
+hex = { package = "hex-conservative", version = "0.1.1" }
 itertools = "0.10"
 lazy_static = "1.3.0"
 libc = "0.2.81"
diff --git a/contrib/check-api-stablity.sh b/contrib/check-api-stablity.sh
new file mode 100644
index 000000000..23e77b083
--- /dev/null
+++ b/contrib/check-api-stablity.sh
@@ -0,0 +1,93 @@
+#!/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
+        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
+}
+
+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
+
+    # Test issuance with no reissuance tokens
+    check_asset "$(cli issueasset 10 0 false && sync)"
+fi
\ No newline at end of file
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/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..737244efe 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::{
-    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,
+    hash_types::TxMerkleNode, Block, BlockHash, OutPoint, ScriptBuf as Script, Sequence,
+    Transaction, TxIn, TxOut, Txid,
 };
 
 #[cfg(feature = "liquid")]
@@ -9,7 +10,7 @@ pub use {
     crate::elements::asset,
     elements::{
         address, confidential, encode::deserialize, script, Address, AssetId, Block, BlockHash,
-        BlockHeader, OutPoint, Script, Transaction, TxIn, TxOut, Txid,
+        BlockHeader, OutPoint, Script, Sequence, Transaction, TxIn, TxMerkleNode, TxOut, Txid,
     },
 };
 
@@ -52,7 +53,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,11 +142,14 @@ 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),
     }
 }
 
 #[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"
@@ -158,7 +162,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,
     }
 }
 
@@ -206,6 +210,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..5abdba80b 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -2,33 +2,34 @@ 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 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};
 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))?,
@@ -40,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))?,
@@ -49,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))?)
 }
 
@@ -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)
     }
 
@@ -527,13 +518,13 @@ 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> {
         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/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/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..884284708 100644
--- a/src/elements/mod.rs
+++ b/src/elements/mod.rs
@@ -1,6 +1,6 @@
-use bitcoin::hashes::{hex::ToHex, Hash};
-use elements::secp256k1_zkp::ZERO_TWEAK;
-use elements::{confidential::Value, encode::serialize, issuance::ContractHash, AssetId, TxIn};
+use bitcoin::hashes::{sha256, Hash};
+use elements::secp256k1_zkp::{PedersenCommitment, Tweak, ZERO_TWEAK};
+use elements::{issuance::ContractHash, AssetId, TxIn};
 
 pub mod asset;
 pub mod peg;
@@ -12,21 +12,21 @@ 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<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")]
-    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 {
@@ -44,33 +44,19 @@ 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
             },
-            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(),
         }
     }
-}
\ 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/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..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()),
     }
@@ -64,6 +62,10 @@ 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")?;
+
+    #[cfg(not(feature = "liquid"))]
+    let addr = addr.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..800eabf12 100644
--- a/src/new_index/schema.rs
+++ b/src/new_index/schema.rs
@@ -1,9 +1,10 @@
 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;
+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 108215634..c5ac02d8d 100644
--- a/src/rest.rs
+++ b/src/rest.rs
@@ -1,33 +1,33 @@
-use crate::chain::{address, BlockHash, Network, OutPoint, Script, Transaction, TxIn, TxOut, Txid};
+use crate::chain::{
+    address, 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,
+    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, std::str::FromStr};
+use bitcoin::consensus::encode;
 
-use bitcoin::blockdata::opcodes;
-use bitcoin::hashes::hex::{FromHex, ToHex};
 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;
 use tokio::sync::oneshot;
 
-use hyperlocal::UnixServerExt;
 use std::fs;
+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;
@@ -56,44 +56,47 @@ 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: u32,
-    merkle_root: String,
-    previousblockhash: Option<String>,
+    weight: u64,
+    merkle_root: TxMerkleNode,
+    previousblockhash: Option<BlockHash>,
     mediantime: u32,
 
     #[cfg(not(feature = "liquid"))]
     nonce: u32,
     #[cfg(not(feature = "liquid"))]
-    bits: u32,
+    bits: bitcoin::pow::CompactTarget,
     #[cfg(not(feature = "liquid"))]
-    difficulty: u64,
+    difficulty: f64,
 
     #[cfg(feature = "liquid")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    ext: Option<serde_json::Value>,
+    ext: Option<elements::BlockExtData>,
 }
 
 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(),
             height: blockhm.header_entry.height() as u32,
-            version: header.version 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,
-            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,
+            previousblockhash: if header.prev_blockhash != *DEFAULT_BLOCKHASH {
+                Some(header.prev_blockhash)
             } else {
                 None
             },
@@ -104,15 +107,15 @@ impl BlockValue {
             #[cfg(not(feature = "liquid"))]
             nonce: header.nonce,
             #[cfg(not(feature = "liquid"))]
-            difficulty: header.difficulty(bitcoin::Network::from(network)),
+            difficulty: header.difficulty_float(),
 
             #[cfg(feature = "liquid")]
-            ext: Some(json!(header.ext)),
+            ext: Some(header.ext.clone()),
         }
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize)]
 struct TransactionValue {
     txid: Txid,
     version: u32,
@@ -120,7 +123,7 @@ struct TransactionValue {
     vin: Vec<TxInValue>,
     vout: Vec<TxOutValue>,
     size: u32,
-    weight: u32,
+    weight: u64,
     fee: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
     status: Option<TransactionStatus>,
@@ -150,21 +153,25 @@ 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,
-            locktime: tx.lock_time,
+            locktime: tx.lock_time.to_consensus_u32(),
             vin: vins,
             vout: vouts,
             size: tx.size() as u32,
-            weight: tx.weight() as u32,
+            weight: weight as u64,
             fee,
             status: Some(TransactionStatus::from(blockid)),
         }
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Clone)]
 struct TxInValue {
     txid: Txid,
     vout: u32,
@@ -174,7 +181,7 @@ struct TxInValue {
     #[serde(skip_serializing_if = "Option::is_none")]
     witness: Option<Vec<String>>,
     is_coinbase: bool,
-    sequence: u32,
+    sequence: Sequence,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     inner_redeemscript_asm: Option<String>,
@@ -195,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
         };
@@ -236,7 +248,7 @@ impl TxInValue {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Clone)]
 struct TxOutValue {
     scriptpubkey: Script,
     scriptpubkey_asm: String,
@@ -254,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")]
@@ -273,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_hex()),
-            _ => 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;
@@ -319,7 +314,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"
@@ -337,21 +332,16 @@ 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,
         }
     }
 }
-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 {
@@ -368,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 {
@@ -405,42 +392,19 @@ impl From<Utxo> for UtxoValue {
             value: utxo.value,
 
             #[cfg(feature = "liquid")]
-            value: match utxo.value {
-                Value::Explicit(value) => Some(value),
-                _ => None,
-            },
+            value: utxo.value.explicit(),
             #[cfg(feature = "liquid")]
-            valuecommitment: match utxo.value {
-                Value::Confidential(..) => Some(hex::encode(encode::serialize(&utxo.value))),
-                _ => None,
-            },
-            #[cfg(feature = "liquid")]
-            asset: match utxo.asset {
-                Asset::Explicit(asset) => Some(asset.to_hex()),
-                _ => 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(nonce.to_hex()),
-                _ => 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),
         }
     }
 }
@@ -639,7 +603,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 +615,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 +624,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,17 +650,17 @@ 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)
                 .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) => {
-            let hash = BlockHash::from_hex(hash)?;
+            let hash = BlockHash::from_str(hash)?;
             let raw = query
                 .chain()
                 .get_block_raw(&hash)
@@ -710,7 +674,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 +683,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 +794,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 +870,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,14 +883,14 @@ 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()))?;
 
             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);
@@ -939,20 +903,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 +925,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())
@@ -973,12 +937,12 @@ fn handle_request(
 
             http_message(
                 StatusCode::OK,
-                hex::encode(encode::serialize(&merkleblock)),
+                encode::serialize_hex(&merkleblock),
                 ttl_by_depth(height, query),
             )
         }
         (&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 +960,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 +987,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 +1034,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 +1044,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 +1076,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 +1091,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 +1105,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 +1151,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 +1171,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 +1206,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,16 +1215,14 @@ 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()))
 }
 
 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)]
@@ -1301,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())
     }
@@ -1313,8 +1263,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..18dc91c27 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
     }
@@ -292,9 +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,
-            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: weight as u32,
             size: b.size,
         }
     }
diff --git a/src/util/fees.rs b/src/util/fees.rs
index 828be6cd1..164b9c133 100644
--- a/src/util/fees.rs
+++ b/src/util/fees.rs
@@ -1,23 +1,28 @@
 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 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() / 4;
+
+        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 as u32,
-            fee_per_vbyte: fee as f32 / vsize as f32,
+            vsize: vsize_float.ceil() as u64,
+            fee_per_vbyte: fee as f64 / vsize_float,
         }
     }
 }
@@ -38,7 +43,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..fbfaf7f97 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::{
@@ -129,41 +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 bitcoin::hashes::hex::{FromHex, ToHex};
-    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())
-    }
-
-    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)?)
-    }
-
-    pub mod opt {
-        use bitcoin::hashes::hex::{FromHex, ToHex};
-        use serde::de::Error;
-        use serde::{Deserializer, Serializer};
-
-        pub fn serialize<S: Serializer>(b: &Option<Vec<u8>>, s: S) -> Result<S::Ok, S::Error> {
-            match *b {
-                None => s.serialize_none(),
-                Some(ref b) => s.serialize_str(&b.to_hex()),
-            }
-        }
-
-        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)?))
-        }
-    }
-}
diff --git a/src/util/script.rs b/src/util/script.rs
index 61be03e65..f7a2a65f3 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,6 +43,8 @@ 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() {
+            #[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")]