Merge #272: Update to hex-conservative 1.1; drop hex module

44a6974 rename hex_conservative to hex, re-export it, delete old hex module (Andrew Poelstra)
f30b28a re-export 'hex_conservative' as hex (Andrew Poelstra)
1c37bb1 serde_utils: remove old hex module (Andrew Poelstra)
de8927c serde: remove old hex module from 'hex_bytes' module (Andrew Poelstra)
0e28e22 serde_utils: change deserialization bound on hex_bytes from FromHex to From<Vec<u8>> (Andrew Poelstra)
c307d35 replace ToHex with hex-conservative 1.1 functions (Andrew Poelstra)
3a1a2a1 script: replace from_hex and from_str with from_hex_no_prefix (Andrew Poelstra)
0b6ef57 confidential: replace FromHex with FromStr for abf and vbf (Andrew Poelstra)
b4ab7c3 replace Vec::<u8>::from_hex with hex-conservative functions (Andrew Poelstra)
a152b04 bump hex-conservative dependency to 1.1.0 (Andrew Poelstra)

Pull request description:

  We have a `hex` module which is loosely based on the `hashes::hex` module from `bitcoin_hashes` 0.11 or so. rust-bitcoin has updated to the `hex-conservative` crate, "hex with a conservative MSRV policy", which is maintained by the rust-bitcoin community.

  We recently have released version 1.1, which is finally feature-complete, after years of haggling over API questions.

  This has a couple philosophical changes from the old `hex` module:

  * There is no `FromHex` trait; the assumption is that if something is naturally hex-encoded then it should use `FromStr` to parse from hex, and there is little value in a trait describing "an object which can be parsed from hex" beyond this. For things like `Script` which have a hex-encoding but aren't "naturally" hex-encoded, they should have inherent methods
  * Relatedly, rather than requiring extension traits to decode hex to arrays or vectors, we provide standalone methods `decode_to_vec` and `decode_to_array`
  * The `ToHex` trait, which previously was oriented around producing hex-encoded `String`s, has been replaced with `DisplayHex`, a trait which produces a (typically) no-alloc wrapper around an object that can be hex-formatted. It is a trait rather than standalone function(s) so it can be cleanly implemented for both `[u8]` and `[u8]`-like things, but we don't expect users to implement this; they should use `Display` or inherent methods instead

  In addition, there are a pile of mechanical changes; `to_hex` becomes `as_hex` in most cases, `Vec::from_hex` becomes `decode_to_vec` or `hex!`, etc. So this PR has a large diff but it's mostly mechanical, and the changes serve both to clean up the code and to eliminate a bunch of allocations.

  A later PR will replace our encoding traits with the new `bitcoin-consensus-encoding` trait, which will further eliminate allocations when deserializing objects from hex.

ACKs for top commit:
  apoelstra:
    ACK 44a6974; successfully ran local tests
  delta1:
    ACK 44a6974; tested locally

Tree-SHA512: b4ed7ccd0c66b0b59baf2ab11c80af502d3590373992c73270f49ae112ca1ab3296138f08375dbe41cc8e8dac65216562eb13195bb77ee2aa7947ad778b06930

Author: delta1

Cargo-recent.lock

@@ -204,7 +204,7 @@ dependencies = [
  "bincode",
  "bitcoin",
  "getrandom 0.2.16",
- "hex-conservative 1.0.0",
+ "hex-conservative 1.1.0",
  "rand",
  "rand_chacha",
  "secp256k1-zkp",
@@ -293,9 +293,12 @@ dependencies = [
 
 [[package]]
 name = "hex-conservative"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ee770c000993d17c185713463d5ebfbd1af9afae4c17cc295640104383bfbf0"
+checksum = "a7289f6b628ce69fb1a371d0fdcf8ff38cd93ec00e3010eb055d1e044998c8d1"
+dependencies = [
+ "arrayvec",
+]
 
 [[package]]
 name = "hex_lit"

Cargo.toml

@@ -37,7 +37,7 @@ serde_json = { version = "1.0", optional = true }
 actual-serde = { package = "serde", version = "1.0.103", features = [
     "derive",
 ], optional = true }
-hex-conservative = "1.0.0"
+hex = { package = "hex-conservative", version = "1.1.0" }
 
 
 [target.wasm32-unknown-unknown.dev-dependencies]

elementsd-tests/src/pset.rs

@@ -7,9 +7,9 @@ extern crate rand;
 use crate::{setup, Call};
 
 use bitcoin::{self, Address, Amount};
-use elements::hex::ToHex;
 use elements::encode::serialize;
 use elements::hashes::Hash;
+use elements::hex::DisplayHex as _;
 use elements::pset::PartiallySignedTransaction;
 use elements::{AssetId, ContractHash};
 use elementsd::bitcoincore_rpc::jsonrpc::serde_json::json;
@@ -116,7 +116,7 @@ fn tx_pegin() {
     bitcoind.client.generate_to_address(101, &btc_addr).unwrap();
     let proof = bitcoind.client.get_tx_out_proof(&[txid], None).unwrap();
     elementsd.generate(2);
-    let inputs = json!([ {"txid":txid, "vout": vout,"pegin_bitcoin_tx": tx_bytes.to_hex(), "pegin_txout_proof": proof.to_hex(), "pegin_claim_script": claim_script } ]);
+    let inputs = json!([ {"txid":txid, "vout": vout,"pegin_bitcoin_tx": tx_bytes.to_lower_hex_string(), "pegin_txout_proof": proof.to_lower_hex_string(), "pegin_claim_script": claim_script } ]);
     let outputs = json!([
         {address_lbtc: "0.9", "blinder_index": 0},
         {"fee": "0.1" }
@@ -158,7 +158,7 @@ fn psbt_rtt(elementsd: &ElementsD, base64: &str) {
         b_bytes[i] = b_bytes[i].wrapping_add(1);
         let base64 = BASE64_STANDARD.encode(&b_bytes);
         if let Some(decoded) = elementsd.decode_psbt(&base64) {
-            assert_ne!(a, decoded, "{} with changed byte {}", b_bytes.to_hex(), i);
+            assert_ne!(a, decoded, "{} with changed byte {}", b_bytes.as_hex(), i);
         }
         b_bytes[i] = b_bytes[i].wrapping_sub(1);
     }

elementsd-tests/src/taproot.rs

@@ -7,7 +7,7 @@ use crate::{Call, setup};
 
 use bitcoin::key::{XOnlyPublicKey, Keypair};
 use bitcoin::Amount;
-use elements::hex::FromHex;
+use elements::hex;
 use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
 use elements::encode::{deserialize, serialize_hex};
 use elements::hashes::Hash;
@@ -101,7 +101,7 @@ fn funded_tap_txout(
     elementsd.generate(1);
     let tx_hex = elementsd.get_transaction(&txid_hex);
 
-    let tx = deserialize::<Transaction>(&Vec::<u8>::from_hex(&tx_hex).unwrap()).unwrap();
+    let tx = deserialize::<Transaction>(&hex::decode_to_vec(&tx_hex).unwrap()).unwrap();
 
     let mut outpoint: Option<OutPoint> = None;
     for (i, out) in tx.output.iter().enumerate() {

examples/pset_blind_coinjoin.rs

@@ -28,7 +28,7 @@ use elements::{pset, secp256k1_zkp};
 
 use elements::encode::{deserialize, serialize_hex};
 use elements::{confidential, AssetId, TxOut};
-use elements::hex::FromHex;
+use elements::hex;
 use rand::SeedableRng;
 
 // Assume txouts are simple pay to wpkh
@@ -41,7 +41,7 @@ struct Secrets {
 }
 
 fn deser_pset(psbt_hex: &str) -> Pset {
-    deserialize::<Pset>(&Vec::<u8>::from_hex(psbt_hex).unwrap()).unwrap()
+    deserialize::<Pset>(&hex::decode_to_vec(psbt_hex).unwrap()).unwrap()
 }
 
 fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
@@ -50,18 +50,18 @@ fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
 
     let txout = TxOut {
         asset: deserialize::<confidential::Asset>(
-            &Vec::<u8>::from_hex(v["assetcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["assetcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         value: deserialize::<confidential::Value>(
-            &Vec::<u8>::from_hex(v["amountcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["amountcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         nonce: deserialize::<confidential::Nonce>(
-            &Vec::<u8>::from_hex(v["commitmentnonce"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["commitmentnonce"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
-        script_pubkey: Script::from_hex(v["scriptPubKey"].as_str().unwrap()).unwrap(),
+        script_pubkey: Script::from_hex_no_prefix(v["scriptPubKey"].as_str().unwrap()).unwrap(),
         witness: TxOutWitness::default(),
     };
 

examples/raw_blind.rs

@@ -15,7 +15,7 @@ use elements::{pset, secp256k1_zkp, SurjectionInput};
 
 use elements::encode::{deserialize, serialize_hex};
 use elements::{confidential, AssetId, TxOut};
-use elements::hex::FromHex;
+use elements::hex;
 use rand::SeedableRng;
 
 /// Pset example workflow:
@@ -36,7 +36,7 @@ struct Secrets {
 }
 
 fn deser_pset(psbt_hex: &str) -> Pset {
-    deserialize::<Pset>(&Vec::<u8>::from_hex(psbt_hex).unwrap()).unwrap()
+    deserialize::<Pset>(&hex::decode_to_vec(psbt_hex).unwrap()).unwrap()
 }
 
 fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
@@ -45,18 +45,18 @@ fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
 
     let txout = TxOut {
         asset: deserialize::<confidential::Asset>(
-            &Vec::<u8>::from_hex(v["assetcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["assetcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         value: deserialize::<confidential::Value>(
-            &Vec::<u8>::from_hex(v["amountcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["amountcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         nonce: deserialize::<confidential::Nonce>(
-            &Vec::<u8>::from_hex(v["commitmentnonce"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["commitmentnonce"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
-        script_pubkey: Script::from_hex(v["scriptPubKey"].as_str().unwrap()).unwrap(),
+        script_pubkey: Script::from_hex_no_prefix(v["scriptPubKey"].as_str().unwrap()).unwrap(),
         witness: TxOutWitness::default(),
     };
 
@@ -280,13 +280,13 @@ fn main() {
     tx.verify_tx_amt_proofs(&secp, &[btc_txout, asset_txout])
         .unwrap();
 
-    let inp0_sig = Vec::<u8>::from_hex("3044022040d1802d6e10da4c27f05eff807550e614b3d2fa20c663dbf1ebf162d3952689022001f477c953b7c543bce877e3297fccb00ef5dba21d427e79c8bfb8522713309801").unwrap();
+    let inp0_sig = hex::hex!("3044022040d1802d6e10da4c27f05eff807550e614b3d2fa20c663dbf1ebf162d3952689022001f477c953b7c543bce877e3297fccb00ef5dba21d427e79c8bfb8522713309801").to_vec();
     let inp0_pk = PublicKey::from_str(
         "0334c307ad8142e7c8a6bf1ad3552b12fbb860885ea7f2d76c1f49f93a7c4bbbe7",
     )
     .unwrap();
 
-    let inp1_sig = Vec::<u8>::from_hex("3044022017c696503f5e1539fe5cb8dd05f793bd3b6e39f193028a7299a80c94c817a02d022007889009088f46cd9d9f4d137815704170410f53d503b68c1e020292a85b93fa01").unwrap();
+    let inp1_sig = hex::hex!("3044022017c696503f5e1539fe5cb8dd05f793bd3b6e39f193028a7299a80c94c817a02d022007889009088f46cd9d9f4d137815704170410f53d503b68c1e020292a85b93fa01").to_vec();
     let inp1_pk = PublicKey::from_str(
         "03df8f51c053ba0dfb443cce9793b6dc3339ffb0ce97af4792dade3aae1eb890f6",
     )

examples/tx.rs

@@ -395,7 +395,6 @@ impl Block {
 #[cfg(test)]
 mod tests {
     use crate::Block;
-    use crate::hex::FromHex;
 
     use super::*;
 
@@ -796,7 +795,7 @@ mod tests {
     fn test_failed_block() {
         let block_str = include_str!("../tests/data/failedblock.hex");
 
-        let bytes = Vec::<u8>::from_hex(block_str).unwrap();
+        let bytes = hex::decode_to_vec(block_str).unwrap();
         let _block = encode::deserialize::<Block>(&bytes).unwrap();
     }
 }