Merge pull request #432 from taoweicn/patch-1

Remove duplicate code

.travis.yml

@@ -1,17 +1,46 @@
 language: rust
-rust:
-  - stable
-  - beta
-  - nightly
-  - 1.14.0
+cache: cargo
 
-before_install:
-  - sudo apt-get -qq update
-  - sudo apt-get install -y binutils-dev libunwind8-dev
+addons:
+  apt:
+    update: true
+    packages:
+      - binutils-dev
+      - libunwind8-dev
+      - libcurl4-openssl-dev
+      - libelf-dev
+      - libdw-dev
+      - cmake
+      - gcc
+      - libiberty-dev
+
+
+matrix:
+  include:
+    - rust: stable
+      env: DO_FUZZ=true DO_COV=true AS_DEPENDENCY=true
+    - rust: beta
+      env: AS_DEPENDENCY=true
+    - rust: nightly
+      env: DO_BENCH=true AS_DEPENDENCY=true
+    - rust: 1.22.0
+      env: AS_DEPENDENCY=true
 
 script:
-  - cargo build --verbose
-  - cargo test --verbose
-  - cargo build --verbose --features=bitcoinconsensus
-  - cargo test --verbose --features=bitcoinconsensus
-  - if [ "$(rustup show | grep default | grep stable)" != "" ]; then cd fuzz && cargo test --verbose && ./travis-fuzz.sh; fi
+  - ./contrib/test.sh
+
+after_success: |
+  if [ "$DO_COV" = true ]; then
+    wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
+    tar xzf master.tar.gz &&
+    cd kcov-master &&
+    mkdir build &&
+    cd build &&
+    cmake .. &&
+    make &&
+    make install DESTDIR=../../kcov-build &&
+    cd ../.. &&
+    rm -rf kcov-master &&
+    for file in target/debug/bitcoin-*; do [ -x "${file}" ] || continue; mkdir -p "target/cov/$(basename $file)"; ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done &&
+    bash <(curl -s https://codecov.io/bash) &&
+    echo "Uploaded code coverage"; fi

CHANGELOG.md

@@ -0,0 +1,192 @@
+
+# 0.23.0 - 2020-01-07
+
+- Update `secp256k1` dependency to `0.17.1`.
+- Update `bitcoinconsensus` dependency to `0.19.0-1`.
+- Update `bech32` dependency to `0.7.2`.
+
+# 0.22.0 - 2020-01-07
+
+- Add `ServiceFlags` type.
+- Add `NetworkMessage::command`.
+- Add `key::Error`.
+- Add newtypes for specific hashes:
+    - `Txid`
+    - `Wtxid`
+    - `BlockHash`
+    - `SigHash`
+    - `PubkeyHash`
+    - `ScriptHash`
+    - `WPubkeyHash`
+    - `WScriptHash`
+    - `TxMerkleNode`
+    - `WitnessMerkleNode`
+    - `WitnessCommitment`
+    - `XpubIdentifier`
+    - `FilterHash`
+- Refactor `CommandString`.
+- Refactor `Reject` message.
+- Rename `RejectReason` enum variants.
+- Refactor `encode::Error`.
+- Implement `Default` for `TxIn`.
+- Implement `std::hash::Hash` for `Inventory`.
+- Implement `Copy` for `InvType` enum.
+- Use `psbt::Error` in `PartiallySignedTransaction::from_unsigned_tx`.
+- Drop message decode max length to 4_000_000.
+- Drop `hex` and `byteorder` dependencies.
+
+# 0.21.0 - 2019-10-02
+
+* Add [serde to `BlockHeader` and `Block`](https://github.com/rust-bitcoin/rust-bitcoin/pull/321)
+* [Clean up `StreamReader` API](https://github.com/rust-bitcoin/rust-bitcoin/pull/318) (breaking change)
+* Add [reject message](https://github.com/rust-bitcoin/rust-bitcoin/pull/323) to p2p messages
+
+# 0.20.0 - 2019-08-23
+
+* Update `secp256k1` 0.15 and `bitcoinconsensus` 0.17
+
+# 0.19.0 - 2019-08-16
+
+* Add `Amount` and `SignedAmount` types.
+* Add BIP-158 support with `BlockFilter` and related types.
+* Add `util::misc::signed_msg_hash()` for signing messages.
+* Add `MerkleBlock` and `PartialMerkleTree` types.
+* bip32: Support serde serializaton for types and add some utility methods:
+    * `ChildNumber::increment`
+    * `DerivationPath::children_from`
+    * `DerivationPath::normal_children`
+    * `DerivationPath::hardened_children`
+* Add `blockdata::script::Builder::push_verify` to verify-ify an opcode.
+* Add `sendheaders` network message.
+* Add `OutPoint::new()` method and JSON-serialize as `<txid>:<vout>`.
+* Refactor `Address` type:
+    * Now supports segwit addresses with version >0.
+    * Add `Address::from_script` constructor.
+    * Add `Address::address_type` inspector.
+    * Parsing now returns an `address::Error` instead of `encode::Error`.
+    * Removed `bitcoin_bech32` dependency for bech32 payloads.
+* bip143: Rename `witness_script` to `script_code`
+* Rename `BlockHeader::spv_validate` to `validate_pow`
+* Rename `OP_NOP2` and `OP_NOP3` to `OP_CLTV` and `OP_CSV`
+* psbt: Use `BTreeMap` instead of `HashMap` to ensure serialization roundtrips.
+* Drop `Decimal` type.
+* Drop `LoneHeaders` type.
+* Replace `strason` dependency with (optional) `serde_json`.
+* Export the `bitcoin_hashes` and `secp256k1` dependent crates.
+* Updated `bitcoin_hashes` dependency to v0.7.
+* Removed `rand` and `serde_test` dependencies.
+* Internal improvements to consensus encoding logic.
+
+# 0.18.0 - 2019-03-21
+
+* Update `bitcoin-bech32` version to 0.9
+* add `to_bytes` method for `util::key` types
+* add serde impls for `util::key` types
+* contracthash: minor cleanups, use `util::key` types instead of `secp256k1` types
+
+# 0.17.1 - 2019-03-04
+
+* Add some trait impls to `PublicKey` for miniscript interoperability
+
+# 0.17.0 - 2019-02-28 - ``The PSBT Release''
+
+* **Update minimum rustc version to 1.22**.
+* [Replace `rust-crypto` with `bitcoin_hashes`; refactor hash types](https://github.com/rust-bitcoin/rust-bitcoin/pull/215)
+* [Remove `Address::p2pk`](https://github.com/rust-bitcoin/rust-bitcoin/pull/222/)
+* Remove misleading blanket `MerkleRoot` implementation; [it is now only defined for `Block`](https://github.com/rust-bitcoin/rust-bitcoin/pull/218)
+* [Add BIP157](https://github.com/rust-bitcoin/rust-bitcoin/pull/215) (client-side block filtering messages)
+* Allow network messages [to be deserialized even across multiple packets](https://github.com/rust-bitcoin/rust-bitcoin/pull/231)
+* [Replace all key types](https://github.com/rust-bitcoin/rust-bitcoin/pull/183) to better match abstractions needed for PSBT
+* [Clean up BIP32](https://github.com/rust-bitcoin/rust-bitcoin/pull/233) in preparation for PSBT; [use new native key types rather than `secp256k1` ones](https://github.com/rust-bitcoin/rust-bitcoin/pull/238/)
+* Remove [apparently-used `Option` serialization](https://github.com/rust-bitcoin/rust-bitcoin/pull/236#event-2158116421) code
+* Finally merge [PSBT](https://github.com/rust-bitcoin/rust-bitcoin/pull/103) after nearly nine months
+
+# 0.16.0 - 2019-01-15
+
+* Reorganize opcode types to eliminate unsafe code
+* Un-expose some macros that were unintentionally exported
+* Update rust-secp256k1 dependency to 0.12
+* Remove `util::iter::Pair` type which does not belong in this library
+* Minor bugfixes and optimizations
+
+# 0.15.1 - 2018-11-08
+
+* [Detect p2pk addresses with compressed keys](https://github.com/rust-bitcoin/rust-bitcoin/pull/189)
+
+# 0.15.0 - 2018-11-03
+
+* [Significant API overhaul](https://github.com/rust-bitcoin/rust-bitcoin/pull/156):
+    * Remove `nu_select` macro and low-level networking support
+    * Move `network::consensus_params` to `consensus::params`
+    * Move many other things into `consensus::params`
+    * Move `BitcoinHash` from `network::serialize` to `util::hash`; remove impl for `Vec<u8>`
+    * Rename/restructure error types
+    * Rename `Consensus{De,En}coder` to `consensus::{De,En}coder`
+    * Replace `Raw{De,En}coder` with blanket impls of `consensus::{De,En}coder` on `io::Read` and `io::Write`
+    * make `serialize` and `serialize_hex` infallible
+* Make 0-input transaction de/serialization [always use segwit](https://github.com/rust-bitcoin/rust-bitcoin/pull/153)
+* Implement `FromStr` and `Display` for many more types
+
+# 0.14.2 - 2018-09-11
+
+* Add serde support for `Address`
+
+# 0.14.1 - 2018-08-28
+
+* Reject non-compact `VarInt`s on various types
+* Expose many types at the top level of the crate
+* Add `Ord`, `PartialOrd` impls for `Script`
+
+# 0.14.0 - 2018-08-22
+
+* Add [regtest network](https://github.com/rust-bitcoin/rust-bitcoin/pull/84) to `Network` enum
+* Add [`Script::is_op_return()`](https://github.com/rust-bitcoin/rust-bitcoin/pull/101/) which is more specific than
+  `Script::is_provably_unspendable()`
+* Update to bech32 0.8.0; [add Regtest bech32 address support](https://github.com/rust-bitcoin/rust-bitcoin/pull/110)
+* [Replace rustc-serialize dependency with hex](https://github.com/rust-bitcoin/rust-bitcoin/pull/107) as a stopgap
+  toward eliminating any extra dependencies for this; clean up the many independent hex encoders and decoders
+  throughout the codebase.
+* [Add conversions between `ChildNumber` and `u32`](https://github.com/rust-bitcoin/rust-bitcoin/pull/126); make
+  representation non-public; fix documentation
+* [Add several derivation convenience](https://github.com/rust-bitcoin/rust-bitcoin/pull/129) to `bip32` extended keys
+* Make `deserialize::deserialize()` [enforce no trailing bytes](https://github.com/rust-bitcoin/rust-bitcoin/pull/129)
+* Replace `TxOutRef` with `OutPoint`; use it in `TxIn` struct.
+* Use modern `as_` `to_` `into_` conventions for array-wrapping types; impl `Display` rather than `ToString` for most types
+* Change `script::Instructions` iterator [to allow rejecting non-minimal pushes](https://github.com/rust-bitcoin/rust-bitcoin/pull/136);
+  fix bug where errors would iterate forever.
+* Overhaul `util::Error`; introduce `serialize::Error` [and use it for `SimpleDecoder` and `SimpleDecoder` rather
+  than parameterizing these over their error type](https://github.com/rust-bitcoin/rust-bitcoin/pull/137).
+* Overhaul `UDecimal` and `Decimal` serialization and parsing [and fix many lingering parsing bugs](https://github.com/rust-bitcoin/rust-bitcoin/pull/142)
+* [Update to serde 1.0 and strason 0.4](https://github.com/rust-bitcoin/rust-bitcoin/pull/125)
+* Update to secp256k1 0.11.0
+* Many, many documentation and test improvements.
+
+# 0.13.1
+
+* Add `Display` trait to uints, `FromStr` trait to `Network` enum
+* Add witness inv types to inv enum, constants for Bitcoin regtest network, `is_coin_base` accessor for tx inputs
+* Expose `merkleroot(Vec<Sha256dHash>)`
+
+# 0.13
+
+* Move witnesses inside the `TxIn` structure
+* Add `Transaction::get_weight()`
+* Update bip143 `sighash_all` API to be more ergonomic
+
+# 0.12
+
+* The in-memory blockchain was moved into a dedicated project rust-bitcoin-chain.
+* Removed old script interpreter
+* A new optional feature "bitcoinconsensus" lets this library use Bitcoin Core's native
+script verifier, wrappend into Rust by the rust-bitcoinconsenus project.
+See `Transaction::verify` and `Script::verify` methods.
+* Replaced Base58 traits with `encode_slice`, `check_encode_slice`, from and `from_check` functions in the base58 module.
+* Un-reversed the Debug output for Sha256dHash
+* Add bech32 support
+* Support segwit address types
+
+### 0.11
+
+* Remove `num` dependency at Matt's request; agree this is obnoxious to require all
+downstream users to also have a `num` dependency just so they can use `Uint256::from_u64`.
+

Cargo.toml

@@ -1,7 +1,6 @@
-
 [package]
 name = "bitcoin"
-version = "0.13.0"
+version = "0.23.0"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 homepage = "https://github.com/rust-bitcoin/rust-bitcoin/"
@@ -16,19 +15,24 @@ name = "bitcoin"
 path = "src/lib.rs"
 
 [features]
-bitcoinconsenus = ["bitcoinconsensus"]
-fuzztarget = ["secp256k1/fuzztarget"]
+fuzztarget = ["secp256k1/fuzztarget", "bitcoin_hashes/fuzztarget"]
+unstable = []
+rand = ["secp256k1/rand-std"]
+use-serde = ["serde", "bitcoin_hashes/serde", "secp256k1/serde"]
 
 [dependencies]
-bitcoin-bech32 = "0.5.1"
-byteorder = "1.1"
-rand = "0.3"
-rust-crypto = "0.2"
-rustc-serialize = "0.3"
-serde = "0.6"
-strason = "0.3"
-bitcoinconsensus = { version = "0.16", optional=true }
+bech32 = "0.7.2"
+bitcoin_hashes = "0.7.3"
+secp256k1 = "0.17.1"
 
-[dependencies.secp256k1]
-version = "0.9"
-features = [ "rand" ]
+bitcoinconsensus = { version = "0.19.0-1", optional = true }
+serde = { version = "1", optional = true }
+
+[dev-dependencies]
+hex = "=0.3.2"
+serde_derive = "<1.0.99"
+serde_json = "<1.0.45"
+serde_test = "1"
+secp256k1 = { version = "0.17.1", features = ["rand-std"] }
+# We need to pin ryu (transitive dep from serde_json) to stay compatible with Rust 1.22.0
+ryu = "<1.0.5"

README.md

@@ -1,10 +1,10 @@
 [![Status](https://travis-ci.org/rust-bitcoin/rust-bitcoin.png?branch=master)](https://travis-ci.org/rust-bitcoin/rust-bitcoin)
+[![Safety Dance](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
 
 # Rust Bitcoin Library
 
 Library with support for de/serialization, parsing and executing on data
-structures and network messages related to Bitcoin and other blockchain-based
-currencies.
+structures and network messages related to Bitcoin.
 
 [Documentation](https://docs.rs/bitcoin/)
 
@@ -14,20 +14,11 @@ Supports (or should support)
 * De/serialization of blocks and transactions
 * Script de/serialization
 * Private keys and address creation, de/serialization and validation (including full BIP32 support)
+* PSBT creation, manipulation, merging and finalization
 * Pay-to-contract support as in Appendix A of the [Blockstream sidechains whitepaper](https://www.blockstream.com/sidechains.pdf)
 
-For JSONRPC interaction with Bitcoin Core, it is recommended to use [rust-jsonrpc](https://github.com/apoelstra/rust-jsonrpc)
-which uses the underlying [strason library](https://github.com/apoelstra/strason)
-which parses decimal numbers as strings, preventing precision errors.
-
-# Usage
-
-To use rust-bitcoin, just add the following to your Cargo.toml.
-
-```toml
-[dependencies]
-bitcoin = "0.12"
-```
+For JSONRPC interaction with Bitcoin Core, it is recommended to use
+[rust-bitcoincore-rpc](https://github.com/rust-bitcoin/rust-bitcoincore-rpc).
 
 # Known limitations
 
@@ -47,12 +38,54 @@ fix specific consensus incompatibilities are welcome.
 
 ## Documentation
 
-Currently the [documentation](https://www.wpsoftware.net/rustdoc/bitcoin/)
-is very sparse. Patches to add usage examples and to expand on existing
-docs would be extremely appreciated.
+Currently can be found on [docs.rs/bitcoin](https://docs.rs/bitcoin/).
+Patches to add usage examples and to expand on existing docs would be extremely
+appreciated.
 
+# Contributing
+Contributions are generally welcome. If you intend to make larger changes please
+discuss them in an issue before PRing them to avoid duplicate work and
+architectural mismatches. If you have any questions or ideas you want to discuss
+please join us in
+[#rust-bitcoin](http://webchat.freenode.net/?channels=%23rust-bitcoin) on
+freenode.
 
-# Policy on Altcoins/Altchains
+## Minimum Supported Rust Version (MSRV)
+This library should always compile with any combination of features on **Rust 1.22**.
+
+## Installing Rust
+Rust can be installed using your package manager of choice or
+[rustup.rs](https://rustup.rs). The former way is considered more secure since
+it typically doesn't involve trust in the CA system. But you should be aware
+that the version of Rust shipped by your distribution might be out of date.
+Generally this isn't a problem for `rust-bitcoin` since we support much older
+versions (>=1.22) than the current stable one.
+
+## Building
+The library can be built and tested using [`cargo`](https://github.com/rust-lang/cargo/):
+
+```
+git clone git@github.com:rust-bitcoin/rust-bitcoin.git
+cd rust-bitcoin
+cargo build
+```
+
+You can run tests with:
+
+```
+cargo test
+```
+
+Please refer to the [`cargo` documentation](https://doc.rust-lang.org/stable/cargo/) for more detailed instructions. 
+
+## Pull Requests
+Every PR needs at least two reviews to get merged. During the review phase
+maintainers and contributors are likely to leave comments and request changes.
+Please try to address them, otherwise your PR might get closed without merging
+after a longer time of inactivity. If your PR isn't ready for review yet please
+mark it by prefixing the title with `WIP: `.
+
+## Policy on Altcoins/Altchains
 
 Patches which add support for non-Bitcoin cryptocurrencies by adding constants
 to existing enums (e.g. to set the network message magic-byte sequence) are
@@ -66,39 +99,12 @@ cross-chain atomic swaps) are more likely to be accepted than things which
 support only a single blockchain.
 
 
-## Release Notes
+# Release Notes
 
-I will try to document all breaking changes here so that people upgrading will know
-what they need to change.
+See [CHANGELOG.md](CHANGELOG.md).
 
-### 0.11
 
-Remove `num` dependency at Matt's request; agree this is obnoxious to require all
-downstream users to also have a `num` dependency just so they can use `Uint256::from_u64`.
-
-### 0.12
-
-* The in-memory blockchain was moved into a dedicated project rust-bitcoin-chain.
-
-* Removed old script interpreter
-
-* A new optional feature "bitcoinconsenus" lets this library use Bitcoin Core's native
-script verifier, wrappend into Rust by the rust-bitcoinconsenus project. 
-See `Transaction::verify` and `Script::verify` methods.
-
-* Replaced Base58 traits with `encode_slice`, `check_encode_slice`, from and `from_check` functions in the base58 module.
-
-* Un-reversed the Debug output for Sha256dHash
-
-* Add bech32 support
-
-* Support segwit address types
-
-### 0.13
-
-* Move witnesses inside the `TxIn` structure
-
-* Add `Transaction::get_weight()`
-
-* Update bip143 `sighash_all` API to be more ergonomic
+# Licensing
 
+The code in this project is licensed under the [Creative Commons CC0 1.0
+Universal license](LICENSE).

contrib/test.sh

@@ -0,0 +1,49 @@
+#!/bin/sh -ex
+
+FEATURES="bitcoinconsensus use-serde rand"
+
+if [ "$DO_COV" = true ]
+then
+    export RUSTFLAGS="-C link-dead-code"
+fi
+
+
+# Use toolchain if explicitly specified
+if [ -n "$TOOLCHAIN" ]
+then
+    alias cargo="cargo +$TOOLCHAIN"
+fi
+
+# Test without any features first
+cargo test --verbose
+
+# Test each feature
+for feature in ${FEATURES}
+do
+    cargo test --verbose --features="$feature"
+done
+
+# Fuzz if told to
+if [ "$DO_FUZZ" = true ]
+then
+    (
+        cd fuzz
+        cargo test --verbose
+        ./travis-fuzz.sh
+    )
+fi
+
+# Bench if told to
+if [ "$DO_BENCH" = true ]
+then
+    cargo bench --features unstable
+fi
+
+# Use as dependency if told to
+if [ -n "$AS_DEPENDENCY" ]
+then
+    cargo new dep_test
+    cd dep_test
+    echo 'bitcoin = { path = "..", features = ["use-serde"] }' >> Cargo.toml
+    cargo test --verbose
+fi

examples/handshake.rs

@@ -0,0 +1,114 @@
+extern crate bitcoin;
+
+use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
+use std::time::{SystemTime, UNIX_EPOCH};
+use std::{env, process};
+use std::io::Write;
+
+use bitcoin::consensus::encode;
+use bitcoin::network::{address, constants, message, message_network};
+use bitcoin::network::stream_reader::StreamReader;
+use bitcoin::secp256k1;
+use bitcoin::secp256k1::rand::Rng;
+
+fn main() {
+    // This example establishes a connection to a Bitcoin node, sends the intial
+    // "version" message, waits for the reply, and finally closes the connection.
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        eprintln!("not enough arguments");
+        process::exit(1);
+    }
+
+    let str_address = &args[1];
+
+    let address: SocketAddr = str_address.parse().unwrap_or_else(|error| {
+        eprintln!("Error parsing address: {:?}", error);
+        process::exit(1);
+    });
+
+    let version_message = build_version_message(address);
+
+    let first_message = message::RawNetworkMessage {
+        magic: constants::Network::Bitcoin.magic(),
+        payload: version_message,
+    };
+
+    if let Ok(mut stream) = TcpStream::connect(address) {
+        // Send the message
+        let _ = stream.write_all(encode::serialize(&first_message).as_slice());
+        println!("Sent version message");
+
+        // Setup StreamReader
+        let read_stream = stream.try_clone().unwrap();
+        let mut stream_reader = StreamReader::new(read_stream, None);
+        loop {
+            // Loop an retrieve new messages
+            let reply: message::RawNetworkMessage = stream_reader.read_next().unwrap();
+            match reply.payload {
+                message::NetworkMessage::Version(_) => {
+                    println!("Received version message: {:?}", reply.payload);
+
+                    let second_message = message::RawNetworkMessage {
+                        magic: constants::Network::Bitcoin.magic(),
+                        payload: message::NetworkMessage::Verack,
+                    };
+
+                    let _ = stream.write_all(encode::serialize(&second_message).as_slice());
+                    println!("Sent verack message");
+                }
+                message::NetworkMessage::Verack => {
+                    println!("Received verack message: {:?}", reply.payload);
+                    break;
+                }
+                _ => {
+                    println!("Received unknown message: {:?}", reply.payload);
+                    break;
+                }
+            }
+        }
+        let _ = stream.shutdown(Shutdown::Both);
+    } else {
+        eprintln!("Failed to open connection");
+    }
+}
+
+fn build_version_message(address: SocketAddr) -> message::NetworkMessage {
+    // Building version message, see https://en.bitcoin.it/wiki/Protocol_documentation#version
+    let my_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
+
+    // "bitfield of features to be enabled for this connection"
+    let services = constants::ServiceFlags::NONE;
+
+    // "standard UNIX timestamp in seconds"
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Time error")
+        .as_secs();
+
+    // "The network address of the node receiving this message"
+    let addr_recv = address::Address::new(&address, constants::ServiceFlags::NONE);
+
+    // "The network address of the node emitting this message"
+    let addr_from = address::Address::new(&my_address, constants::ServiceFlags::NONE);
+
+    // "Node random nonce, randomly generated every time a version packet is sent. This nonce is used to detect connections to self."
+    let nonce: u64 = secp256k1::rand::thread_rng().gen();
+
+    // "User Agent (0x00 if string is 0 bytes long)"
+    let user_agent = String::from("rust-example");
+
+    // "The last block received by the emitting node"
+    let start_height: i32 = 0;
+
+    // Construct the message
+    message::NetworkMessage::Version(message_network::VersionMessage::new(
+        services,
+        timestamp as i64,
+        addr_recv,
+        addr_from,
+        nonce,
+        user_agent,
+        start_height,
+    ))
+}

fuzz/Cargo.toml

@@ -13,7 +13,7 @@ honggfuzz_fuzz = ["honggfuzz"]
 
 [dependencies]
 honggfuzz = { version = "0.5", optional = true }
-afl = { version = "0.3", optional = true }
+afl = { version = "0.4", optional = true }
 bitcoin = { path = "..", features = ["fuzztarget"] }
 
 # Prevent this from interfering with workspaces
@@ -35,3 +35,23 @@ path = "fuzz_targets/deserialize_transaction.rs"
 [[bin]]
 name = "deserialize_address"
 path = "fuzz_targets/deserialize_address.rs"
+
+[[bin]]
+name = "deserialize_amount"
+path = "fuzz_targets/deserialize_amount.rs"
+
+[[bin]]
+name = "outpoint_string"
+path = "fuzz_targets/outpoint_string.rs"
+
+[[bin]]
+name = "deserialize_psbt"
+path = "fuzz_targets/deserialize_psbt.rs"
+
+[[bin]]
+name = "deser_net_msg"
+path = "fuzz_targets/deser_net_msg.rs"
+
+[[bin]]
+name = "uint128_fuzz"
+path = "fuzz_targets/uint128_fuzz.rs"

fuzz/fuzz_targets/deser_net_msg.rs

@@ -0,0 +1,52 @@
+extern crate bitcoin;
+
+fn do_test(data: &[u8]) {
+    let _: Result<bitcoin::network::message::RawNetworkMessage, _> = bitcoin::consensus::encode::deserialize(data);
+}
+
+#[cfg(feature = "afl")]
+#[macro_use] extern crate afl;
+#[cfg(feature = "afl")]
+fn main() {
+    fuzz!(|data| {
+        do_test(&data);
+    });
+}
+
+#[cfg(feature = "honggfuzz")]
+#[macro_use] extern crate honggfuzz;
+#[cfg(feature = "honggfuzz")]
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'...b'F' => b |= c - b'A' + 10,
+                b'a'...b'f' => b |= c - b'a' + 10,
+                b'0'...b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}

fuzz/fuzz_targets/deserialize_address.rs

@@ -10,10 +10,10 @@ fn do_test(data: &[u8]) {
 }
 
 #[cfg(feature = "afl")]
-extern crate afl;
+#[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
-    afl::read_stdio_bytes(|data| {
+    fuzz!(|data| {
         do_test(&data);
     });
 }

fuzz/fuzz_targets/deserialize_amount.rs

@@ -0,0 +1,74 @@
+extern crate bitcoin;
+use std::str::FromStr;
+fn do_test(data: &[u8]) {
+    let data_str = String::from_utf8_lossy(data);
+
+    // signed
+    let samt = match bitcoin::util::amount::SignedAmount::from_str(&data_str) {
+        Ok(amt) => amt,
+        Err(_) => return,
+    };
+    let samt_roundtrip = match bitcoin::util::amount::SignedAmount::from_str(&samt.to_string()) {
+        Ok(amt) => amt,
+        Err(_) => return,
+    };
+    assert_eq!(samt, samt_roundtrip);
+
+    // unsigned
+    let amt = match bitcoin::util::amount::Amount::from_str(&data_str) {
+        Ok(amt) => amt,
+        Err(_) => return,
+    };
+    let amt_roundtrip = match bitcoin::util::amount::Amount::from_str(&amt.to_string()) {
+        Ok(amt) => amt,
+        Err(_) => return,
+    };
+    assert_eq!(amt, amt_roundtrip);
+}
+
+#[cfg(feature = "afl")]
+#[macro_use] extern crate afl;
+#[cfg(feature = "afl")]
+fn main() {
+    fuzz!(|data| {
+        do_test(&data);
+    });
+}
+
+#[cfg(feature = "honggfuzz")]
+#[macro_use] extern crate honggfuzz;
+#[cfg(feature = "honggfuzz")]
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'...b'F' => b |= c - b'A' + 10,
+                b'a'...b'f' => b |= c - b'a' + 10,
+                b'0'...b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000000", &mut a);
+        super::do_test(&a);
+    }
+}

fuzz/fuzz_targets/deserialize_block.rs

@@ -1,14 +1,14 @@
 extern crate bitcoin;
-type BResult = Result<bitcoin::blockdata::block::Block, bitcoin::util::Error>;
+
 fn do_test(data: &[u8]) {
-    let _: BResult = bitcoin::network::serialize::deserialize(data);
+    let _: Result<bitcoin::blockdata::block::Block, _>= bitcoin::consensus::encode::deserialize(data);
 }
 
 #[cfg(feature = "afl")]
-extern crate afl;
+#[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
-    afl::read_stdio_bytes(|data| {
+    fuzz!(|data| {
         do_test(&data);
     });
 }

fuzz/fuzz_targets/deserialize_psbt.rs

@@ -0,0 +1,61 @@
+extern crate bitcoin;
+
+fn do_test(data: &[u8]) {
+    let psbt: Result<bitcoin::util::psbt::PartiallySignedTransaction, _> = bitcoin::consensus::encode::deserialize(data);
+    match psbt {
+        Err(_) => {},
+        Ok(psbt) => {
+            let ser = bitcoin::consensus::encode::serialize(&psbt);
+            let deser: bitcoin::util::psbt::PartiallySignedTransaction  = bitcoin::consensus::encode::deserialize(&ser).unwrap();
+            // Since the fuzz data could order psbt fields differently, we compare to our deser/ser instead of data
+            assert_eq!(ser, bitcoin::consensus::encode::serialize(&deser));
+        }
+    }
+}
+
+#[cfg(feature = "afl")]
+#[macro_use] extern crate afl;
+#[cfg(feature = "afl")]
+fn main() {
+    fuzz!(|data| {
+        do_test(&data);
+    });
+}
+
+#[cfg(feature = "honggfuzz")]
+#[macro_use] extern crate honggfuzz;
+#[cfg(feature = "honggfuzz")]
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'...b'F' => b |= c - b'A' + 10,
+                b'a'...b'f' => b |= c - b'a' + 10,
+                b'0'...b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}

fuzz/fuzz_targets/deserialize_script.rs

@@ -1,14 +1,52 @@
 extern crate bitcoin;
-type BResult = Result<bitcoin::blockdata::script::Script, bitcoin::util::Error>;
+
+use bitcoin::util::address::Address;
+use bitcoin::network::constants::Network;
+use bitcoin::blockdata::script;
+use bitcoin::consensus::encode;
+
 fn do_test(data: &[u8]) {
-    let _: BResult = bitcoin::network::serialize::deserialize(data);
+    let s: Result<script::Script, _> = encode::deserialize(data);
+    if let Ok(script) = s {
+        let _: Vec<script::Instruction> = script.iter(false).collect();
+        let enforce_min: Vec<script::Instruction> = script.iter(true).collect();
+
+        let mut b = script::Builder::new();
+        for ins in enforce_min {
+            match ins {
+                script::Instruction::Error(_) => return,
+                script::Instruction::Op(op) => { b = b.push_opcode(op); }
+                script::Instruction::PushBytes(bytes) => {
+                    // Any one-byte pushes, except -0, which can be interpreted as numbers, should be
+                    // reserialized as numbers. (For -1 through 16, this will use special ops; for
+                    // others it'll just reserialize them as pushes.)
+                    if bytes.len() == 1 && bytes[0] != 0x80 && bytes[0] != 0x00 {
+                        if let Ok(num) = script::read_scriptint(bytes) {
+                            b = b.push_int(num);
+                        } else {
+                            b = b.push_slice(bytes);
+                        }
+                    } else {
+                        b = b.push_slice(bytes);
+                    }
+                }
+            }
+        }
+        assert_eq!(b.into_script(), script);
+        assert_eq!(data, &encode::serialize(&script)[..]);
+
+        // Check if valid address and if that address roundtrips.
+        if let Some(addr) = Address::from_script(&script, Network::Bitcoin) {
+            assert_eq!(addr.script_pubkey(), script);
+        }
+    }
 }
 
 #[cfg(feature = "afl")]
-extern crate afl;
+#[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
-    afl::read_stdio_bytes(|data| {
+    fuzz!(|data| {
         do_test(&data);
     });
 }

fuzz/fuzz_targets/deserialize_transaction.rs

@@ -1,26 +1,35 @@
 extern crate bitcoin;
-type BResult = Result<bitcoin::blockdata::transaction::Transaction, bitcoin::util::Error>;
+
 fn do_test(data: &[u8]) {
-    let tx_result: BResult = bitcoin::network::serialize::deserialize(data);
+    let tx_result: Result<bitcoin::blockdata::transaction::Transaction, _> = bitcoin::consensus::encode::deserialize(data);
     match tx_result {
         Err(_) => {},
         Ok(mut tx) => {
-            let len = bitcoin::network::serialize::serialize(&tx).unwrap().len() as u64;
+            let ser = bitcoin::consensus::encode::serialize(&tx);
+            assert_eq!(&ser[..], data);
+            let len = ser.len();
             let calculated_weight = tx.get_weight();
             for input in &mut tx.input {
                 input.witness = vec![];
             }
-            let no_witness_len = bitcoin::network::serialize::serialize(&tx).unwrap().len() as u64;
-            assert_eq!(no_witness_len * 3 + len, calculated_weight);
+            let no_witness_len = bitcoin::consensus::encode::serialize(&tx).len();
+            // For 0-input transactions, `no_witness_len` will be incorrect because
+            // we serialize as segwit even after "stripping the witnesses". We need
+            // to drop two bytes (i.e. eight weight)
+            if tx.input.is_empty() {
+                assert_eq!(no_witness_len * 3 + len - 8, calculated_weight);
+            } else {
+                assert_eq!(no_witness_len * 3 + len, calculated_weight);
+            }
         },
     }
 }
 
 #[cfg(feature = "afl")]
-extern crate afl;
+#[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
-    afl::read_stdio_bytes(|data| {
+    fuzz!(|data| {
         do_test(&data);
     });
 }
@@ -58,7 +67,7 @@ mod tests {
     #[test]
     fn duplicate_crash() {
         let mut a = Vec::new();
-        extend_vec_from_hex("00", &mut a);
+        extend_vec_from_hex("000700000001000000010000", &mut a);
         super::do_test(&a);
     }
 }

fuzz/fuzz_targets/outpoint_string.rs

@@ -0,0 +1,88 @@
+
+extern crate bitcoin;
+
+use bitcoin::blockdata::transaction::OutPoint;
+use bitcoin::consensus::encode;
+
+use std::str::FromStr;
+
+fn do_test(data: &[u8]) {
+    let lowercase: Vec<u8> = data.iter().map(|c| match *c {
+        b'A' => b'a',
+        b'B' => b'b',
+        b'C' => b'c',
+        b'D' => b'd',
+        b'E' => b'e',
+        b'F' => b'f',
+        x => x
+    }).collect();
+    let data_str = match String::from_utf8(lowercase) {
+        Err(_) => return,
+        Ok(s) => s,
+    };
+    match OutPoint::from_str(&data_str) {
+        Ok(op) => {
+            assert_eq!(op.to_string().as_bytes(), data_str.as_bytes());
+        }
+        Err(_) => {
+            // If we can't deserialize as a string, try consensus deserializing
+            let res: Result<OutPoint, _> = encode::deserialize(data);
+            if let Ok(deser) = res {
+                let ser = encode::serialize(&deser);
+                assert_eq!(ser, data);
+                let string = deser.to_string();
+                match OutPoint::from_str(&string) {
+                    Ok(destring) => assert_eq!(destring, deser),
+                    Err(_) => panic!()
+                }
+            }
+        }
+    }
+}
+
+#[cfg(feature = "afl")]
+#[macro_use] extern crate afl;
+#[cfg(feature = "afl")]
+fn main() {
+    fuzz!(|data| {
+        do_test(&data);
+    });
+}
+
+#[cfg(feature = "honggfuzz")]
+#[macro_use] extern crate honggfuzz;
+#[cfg(feature = "honggfuzz")]
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'...b'F' => b |= c - b'A' + 10,
+                b'a'...b'f' => b |= c - b'a' + 10,
+                b'0'...b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}

fuzz/fuzz_targets/uint128_fuzz.rs

@@ -0,0 +1,101 @@
+extern crate bitcoin;
+use std::str::FromStr;
+
+fn do_test(data: &[u8]) {
+    macro_rules! read_ints {
+        ($start: expr) => { {
+            let mut native = 0;
+            for c in data[$start..$start + 16].iter() {
+                native <<= 8;
+                native |= (*c) as u128;
+            }
+            // Note BE:
+            let uint128 = bitcoin::util::uint::Uint128::from(&[native as u64, (native >> 8*8) as u64][..]);
+            (native, uint128)
+        } }
+    }
+    macro_rules! check_eq {
+        ($native: expr, $uint: expr) => { {
+            assert_eq!(&[$native as u64, ($native >> 8*8) as u64], $uint.as_bytes());
+        } }
+    }
+
+    if data.len() != 16*2 + 1 { return; }
+    let (a_native, a) = read_ints!(0);
+
+    // Checks using only a:
+    for i in 0..128 {
+        check_eq!(a_native << i, a << i);
+        check_eq!(a_native >> i, a >> i);
+    }
+    assert_eq!(a_native as u64, a.low_u64());
+    assert_eq!(a_native as u32, a.low_u32());
+    assert_eq!(128 - a_native.leading_zeros() as usize, a.bits());
+    assert_eq!(a_native as u64, bitcoin::util::uint::Uint128::from_u64(a_native as u64).unwrap().low_u64());
+
+    // Checks with two numbers:
+    let (b_native, b) = read_ints!(16);
+
+    check_eq!(a_native.wrapping_add(b_native), a + b);
+    check_eq!(a_native.wrapping_sub(b_native), a - b);
+    if b_native != 0 {
+        check_eq!(a_native.wrapping_div(b_native), a / b);
+    }
+    check_eq!(a_native.wrapping_mul(b_native), a * b);
+    check_eq!(a_native & b_native, a & b);
+    check_eq!(a_native | b_native, a | b);
+    check_eq!(a_native ^ b_native, a ^ b);
+    check_eq!(a_native.wrapping_mul((b_native as u32) as u128), a.mul_u32(b.low_u32()));
+
+    assert_eq!(a_native > b_native, a > b);
+    assert_eq!(a_native >= b_native, a >= b);
+    assert_eq!(a_native < b_native, a < b);
+    assert_eq!(a_native <= b_native, a <= b);
+}
+
+#[cfg(feature = "afl")]
+#[macro_use] extern crate afl;
+#[cfg(feature = "afl")]
+fn main() {
+    fuzz!(|data| {
+        do_test(&data);
+    });
+}
+
+#[cfg(feature = "honggfuzz")]
+#[macro_use] extern crate honggfuzz;
+#[cfg(feature = "honggfuzz")]
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'...b'F' => b |= c - b'A' + 10,
+                b'a'...b'f' => b |= c - b'a' + 10,
+                b'0'...b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("100000a70000000000000000000000000000000000000000000000000000000054", &mut a);
+        super::do_test(&a);
+    }
+}

fuzz/hfuzz_input/deserialize_address/input/18b6e222b04bbd45df9508b64b8e47d5.00000014.honggfuzz.cov

@@ -0,0 +1 @@
+tb1218755mmmmmmlmmm9

fuzz/hfuzz_input/deserialize_address/input/2418838742eb837088ce87020b701357.0000000e.honggfuzz.cov

@@ -0,0 +1 @@
+tb1q1qﾇtb1fｧqo

fuzz/hfuzz_input/deserialize_address/input/4c268893957d293ecb031b7a493d5517.0000000b.honggfuzz.cov

@@ -0,0 +1 @@
+tb1270kt564

fuzz/hfuzz_input/deserialize_address/input/642cd2ab1075cc9dcbf11d4517132cff.0000000d.honggfuzz.cov

@@ -0,0 +1 @@
+BC1A[01z--546

fuzz/hfuzz_input/deserialize_address/input/733c9c9c9cb000002c9c9c9cc3100000.00000005.honggfuzz.cov

@@ -0,0 +1 @@
+1111W

fuzz/hfuzz_input/deserialize_address/input/804ca76c67dac27d3fa9842a5fbf0acb.00000012.honggfuzz.cov

@@ -0,0 +1 @@
+BC1-81003971758255

fuzz/hfuzz_input/deserialize_address/input/a4611c9c91300000211c9c9194400000.00000005.honggfuzz.cov

@@ -0,0 +1 @@
+9119<EFBFBD>

fuzz/hfuzz_input/deserialize_address/input/c7b1f1e233cb62b7663a33abe7722ab8.0000000e.honggfuzz.cov

@@ -0,0 +1 @@
+bc1{)2<>31cc<63><63>

fuzz/hfuzz_input/deserialize_address/input/dddf9577343cbfd614aa48444fdc440d.0000000b.honggfuzz.cov

@@ -0,0 +1 @@
+BC1п<EFBFBD>в?ї~<7E>:

fuzz/hfuzz_input/deserialize_address/input/ebdf1f0999769e0dd97c488f9e1629c3.0000000b.honggfuzz.cov

@@ -0,0 +1 @@
+BC1A2Q𐐀:

fuzz/hfuzz_input/deserialize_address/input/fea481ecdefcdebf030efcdefcc12454.00000008.honggfuzz.cov

@@ -0,0 +1 @@
+BC1C1Tｭﾜ

fuzz/hfuzz_input/deserialize_address/input/id-000000_orig-15cad1ae8551b96348bc3115fa7ebe63.0000000e.honggfuzz.cov

@@ -0,0 +1 @@
+BC10VWWW0VWWWy

fuzz/hfuzz_input/deserialize_address/input/id-000001_orig-215f74c65c586d0f6697654f73f1590f.0000001d.honggfuzz.cov

@@ -0,0 +1 @@
+BC1MMMMMMMMMMMMMMMMMMMMMMMMM6

fuzz/hfuzz_input/deserialize_address/input/id-000003_orig-2ce88960000000005938fcb000000000.00000003.honggfuzz.cov

@@ -0,0 +1 @@
+bc1

fuzz/hfuzz_input/deserialize_address/input/id-000006_orig-70b17afe56c3a7b354b7c3b6c80a2bb9.0000002b.honggfuzz.cov

@@ -0,0 +1 @@
+tb1118755mmmmmmmmmm9264mmmmmmm932772648

fuzz/hfuzz_input/deserialize_address/input/id-000007_orig-728beb87e91000002957ebebb2a00000.00000005.honggfuzz.cov

@@ -0,0 +1 @@
+7t44V

fuzz/hfuzz_input/deserialize_address/input/id-000008_orig-2c9c9c9cb00000002c9c9c9cb0000000.00000004.honggfuzz.cov

@@ -0,0 +1 @@
+1111

fuzz/hfuzz_input/deserialize_address/input/id-000011_orig-9c3c1fb7a5a5a5a5a60c3c7aa5a5a5a5.0000000b.honggfuzz.cov

@@ -0,0 +1 @@
+zSSSSSSSSSS

fuzz/hfuzz_input/deserialize_address/input/id-000013_orig-c5a6dff88d6d9cded749fcdd9d288fec.00000009.honggfuzz.cov

@@ -0,0 +1 @@
+BC1A063-+

fuzz/hfuzz_input/deserialize_address/input/id-000016_orig-cedfa000000000005f6e800000000000.00000002.honggfuzz.cov

@@ -0,0 +1 @@
+f<EFBFBD>

fuzz/hfuzz_input/deserialize_address/input/id-000017_orig-cfe7500000000000d79f300000000000.00000002.honggfuzz.cov

@@ -0,0 +1 @@
+漁

fuzz/hfuzz_input/deserialize_address/input/id-000018_orig-e9b51c311bb9ce0d748f29409e19cbbb.0000000b.honggfuzz.cov

@@ -0,0 +1 @@
+BC1A2Z4Y8J9

fuzz/hfuzz_input/deserialize_address/input/id-000019_orig-7b300000000000007b30000000000000.00000001.honggfuzz.cov

@@ -0,0 +1 @@
+Y

fuzz/hfuzz_input/deserialize_address/input/id-000019_orig-eaaab62c6d65ea2889ce9e10f05d9924.0000000f.honggfuzz.cov

@@ -0,0 +1 @@
+tb1p25316484708

fuzz/hfuzz_input/deserialize_address/input/id-000021_orig-efa9a6552efcc1b41f947711ecde356c.0000000a.honggfuzz.cov

@@ -0,0 +1 @@
+BCRT1Cｬ1ｬｯ

fuzz/hfuzz_input/deserialize_address/input/id-000022_orig-cb1917e940dd2cde31ebfc9d50d957a3.00000009.honggfuzz.cov

@@ -0,0 +1 @@
+BC10m7tK!

fuzz/hfuzz_input/deserialize_address/input/id-000025_orig-46367000000000004636700000000000.00000002.honggfuzz.cov

@@ -0,0 +1 @@
+uu

fuzz/hfuzz_input/deserialize_address/input/id-000026_orig-2b5a40ad2cdebf606f0efc9d201a4bc0.00000007.honggfuzz.cov

@@ -0,0 +1 @@
+BC108<EFBFBD>4

fuzz/hfuzz_input/deserialize_address/input/id-000028_orig-2cdf11c00000000071af4cb000000000.00000003.honggfuzz.cov

@@ -0,0 +1 @@
+TB1

fuzz/hfuzz_input/deserialize_address/input/id-000028_orig-e3a0a0acdebf60006f0efc90a0638000.00000006.honggfuzz.cov

@@ -0,0 +1 @@
+BC188<EFBFBD>

fuzz/hfuzz_input/deserialize_address/input/id-000029_orig-2ce927c00000000047994cb000000000.00000003.honggfuzz.cov

@@ -0,0 +1 @@
+tb1

fuzz/hfuzz_input/deserialize_address/input/id-000029_orig-e4299c9c9c9c9c9ce4299c9c9c9c9c9c.00000009.honggfuzz.cov

@@ -0,0 +1 @@
+111111111

fuzz/hfuzz_input/deserialize_address/input/id-000030_orig-37df2d30000000004d5f57b000000000.00000003.honggfuzz.cov

@@ -0,0 +1 @@
+yB!

fuzz/hfuzz_input/deserialize_address/input/id-000031_orig-41736041414141414173604141414141.00000019.honggfuzz.cov

@@ -0,0 +1 @@
+1111111111111111111111111

fuzz/hfuzz_input/deserialize_address/input/id-000032_orig-583f57782266bf0cf61b913df4fa7b99.00000011.honggfuzz.cov

@@ -0,0 +1 @@
+BC1-7111544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000036_orig-d7796363633d2cde4deafc9d73636363.00000009.honggfuzz.cov

@@ -0,0 +1 @@
+BC10WWWW4

fuzz/hfuzz_input/deserialize_address/input/id-000039_orig-id-000033_src-000004_op-havoc_rep-2

@@ -0,0 +1 @@
+o161

fuzz/hfuzz_input/deserialize_address/input/id-000040_orig-id-000034_src-000004_op-havoc_rep-2

@@ -0,0 +1 @@
+1

fuzz/hfuzz_input/deserialize_address/input/id-000043_orig-id-000042_src-000004_op-havoc_rep-2

@@ -0,0 +1 @@
+111

fuzz/hfuzz_input/deserialize_address/input/id-000044_orig-id-000042_src-000004_op-havoc_rep-64

@@ -0,0 +1 @@
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

fuzz/hfuzz_input/deserialize_address/input/id-000045_orig-id-000044_src-000004_op-havoc_rep-4

@@ -0,0 +1 @@
+11YYYYYYYYYYYY1961

fuzz/hfuzz_input/deserialize_address/input/id-000046_orig-id-000045_src-000004_op-havoc_rep-2

@@ -0,0 +1 @@
+1Y666161

fuzz/hfuzz_input/deserialize_address/input/id-000046_src-000004_op-havoc_rep-2

@@ -0,0 +1 @@
+11111111111111

fuzz/hfuzz_input/deserialize_address/input/id-000047_src-000004+000012_op-splice_rep-2

@@ -0,0 +1 @@
+BC1-71110837GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGWGGGG

fuzz/hfuzz_input/deserialize_address/input/id-000058_sync-deserialize_address_0_src-000050

@@ -0,0 +1 @@
+1111111

fuzz/hfuzz_input/deserialize_address/input/id-000059_sync-deserialize_address_0_src-000057

@@ -0,0 +1 @@
+BC1-711154444444444444444444444444444E083dU

fuzz/hfuzz_input/deserialize_address/input/id-000062_sync-deserialize_address_0_src-000059

@@ -0,0 +1 @@
+BC1C1;71;711-7111544E083'1-71115111111O1111144E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000062_sync-deserialize_address_master_src-000062

@@ -0,0 +1 @@
+11111111111111111111111111111111111111111111

fuzz/hfuzz_input/deserialize_address/input/id-000063_sync-deserialize_address_master_src-000044

@@ -0,0 +1 @@
+11111161

fuzz/hfuzz_input/deserialize_address/input/id-000064_sync-deserialize_address_0_src-000044

@@ -0,0 +1 @@
+BC1-71115(4E0831-7111544E0837U7U

fuzz/hfuzz_input/deserialize_address/input/id-000064_sync-deserialize_address_0_src-000060

@@ -0,0 +1 @@
+BC1C11111111111111111111111111~~~~~~~~~~~~~~~~~1111E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000065_sync-deserialize_address_master_src-000067

@@ -0,0 +1 @@
+BC111544E083'1-711154C1;71@711-7111544E083'1-7111544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000068_src-000004_op-flip1_pos-3

@@ -0,0 +1 @@
+tb1r70kt564

fuzz/hfuzz_input/deserialize_address/input/id-000069_src-000004_op-flip2_pos-3

@@ -0,0 +1 @@
+tb1170kt564

fuzz/hfuzz_input/deserialize_address/input/id-000069_src-000050_op-havoc_rep-8

@@ -0,0 +1 @@
+BC1C1;XXXXXXXXXXXXXXXXXXXXXXXXAXXX114E544E0<544E7111544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000070_src-000050_op-havoc_rep-4

@@ -0,0 +1 @@
+BC1C1;71;711-7111544E083'711-711154-7117'11-71115440837U

fuzz/hfuzz_input/deserialize_address/input/id-000070_sync-deserialize_address_0_src-000062

@@ -0,0 +1 @@
+BC11544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000071_src-000050_op-havoc_rep-2

@@ -0,0 +1 @@
+BC1C1;71;711-7111544E083'1-7111544E08377-7111544E0837UU

fuzz/hfuzz_input/deserialize_address/input/id-000072_src-000004_op-havoc_rep-64

@@ -0,0 +1 @@
+22

fuzz/hfuzz_input/deserialize_address/input/id-000072_src-000051_op-flip2_pos-22

@@ -0,0 +1 @@
+BC1-3711LLLLLLLLLLLLLL,LLLLLLLLLLLLLLLLL1544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000074_src-000004_op-havoc_rep-2

@@ -0,0 +1 @@
+tb127kkkkkkkkkkkkkkkkkkkkkkkkkkkkkk0kt56

fuzz/hfuzz_input/deserialize_address/input/id-000074_sync-deserialize_address_0_src-000064

@@ -0,0 +1 @@
+BC1C1;71;711-44E083'1-711154SA0837111544E083'1-7111544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000075_src-000004_op-havoc_rep-64

@@ -0,0 +1 @@
+hhhhhhhhhhhhhhhhRhhhhhhhThhhhhhhhhhhhhhRhhhhhhhh

fuzz/hfuzz_input/deserialize_address/input/id-000075_sync-deserialize_address_0_src-000049

@@ -0,0 +1 @@
+BC1EC1-7111544E0A37+111544E0A37U

fuzz/hfuzz_input/deserialize_address/input/id-000076_src-000061_op-havoc_rep-8

@@ -0,0 +1 @@
+BC1C1;71;.11-7111544-7*1'1-7*115C17*1'1-7*115C1CA;71;1C1;71;711-711-7111514E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000077_src-000006_op-flip1_pos-30

@@ -0,0 +1 @@
+tb1118755mmmmmmmmmm9264mmmmmmm132772648

fuzz/hfuzz_input/deserialize_address/input/id-000077_sync-deserialize_address_0_src-000043

@@ -0,0 +1 @@
+BC1C1;71;711-710154C1C1;71;711-4E083'1-7111544E0837U

fuzz/hfuzz_input/deserialize_address/input/id-000080_src-000006_op-havoc_rep-2

@@ -0,0 +1 @@
+tb1118755mmmnmmmmmm9264mmb1mmmmm93277264