diff --git a/bitcoin/src/blockdata/locktime/absolute.rs b/bitcoin/src/blockdata/locktime/absolute.rs index eb37de29..fa7be4ef 100644 --- a/bitcoin/src/blockdata/locktime/absolute.rs +++ b/bitcoin/src/blockdata/locktime/absolute.rs @@ -18,9 +18,8 @@ use mutagen::mutate; use crate::absolute; use crate::consensus::encode::{self, Decodable, Encodable}; use crate::error::ParseIntError; -use crate::parse::{impl_parse_str, impl_parse_str_from_int_infallible}; +use crate::parse::{self, impl_parse_str, impl_parse_str_from_int_infallible}; use crate::prelude::*; -use crate::string::FromHexStr; /// The Threshold for deciding whether a lock time value is a height or a time (see [Bitcoin Core]). /// @@ -102,6 +101,14 @@ impl LockTime { /// The number of bytes that the locktime contributes to the size of a transaction. pub const SIZE: usize = 4; // Serialized length of a u32. + /// Creates a `LockTime` from a hex string. + /// + /// The input string is may or may not contain a typical hex prefix e.g., `0x`. + pub fn from_hex(s: &str) -> Result { + let lock_time = parse::hex_u32(s)?; + Ok(Self::from_consensus(lock_time)) + } + /// Constructs a `LockTime` from an nLockTime value or the argument to OP_CHEKCLOCKTIMEVERIFY. /// /// # Examples @@ -325,16 +332,6 @@ impl fmt::Display for LockTime { } } -impl FromHexStr for LockTime { - type Error = ParseIntError; - - #[inline] - fn from_hex_str_no_prefix + Into>(s: S) -> Result { - let lock_time = crate::parse::hex_u32(s)?; - Ok(Self::from_consensus(lock_time)) - } -} - impl Encodable for LockTime { #[inline] fn consensus_encode(&self, w: &mut W) -> Result { @@ -419,6 +416,11 @@ impl Height { /// The maximum absolute block height. pub const MAX: Self = Height(LOCK_TIME_THRESHOLD - 1); + /// Creates a `Height` from a hex string. + /// + /// The input string is may or may not contain a typical hex prefix e.g., `0x`. + pub fn from_hex(s: &str) -> Result { parse_hex(s, Self::from_consensus) } + /// Constructs a new block height. /// /// # Errors @@ -460,15 +462,6 @@ impl fmt::Display for Height { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) } } -impl FromHexStr for Height { - type Error = ParseHeightError; - - #[inline] - fn from_hex_str_no_prefix + Into>(s: S) -> Result { - parse_hex(s, Self::from_consensus) - } -} - impl_parse_str!(Height, ParseHeightError, parser(Height::from_consensus)); /// Error returned when parsing block height fails. @@ -508,6 +501,11 @@ impl Time { /// The maximum absolute block time (Sun Feb 07 2106 06:28:15 GMT+0000). pub const MAX: Self = Time(u32::max_value()); + /// Creates a `Time` from a hex string. + /// + /// The input string is may or may not contain a typical hex prefix e.g., `0x`. + pub fn from_hex(s: &str) -> Result { parse_hex(s, Self::from_consensus) } + /// Constructs a new block time. /// /// # Errors @@ -549,15 +547,6 @@ impl fmt::Display for Time { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) } } -impl FromHexStr for Time { - type Error = ParseTimeError; - - #[inline] - fn from_hex_str_no_prefix + Into>(s: S) -> Result { - parse_hex(s, Self::from_consensus) - } -} - impl_parse_str!(Time, ParseTimeError, parser(Time::from_consensus)); /// Error returned when parsing block time fails. @@ -599,7 +588,7 @@ where S: AsRef + Into, F: FnOnce(u32) -> Result, { - let n = i64::from_str_radix(s.as_ref(), 16).map_err(ParseError::invalid_int(s))?; + let n = i64::from_str_radix(parse::strip_hex_prefix(s.as_ref()), 16).map_err(ParseError::invalid_int(s))?; let n = u32::try_from(n).map_err(|_| ParseError::Conversion(n))?; f(n).map_err(ParseError::from).map_err(Into::into) } @@ -821,61 +810,61 @@ mod tests { #[test] fn time_from_str_hex_happy_path() { - let actual = Time::from_hex_str("0x6289C350").unwrap(); + let actual = Time::from_hex("0x6289C350").unwrap(); let expected = Time::from_consensus(0x6289C350).unwrap(); assert_eq!(actual, expected); } #[test] fn time_from_str_hex_no_prefix_happy_path() { - let time = Time::from_hex_str_no_prefix("6289C350").unwrap(); + let time = Time::from_hex("6289C350").unwrap(); assert_eq!(time, Time(0x6289C350)); } #[test] fn time_from_str_hex_invalid_hex_should_err() { let hex = "0xzb93"; - let result = Time::from_hex_str(hex); + let result = Time::from_hex(hex); assert!(result.is_err()); } #[test] fn lock_time_from_str_hex_happy_path() { - let actual = LockTime::from_hex_str("0xBA70D").unwrap(); + let actual = LockTime::from_hex("0xBA70D").unwrap(); let expected = LockTime::from_consensus(0xBA70D); assert_eq!(actual, expected); } #[test] fn lock_time_from_str_hex_no_prefix_happy_path() { - let lock_time = LockTime::from_hex_str_no_prefix("BA70D").unwrap(); + let lock_time = LockTime::from_hex("BA70D").unwrap(); assert_eq!(lock_time, LockTime::from_consensus(0xBA70D)); } #[test] fn lock_time_from_str_hex_invalid_hex_should_ergr() { let hex = "0xzb93"; - let result = LockTime::from_hex_str(hex); + let result = LockTime::from_hex(hex); assert!(result.is_err()); } #[test] fn height_from_str_hex_happy_path() { - let actual = Height::from_hex_str("0xBA70D").unwrap(); + let actual = Height::from_hex("0xBA70D").unwrap(); let expected = Height(0xBA70D); assert_eq!(actual, expected); } #[test] fn height_from_str_hex_no_prefix_happy_path() { - let height = Height::from_hex_str_no_prefix("BA70D").unwrap(); + let height = Height::from_hex("BA70D").unwrap(); assert_eq!(height, Height(0xBA70D)); } #[test] fn height_from_str_hex_invalid_hex_should_err() { let hex = "0xzb93"; - let result = Height::from_hex_str(hex); + let result = Height::from_hex(hex); assert!(result.is_err()); } diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs index 7674824c..c0a7c023 100644 --- a/bitcoin/src/blockdata/transaction.rs +++ b/bitcoin/src/blockdata/transaction.rs @@ -25,10 +25,9 @@ use crate::blockdata::witness::Witness; use crate::blockdata::FeeRate; use crate::consensus::{encode, Decodable, Encodable}; use crate::internal_macros::{impl_consensus_encoding, impl_hashencode}; -use crate::parse::impl_parse_str_from_int_infallible; +use crate::parse::{self, impl_parse_str_from_int_infallible, ParseIntError}; #[cfg(doc)] use crate::sighash::{EcdsaSighashType, TapSighashType}; -use crate::string::FromHexStr; use crate::prelude::*; use crate::{Amount, SignedAmount, VarInt}; @@ -402,6 +401,14 @@ impl Sequence { self.is_relative_lock_time() & (self.0 & Sequence::LOCK_TYPE_MASK > 0) } + /// Creates a `Sequence` number from a hex string. + /// + /// The input string may or may not contain a typical hex prefix e.g., `0x`. + pub fn from_hex(s: &str) -> Result { + let lock_time = parse::hex_u32(s)?; + Ok(Self::from_consensus(lock_time)) + } + /// Creates a relative lock-time using block height. #[inline] pub fn from_height(height: u16) -> Self { Sequence(u32::from(height)) } @@ -473,15 +480,6 @@ impl Sequence { fn low_u16(&self) -> u16 { self.0 as u16 } } -impl FromHexStr for Sequence { - type Error = crate::parse::ParseIntError; - - fn from_hex_str_no_prefix + Into>(s: S) -> Result { - let sequence = crate::parse::hex_u32(s)?; - Ok(Self::from_consensus(sequence)) - } -} - impl Default for Sequence { /// The default value of sequence is 0xffffffff. fn default() -> Self { Sequence::MAX } @@ -2120,20 +2118,20 @@ mod tests { #[test] fn sequence_from_str_hex_happy_path() { - let sequence = Sequence::from_hex_str("0xFFFFFFFF").unwrap(); + let sequence = Sequence::from_hex("0xFFFFFFFF").unwrap(); assert_eq!(sequence, Sequence::MAX); } #[test] fn sequence_from_str_hex_no_prefix_happy_path() { - let sequence = Sequence::from_hex_str_no_prefix("FFFFFFFF").unwrap(); + let sequence = Sequence::from_hex("FFFFFFFF").unwrap(); assert_eq!(sequence, Sequence::MAX); } #[test] fn sequence_from_str_hex_invalid_hex_should_err() { let hex = "0xzb93"; - let result = Sequence::from_hex_str(hex); + let result = Sequence::from_hex(hex); assert!(result.is_err()); } diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs index c9f92e6b..23524672 100644 --- a/bitcoin/src/lib.rs +++ b/bitcoin/src/lib.rs @@ -108,7 +108,6 @@ pub mod policy; pub mod pow; pub mod psbt; pub mod sign_message; -pub mod string; pub mod taproot; #[rustfmt::skip] // Keep public re-exports separate. diff --git a/bitcoin/src/parse.rs b/bitcoin/src/parse.rs index 35eb4764..f8c40400 100644 --- a/bitcoin/src/parse.rs +++ b/bitcoin/src/parse.rs @@ -90,8 +90,19 @@ pub(crate) fn int + Into>(s: S) -> Result &str { + if let Some(stripped) = s.strip_prefix("0x") { + stripped + } else if let Some(stripped) = s.strip_prefix("0X") { + stripped + } else { + s + } +} + pub(crate) fn hex_u32 + Into>(s: S) -> Result { - u32::from_str_radix(s.as_ref(), 16).map_err(|error| ParseIntError { + u32::from_str_radix(strip_hex_prefix(s.as_ref()), 16).map_err(|error| ParseIntError { input: s.into(), bits: u8::try_from(core::mem::size_of::() * 8).expect("max is 32 bits for u32"), is_signed: u32::try_from(-1i8).is_ok(), diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs index e6870677..e098cbb7 100644 --- a/bitcoin/src/pow.rs +++ b/bitcoin/src/pow.rs @@ -17,8 +17,7 @@ use crate::blockdata::block::BlockHash; use crate::consensus::encode::{self, Decodable, Encodable}; #[cfg(doc)] use crate::consensus::Params; -use crate::string::FromHexStr; -use crate::prelude::*; +use crate::parse::{self, ParseIntError}; use crate::Network; /// Implement traits and methods shared by `Target` and `Work`. @@ -272,6 +271,14 @@ do_impl!(Target); pub struct CompactTarget(u32); impl CompactTarget { + /// Creates a [`CompactTarget`] from a hex string. + /// + /// The input string is may or may not contain a typical hex prefix e.g., `0x`. + pub fn from_hex(s: &str) -> Result { + let lock_time = parse::hex_u32(s)?; + Ok(Self::from_consensus(lock_time)) + } + /// Creates a [`CompactTarget`] from a consensus encoded `u32`. pub fn from_consensus(bits: u32) -> Self { Self(bits) } @@ -283,15 +290,6 @@ impl From for Target { fn from(c: CompactTarget) -> Self { Target::from_compact(c) } } -impl FromHexStr for CompactTarget { - type Error = crate::parse::ParseIntError; - - fn from_hex_str_no_prefix + Into>(s: S) -> Result { - let compact_target = crate::parse::hex_u32(s)?; - Ok(Self::from_consensus(compact_target)) - } -} - impl Encodable for CompactTarget { #[inline] fn consensus_encode(&self, w: &mut W) -> Result { @@ -1525,14 +1523,14 @@ mod tests { #[test] fn compact_target_from_hex_str_happy_path() { - let actual = CompactTarget::from_hex_str("0x01003456").unwrap(); + let actual = CompactTarget::from_hex("0x01003456").unwrap(); let expected = CompactTarget(0x01003456); assert_eq!(actual, expected); } #[test] fn compact_target_from_hex_str_no_prefix_happy_path() { - let actual = CompactTarget::from_hex_str_no_prefix("01003456").unwrap(); + let actual = CompactTarget::from_hex("01003456").unwrap(); let expected = CompactTarget(0x01003456); assert_eq!(actual, expected); } @@ -1540,7 +1538,7 @@ mod tests { #[test] fn compact_target_from_hex_invalid_hex_should_err() { let hex = "0xzbf9"; - let result = CompactTarget::from_hex_str(hex); + let result = CompactTarget::from_hex(hex); assert!(result.is_err()); } diff --git a/bitcoin/src/string.rs b/bitcoin/src/string.rs deleted file mode 100644 index c8bad0ba..00000000 --- a/bitcoin/src/string.rs +++ /dev/null @@ -1,76 +0,0 @@ -// SPDX-License-Identifier: CC0-1.0 - -//! Bitcoin string parsing utilities. -//! -//! This module provides utility types and traits -//! to support handling and parsing strings within `rust-bitcoin`. - -use core::fmt; - -use internals::write_err; - -use crate::prelude::*; - -/// Trait that allows types to be initialized from hex strings -pub trait FromHexStr: Sized { - /// An error occurred while parsing the hex string. - type Error; - - /// Parses provided string as hex requiring 0x prefix. - /// - /// This is intended for user-supplied inputs or already-existing protocols in which 0x prefix is used. - fn from_hex_str + Into>(s: S) -> Result> { - if !s.as_ref().starts_with("0x") { - Err(FromHexError::MissingPrefix(s.into())) - } else { - Ok(Self::from_hex_str_no_prefix(s.as_ref().trim_start_matches("0x"))?) - } - } - - /// Parses provided string as hex without requiring 0x prefix. - /// - /// This is **not** recommended for user-supplied inputs because of possible confusion with decimals. - /// It should be only used for existing protocols which always encode values as hex without 0x prefix. - fn from_hex_str_no_prefix + Into>(s: S) -> Result; -} - -/// Hex parsing error -#[derive(Debug, Clone, PartialEq, Eq)] -#[non_exhaustive] -pub enum FromHexError { - /// The input was not a valid hex string, contains the error that occurred while parsing. - ParseHex(E), - /// The input is missing `0x` prefix, contains the invalid input. - MissingPrefix(String), -} - -impl From for FromHexError { - fn from(e: E) -> Self { FromHexError::ParseHex(e) } -} - -impl fmt::Display for FromHexError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - use FromHexError::*; - - match *self { - ParseHex(ref e) => write_err!(f, "failed to parse hex string"; e), - MissingPrefix(ref value) => - write_err!(f, "the input value `{}` is missing the `0x` prefix", value; self), - } - } -} - -#[cfg(feature = "std")] -impl std::error::Error for FromHexError -where - E: std::error::Error + 'static, -{ - fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { - use FromHexError::*; - - match *self { - ParseHex(ref e) => Some(e), - MissingPrefix(_) => None, - } - } -}