From f6668d8ee33604e7c2f8d4e344daf9154c53b4ba Mon Sep 17 00:00:00 2001 From: Jeff Bencin Date: Tue, 10 Oct 2023 11:11:10 -0400 Subject: [PATCH] chore: Apply new `rustfmt` config from parent commit to all files --- clarity/src/libclarity.rs | 6 +- clarity/src/vm/analysis/analysis_db.rs | 1 - .../src/vm/analysis/arithmetic_checker/mod.rs | 17 +- .../vm/analysis/arithmetic_checker/tests.rs | 10 +- .../contract_interface_builder/mod.rs | 10 +- clarity/src/vm/analysis/errors.rs | 4 +- clarity/src/vm/analysis/mod.rs | 21 +- .../src/vm/analysis/read_only_checker/mod.rs | 17 +- .../vm/analysis/read_only_checker/tests.rs | 5 +- clarity/src/vm/analysis/tests/mod.rs | 3 +- .../src/vm/analysis/trait_checker/tests.rs | 6 +- .../src/vm/analysis/type_checker/contexts.rs | 7 +- clarity/src/vm/analysis/type_checker/mod.rs | 25 +-- .../analysis/type_checker/v2_05/contexts.rs | 9 +- .../src/vm/analysis/type_checker/v2_05/mod.rs | 29 ++- .../type_checker/v2_05/natives/maps.rs | 9 +- .../type_checker/v2_05/natives/mod.rs | 12 +- .../type_checker/v2_05/natives/options.rs | 6 +- .../type_checker/v2_05/natives/sequences.rs | 20 +- .../type_checker/v2_05/tests/assets.rs | 3 +- .../type_checker/v2_05/tests/contracts.rs | 18 +- .../analysis/type_checker/v2_05/tests/mod.rs | 16 +- .../vm/analysis/type_checker/v2_1/contexts.rs | 11 +- .../src/vm/analysis/type_checker/v2_1/mod.rs | 31 ++- .../type_checker/v2_1/natives/assets.rs | 4 +- .../type_checker/v2_1/natives/maps.rs | 9 +- .../analysis/type_checker/v2_1/natives/mod.rs | 17 +- .../type_checker/v2_1/natives/options.rs | 8 +- .../type_checker/v2_1/natives/sequences.rs | 18 +- .../type_checker/v2_1/tests/assets.rs | 7 +- .../type_checker/v2_1/tests/contracts.rs | 20 +- .../analysis/type_checker/v2_1/tests/mod.rs | 35 ++- clarity/src/vm/analysis/types.rs | 15 +- clarity/src/vm/ast/definition_sorter/mod.rs | 6 +- clarity/src/vm/ast/definition_sorter/tests.rs | 3 +- clarity/src/vm/ast/errors.rs | 4 +- clarity/src/vm/ast/mod.rs | 32 ++- clarity/src/vm/ast/parser/v1.rs | 21 +- clarity/src/vm/ast/parser/v2/lexer/error.rs | 6 +- clarity/src/vm/ast/parser/v2/lexer/mod.rs | 10 +- clarity/src/vm/ast/parser/v2/lexer/token.rs | 3 +- clarity/src/vm/ast/parser/v2/mod.rs | 11 +- clarity/src/vm/ast/stack_depth_checker.rs | 4 +- clarity/src/vm/ast/sugar_expander/mod.rs | 6 +- clarity/src/vm/ast/types.rs | 5 +- clarity/src/vm/callables.rs | 13 +- clarity/src/vm/clarity.rs | 23 +- clarity/src/vm/contexts.rs | 34 ++- clarity/src/vm/contracts.rs | 3 +- clarity/src/vm/costs/mod.rs | 5 +- clarity/src/vm/coverage.rs | 15 +- clarity/src/vm/database/clarity_db.rs | 57 ++--- clarity/src/vm/database/clarity_store.rs | 10 +- clarity/src/vm/database/key_value_wrapper.rs | 17 +- clarity/src/vm/database/mod.rs | 3 +- clarity/src/vm/database/sqlite.rs | 2 - clarity/src/vm/database/structures.rs | 10 +- clarity/src/vm/diagnostic.rs | 3 +- clarity/src/vm/docs/contracts.rs | 14 +- clarity/src/vm/docs/mod.rs | 51 ++--- clarity/src/vm/errors.rs | 16 +- clarity/src/vm/events.rs | 5 +- clarity/src/vm/functions/arithmetic.rs | 15 +- clarity/src/vm/functions/assets.rs | 10 +- clarity/src/vm/functions/conversions.rs | 3 +- clarity/src/vm/functions/crypto.rs | 20 +- clarity/src/vm/functions/database.rs | 9 +- clarity/src/vm/functions/define.rs | 3 +- clarity/src/vm/functions/mod.rs | 17 +- clarity/src/vm/functions/options.rs | 3 +- clarity/src/vm/functions/principals.rs | 29 +-- clarity/src/vm/functions/sequences.rs | 15 +- clarity/src/vm/mod.rs | 55 +++-- clarity/src/vm/representations.rs | 13 +- clarity/src/vm/test_util/mod.rs | 21 +- clarity/src/vm/tests/assets.rs | 8 +- clarity/src/vm/tests/contracts.rs | 30 ++- clarity/src/vm/tests/datamaps.rs | 7 +- clarity/src/vm/tests/defines.rs | 5 +- clarity/src/vm/tests/mod.rs | 14 +- clarity/src/vm/tests/principals.rs | 25 +-- clarity/src/vm/tests/sequences.rs | 12 +- clarity/src/vm/tests/simple_apply_eval.rs | 37 ++-- clarity/src/vm/tests/traits.rs | 11 +- clarity/src/vm/types/mod.rs | 9 +- clarity/src/vm/types/serialization.rs | 32 ++- clarity/src/vm/types/signatures.rs | 15 +- clarity/src/vm/variables.rs | 8 +- clarity/src/vm/version.rs | 6 +- libsigner/src/events.rs | 15 +- libsigner/src/http.rs | 4 +- libsigner/src/libsigner.rs | 7 +- libsigner/src/runloop.rs | 7 +- libsigner/src/session.rs | 6 +- libsigner/src/tests/http.rs | 13 +- libsigner/src/tests/mod.rs | 9 +- libstackerdb/src/libstackerdb.rs | 20 +- libstackerdb/src/tests/mod.rs | 13 +- pox-locking/src/pox_1.rs | 3 +- pox-locking/src/pox_2.rs | 6 +- pox-locking/src/pox_3.rs | 9 +- stacks-common/src/address/c32.rs | 11 +- stacks-common/src/address/c32_old.rs | 5 +- stacks-common/src/address/mod.rs | 13 +- stacks-common/src/deps_common/bech32/mod.rs | 8 +- .../deps_common/bitcoin/blockdata/block.rs | 6 +- .../bitcoin/blockdata/constants.rs | 10 +- .../deps_common/bitcoin/blockdata/opcodes.rs | 6 +- .../deps_common/bitcoin/blockdata/script.rs | 12 +- .../bitcoin/blockdata/transaction.rs | 5 +- .../deps_common/bitcoin/network/address.rs | 5 +- .../deps_common/bitcoin/network/encodable.rs | 1 - .../deps_common/bitcoin/network/message.rs | 12 +- .../bitcoin/network/message_blockdata.rs | 9 +- .../bitcoin/network/message_network.rs | 4 +- .../src/deps_common/bitcoin/network/mod.rs | 4 +- .../deps_common/bitcoin/network/serialize.rs | 7 +- .../src/deps_common/bitcoin/util/hash.rs | 11 +- stacks-common/src/deps_common/ctrlc/error.rs | 3 +- stacks-common/src/deps_common/ctrlc/mod.rs | 3 +- .../src/deps_common/ctrlc/platform/mod.rs | 1 - .../deps_common/ctrlc/platform/unix/mod.rs | 6 +- .../deps_common/ctrlc/platform/windows/mod.rs | 4 +- stacks-common/src/deps_common/ctrlc/tests.rs | 3 +- stacks-common/src/deps_common/httparse/mod.rs | 9 +- stacks-common/src/libcommon.rs | 3 +- stacks-common/src/types/chainstate.rs | 31 +-- stacks-common/src/types/mod.rs | 19 +- stacks-common/src/util/chunked_encoding.rs | 7 +- stacks-common/src/util/hash.rs | 32 +-- stacks-common/src/util/log.rs | 11 +- stacks-common/src/util/mod.rs | 9 +- stacks-common/src/util/pipe.rs | 20 +- stacks-common/src/util/secp256k1.rs | 43 ++-- stacks-common/src/util/uint.rs | 6 +- stacks-common/src/util/vrf.rs | 36 ++-- stacks-signer/src/cli.rs | 8 +- stacks-signer/src/config.rs | 16 +- stacks-signer/src/main.rs | 50 ++--- stacks-signer/src/runloop.rs | 26 +-- stacks-signer/src/stacks_client.rs | 3 +- stacks-signer/src/utils.rs | 6 +- stackslib/src/blockstack_cli.rs | 22 +- stackslib/src/burnchains/affirmation.rs | 38 ++-- stackslib/src/burnchains/bitcoin/address.rs | 7 +- stackslib/src/burnchains/bitcoin/bits.rs | 57 +++-- stackslib/src/burnchains/bitcoin/blocks.rs | 59 +++-- stackslib/src/burnchains/bitcoin/indexer.rs | 69 +++--- stackslib/src/burnchains/bitcoin/messages.rs | 3 +- stackslib/src/burnchains/bitcoin/mod.rs | 12 +- stackslib/src/burnchains/bitcoin/network.rs | 24 +-- stackslib/src/burnchains/bitcoin/spv.rs | 41 ++-- stackslib/src/burnchains/burnchain.rs | 90 +++----- stackslib/src/burnchains/db.rs | 27 +-- stackslib/src/burnchains/indexer.rs | 8 +- stackslib/src/burnchains/mod.rs | 49 ++--- stackslib/src/burnchains/tests/affirmation.rs | 47 ++-- stackslib/src/burnchains/tests/burnchain.rs | 43 ++-- stackslib/src/burnchains/tests/db.rs | 29 ++- stackslib/src/burnchains/tests/mod.rs | 26 +-- stackslib/src/chainstate/burn/db/mod.rs | 23 +- .../src/chainstate/burn/db/processing.rs | 43 ++-- stackslib/src/chainstate/burn/db/sortdb.rs | 130 +++++------ stackslib/src/chainstate/burn/distribution.rs | 62 +++--- stackslib/src/chainstate/burn/mod.rs | 45 ++-- .../burn/operations/delegate_stx.rs | 35 ++- .../burn/operations/leader_block_commit.rs | 86 +++----- .../burn/operations/leader_key_register.rs | 53 ++--- .../src/chainstate/burn/operations/mod.rs | 54 ++--- .../chainstate/burn/operations/stack_stx.rs | 64 +++--- .../burn/operations/transfer_stx.rs | 59 +++-- .../burn/operations/user_burn_support.rs | 49 ++--- stackslib/src/chainstate/burn/sortition.rs | 53 ++--- stackslib/src/chainstate/coordinator/comm.rs | 6 +- stackslib/src/chainstate/coordinator/mod.rs | 88 ++++---- stackslib/src/chainstate/coordinator/tests.rs | 77 +++---- stackslib/src/chainstate/mod.rs | 1 - stackslib/src/chainstate/stacks/address.rs | 37 ++-- stackslib/src/chainstate/stacks/auth.rs | 54 ++--- stackslib/src/chainstate/stacks/block.rs | 57 ++--- .../chainstate/stacks/boot/contract_tests.rs | 61 +++--- stackslib/src/chainstate/stacks/boot/docs.rs | 3 +- stackslib/src/chainstate/stacks/boot/mod.rs | 90 ++++---- .../src/chainstate/stacks/boot/pox_2_tests.rs | 71 +++--- .../src/chainstate/stacks/boot/pox_3_tests.rs | 82 +++---- .../src/chainstate/stacks/db/accounts.rs | 32 ++- stackslib/src/chainstate/stacks/db/blocks.rs | 127 +++++------ .../src/chainstate/stacks/db/contracts.rs | 45 ++-- stackslib/src/chainstate/stacks/db/headers.rs | 21 +- stackslib/src/chainstate/stacks/db/mod.rs | 94 ++++---- .../src/chainstate/stacks/db/transactions.rs | 76 +++---- .../src/chainstate/stacks/db/unconfirmed.rs | 28 +-- stackslib/src/chainstate/stacks/events.rs | 7 +- stackslib/src/chainstate/stacks/index/bits.rs | 25 +-- .../src/chainstate/stacks/index/cache.rs | 46 ++-- stackslib/src/chainstate/stacks/index/file.rs | 35 +-- stackslib/src/chainstate/stacks/index/marf.rs | 22 +- stackslib/src/chainstate/stacks/index/mod.rs | 20 +- stackslib/src/chainstate/stacks/index/node.rs | 23 +- .../src/chainstate/stacks/index/proofs.rs | 29 +-- .../src/chainstate/stacks/index/storage.rs | 44 ++-- .../src/chainstate/stacks/index/test/cache.rs | 22 +- .../src/chainstate/stacks/index/test/file.rs | 10 +- .../src/chainstate/stacks/index/test/marf.rs | 19 +- .../src/chainstate/stacks/index/test/mod.rs | 23 +- .../src/chainstate/stacks/index/test/node.rs | 3 +- .../chainstate/stacks/index/test/proofs.rs | 3 +- .../chainstate/stacks/index/test/storage.rs | 8 +- .../src/chainstate/stacks/index/test/trie.rs | 6 +- stackslib/src/chainstate/stacks/index/trie.rs | 24 +-- .../src/chainstate/stacks/index/trie_sql.rs | 35 +-- stackslib/src/chainstate/stacks/miner.rs | 70 +++--- stackslib/src/chainstate/stacks/mod.rs | 73 +++---- .../src/chainstate/stacks/tests/accounting.rs | 47 ++-- .../stacks/tests/block_construction.rs | 57 ++--- .../stacks/tests/chain_histories.rs | 49 ++--- stackslib/src/chainstate/stacks/tests/mod.rs | 44 ++-- .../src/chainstate/stacks/transaction.rs | 39 ++-- stackslib/src/clarity_cli.rs | 104 +++------ stackslib/src/clarity_cli_main.rs | 4 +- stackslib/src/clarity_vm/clarity.rs | 111 ++++------ stackslib/src/clarity_vm/database/marf.rs | 30 ++- stackslib/src/clarity_vm/database/mod.rs | 46 ++-- .../src/clarity_vm/tests/analysis_costs.rs | 30 +-- stackslib/src/clarity_vm/tests/ast.rs | 16 +- stackslib/src/clarity_vm/tests/contracts.rs | 43 ++-- stackslib/src/clarity_vm/tests/costs.rs | 31 ++- .../src/clarity_vm/tests/epoch_switch.rs | 38 ++-- stackslib/src/clarity_vm/tests/events.rs | 26 +-- stackslib/src/clarity_vm/tests/forking.rs | 12 +- .../src/clarity_vm/tests/large_contract.rs | 38 ++-- .../src/clarity_vm/tests/simple_tests.rs | 3 +- stackslib/src/core/mempool.rs | 83 +++---- stackslib/src/core/mod.rs | 19 +- stackslib/src/core/tests/mod.rs | 100 ++++----- stackslib/src/cost_estimates/fee_medians.rs | 28 +-- .../src/cost_estimates/fee_rate_fuzzer.rs | 11 +- stackslib/src/cost_estimates/fee_scalar.rs | 29 +-- stackslib/src/cost_estimates/mod.rs | 12 +- stackslib/src/cost_estimates/pessimistic.rs | 21 +- stackslib/src/cost_estimates/tests/common.rs | 11 +- .../cost_estimates/tests/cost_estimators.rs | 39 ++-- .../src/cost_estimates/tests/fee_medians.rs | 27 ++- .../cost_estimates/tests/fee_rate_fuzzer.rs | 13 +- .../src/cost_estimates/tests/fee_scalar.rs | 32 ++- stackslib/src/cost_estimates/tests/metrics.rs | 3 +- stackslib/src/main.rs | 88 +++----- stackslib/src/monitoring/mod.rs | 28 ++- stackslib/src/net/asn.rs | 18 +- stackslib/src/net/atlas/db.rs | 40 ++-- stackslib/src/net/atlas/download.rs | 32 ++- stackslib/src/net/atlas/mod.rs | 15 +- stackslib/src/net/atlas/tests.rs | 22 +- stackslib/src/net/chat.rs | 84 +++----- stackslib/src/net/codec.rs | 64 +++--- stackslib/src/net/connection.rs | 75 +++---- stackslib/src/net/db.rs | 75 ++----- stackslib/src/net/dns.rs | 43 ++-- stackslib/src/net/download.rs | 86 +++----- stackslib/src/net/http.rs | 133 ++++-------- stackslib/src/net/inv.rs | 68 +++--- stackslib/src/net/mod.rs | 181 ++++++---------- stackslib/src/net/neighbors/comms.rs | 41 ++-- stackslib/src/net/neighbors/db.rs | 36 ++-- stackslib/src/net/neighbors/mod.rs | 46 ++-- stackslib/src/net/neighbors/neighbor.rs | 23 +- stackslib/src/net/neighbors/walk.rs | 52 ++--- stackslib/src/net/p2p.rs | 105 +++------ stackslib/src/net/poll.rs | 52 ++--- stackslib/src/net/prune.rs | 44 ++-- stackslib/src/net/relay.rs | 117 +++++----- stackslib/src/net/rpc.rs | 204 +++++++----------- stackslib/src/net/server.rs | 93 +++----- stackslib/src/net/stackerdb/config.rs | 34 ++- stackslib/src/net/stackerdb/db.rs | 34 ++- stackslib/src/net/stackerdb/mod.rs | 41 ++-- stackslib/src/net/stackerdb/sync.rs | 36 ++-- stackslib/src/net/stackerdb/tests/config.rs | 43 ++-- stackslib/src/net/stackerdb/tests/db.rs | 25 +-- stackslib/src/net/stackerdb/tests/sync.rs | 39 ++-- stackslib/src/net/stream.rs | 15 +- stackslib/src/net/tests/neighbors.rs | 19 +- stackslib/src/net/tests/stream.rs | 22 +- stackslib/src/util_lib/bloom.rs | 31 +-- stackslib/src/util_lib/boot.rs | 11 +- stackslib/src/util_lib/db.rs | 48 ++--- stackslib/src/util_lib/mod.rs | 11 +- stackslib/src/util_lib/strings.rs | 23 +- stx-genesis/build.rs | 9 +- stx-genesis/src/lib.rs | 4 +- .../burnchains/bitcoin_regtest_controller.rs | 56 ++--- .../src/burnchains/mocknet_controller.rs | 8 +- testnet/stacks-node/src/burnchains/mod.rs | 13 +- testnet/stacks-node/src/config.rs | 28 +-- testnet/stacks-node/src/event_dispatcher.rs | 35 ++- testnet/stacks-node/src/keychain.rs | 24 +-- testnet/stacks-node/src/main.rs | 18 +- .../stacks-node/src/monitoring/prometheus.rs | 3 +- testnet/stacks-node/src/neon_node.rs | 99 ++++----- testnet/stacks-node/src/node.rs | 69 +++--- testnet/stacks-node/src/run_loop/helium.rs | 6 +- testnet/stacks-node/src/run_loop/mod.rs | 25 +-- testnet/stacks-node/src/run_loop/neon.rs | 39 ++-- testnet/stacks-node/src/stacks_events.rs | 8 +- testnet/stacks-node/src/syncctl.rs | 10 +- testnet/stacks-node/src/tenure.rs | 13 +- .../stacks-node/src/tests/bitcoin_regtest.rs | 15 +- testnet/stacks-node/src/tests/epoch_205.rs | 76 +++---- testnet/stacks-node/src/tests/epoch_21.rs | 101 ++++----- testnet/stacks-node/src/tests/epoch_22.rs | 48 ++--- testnet/stacks-node/src/tests/epoch_23.rs | 21 +- testnet/stacks-node/src/tests/epoch_24.rs | 30 +-- testnet/stacks-node/src/tests/integrations.rs | 55 +++-- testnet/stacks-node/src/tests/mempool.rs | 33 ++- testnet/stacks-node/src/tests/mod.rs | 23 +- .../src/tests/neon_integrations.rs | 105 ++++----- testnet/stacks-node/src/tests/signer.rs | 37 ++-- testnet/stacks-node/src/tests/stackerdb.rs | 38 +--- 318 files changed, 3707 insertions(+), 5688 deletions(-) diff --git a/clarity/src/libclarity.rs b/clarity/src/libclarity.rs index dad6eac90..def9435db 100644 --- a/clarity/src/libclarity.rs +++ b/clarity/src/libclarity.rs @@ -63,10 +63,12 @@ pub extern crate stacks_common; pub mod vm; pub mod boot_util { + use std::convert::TryFrom; + + use stacks_common::types::chainstate::StacksAddress; + use crate::vm::representations::ContractName; use crate::vm::types::QualifiedContractIdentifier; - use stacks_common::types::chainstate::StacksAddress; - use std::convert::TryFrom; pub fn boot_code_id(name: &str, mainnet: bool) -> QualifiedContractIdentifier { let addr = boot_code_addr(mainnet); diff --git a/clarity/src/vm/analysis/analysis_db.rs b/clarity/src/vm/analysis/analysis_db.rs index 7fdfbdfab..b278bc5ef 100644 --- a/clarity/src/vm/analysis/analysis_db.rs +++ b/clarity/src/vm/analysis/analysis_db.rs @@ -26,7 +26,6 @@ use crate::vm::database::{ use crate::vm::representations::ClarityName; use crate::vm::types::signatures::FunctionSignature; use crate::vm::types::{FunctionType, QualifiedContractIdentifier, TraitIdentifier, TypeSignature}; - use crate::vm::ClarityVersion; pub struct AnalysisDatabase<'a> { diff --git a/clarity/src/vm/analysis/arithmetic_checker/mod.rs b/clarity/src/vm/analysis/arithmetic_checker/mod.rs index d258b39af..c38451c74 100644 --- a/clarity/src/vm/analysis/arithmetic_checker/mod.rs +++ b/clarity/src/vm/analysis/arithmetic_checker/mod.rs @@ -14,10 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::HashMap; + +pub use super::errors::{ + check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult, +}; +use super::AnalysisDatabase; use crate::vm::analysis::types::{AnalysisPass, ContractAnalysis}; use crate::vm::functions::define::{DefineFunctions, DefineFunctionsParsed}; -use crate::vm::functions::tuples; -use crate::vm::functions::NativeFunctions; +use crate::vm::functions::{tuples, NativeFunctions}; use crate::vm::representations::SymbolicExpressionType::{ Atom, AtomValue, Field, List, LiteralValue, TraitReference, }; @@ -25,17 +30,9 @@ use crate::vm::representations::{ClarityName, SymbolicExpression, SymbolicExpres use crate::vm::types::{ parse_name_type_pairs, PrincipalData, TupleTypeSignature, TypeSignature, Value, }; - use crate::vm::variables::NativeVariables; -use std::collections::HashMap; - use crate::vm::ClarityVersion; -pub use super::errors::{ - check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult, -}; -use super::AnalysisDatabase; - #[cfg(test)] mod tests; diff --git a/clarity/src/vm/analysis/arithmetic_checker/tests.rs b/clarity/src/vm/analysis/arithmetic_checker/tests.rs index d1a1de245..4ad02c08d 100644 --- a/clarity/src/vm/analysis/arithmetic_checker/tests.rs +++ b/clarity/src/vm/analysis/arithmetic_checker/tests.rs @@ -14,18 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::ClarityVersion; #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; use stacks_common::types::StacksEpochId; -use crate::vm::analysis::mem_type_check; -use crate::vm::analysis::{ - arithmetic_checker::ArithmeticOnlyChecker, arithmetic_checker::Error, - arithmetic_checker::Error::*, ContractAnalysis, -}; +use crate::vm::analysis::arithmetic_checker::Error::*; +use crate::vm::analysis::arithmetic_checker::{ArithmeticOnlyChecker, Error}; +use crate::vm::analysis::{mem_type_check, ContractAnalysis}; use crate::vm::ast::parse; use crate::vm::costs::LimitedCostTracker; use crate::vm::functions::define::DefineFunctions; @@ -33,6 +30,7 @@ use crate::vm::functions::NativeFunctions; use crate::vm::tests::test_clarity_versions; use crate::vm::types::QualifiedContractIdentifier; use crate::vm::variables::NativeVariables; +use crate::vm::ClarityVersion; /// Checks whether or not a contract only contains arithmetic expressions (for example, defining a /// map would not pass this check). diff --git a/clarity/src/vm/analysis/contract_interface_builder/mod.rs b/clarity/src/vm/analysis/contract_interface_builder/mod.rs index 201d2e231..a418d9f66 100644 --- a/clarity/src/vm/analysis/contract_interface_builder/mod.rs +++ b/clarity/src/vm/analysis/contract_interface_builder/mod.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{BTreeMap, BTreeSet}; + use stacks_common::types::StacksEpochId; use crate::vm::analysis::types::ContractAnalysis; @@ -21,10 +23,7 @@ use crate::vm::types::signatures::CallableSubtype; use crate::vm::types::{ FixedFunction, FunctionArg, FunctionType, TupleTypeSignature, TypeSignature, }; -use crate::vm::ClarityName; -use std::collections::{BTreeMap, BTreeSet}; - -use crate::vm::ClarityVersion; +use crate::vm::{ClarityName, ClarityVersion}; pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> ContractInterface { let mut contract_interface = @@ -180,8 +179,9 @@ impl ContractInterfaceAtomType { } pub fn from_type_signature(sig: &TypeSignature) -> ContractInterfaceAtomType { + use crate::vm::types::SequenceSubtype::*; + use crate::vm::types::StringSubtype::*; use crate::vm::types::TypeSignature::*; - use crate::vm::types::{SequenceSubtype::*, StringSubtype::*}; match sig { NoType => ContractInterfaceAtomType::none, diff --git a/clarity/src/vm/analysis/errors.rs b/clarity/src/vm/analysis/errors.rs index bb51b42b4..9aeb878f2 100644 --- a/clarity/src/vm/analysis/errors.rs +++ b/clarity/src/vm/analysis/errors.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::{error, fmt}; + use crate::vm::costs::{CostErrors, ExecutionCost}; use crate::vm::diagnostic::{DiagnosableError, Diagnostic}; use crate::vm::representations::SymbolicExpression; use crate::vm::types::{TraitIdentifier, TupleTypeSignature, TypeSignature, Value}; -use std::error; -use std::fmt; pub type CheckResult = Result; diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs index b83f4a4fd..50c5b1e7d 100644 --- a/clarity/src/vm/analysis/mod.rs +++ b/clarity/src/vm/analysis/mod.rs @@ -24,28 +24,23 @@ pub mod trait_checker; pub mod type_checker; pub mod types; -use crate::vm::database::MemoryBackingStore; use stacks_common::types::StacksEpochId; -pub use self::types::{AnalysisPass, ContractAnalysis}; - -use crate::vm::costs::LimitedCostTracker; -use crate::vm::database::STORE_CONTRACT_SRC_INTERFACE; -use crate::vm::representations::SymbolicExpression; -use crate::vm::types::{QualifiedContractIdentifier, TypeSignature}; -use crate::vm::ClarityVersion; - pub use self::analysis_db::AnalysisDatabase; -pub use self::errors::{CheckError, CheckErrors, CheckResult}; - use self::arithmetic_checker::ArithmeticOnlyChecker; use self::contract_interface_builder::build_contract_interface; +pub use self::errors::{CheckError, CheckErrors, CheckResult}; use self::read_only_checker::ReadOnlyChecker; use self::trait_checker::TraitChecker; use self::type_checker::v2_05::TypeChecker as TypeChecker2_05; use self::type_checker::v2_1::TypeChecker as TypeChecker2_1; -use crate::vm::ast::build_ast_with_rules; -use crate::vm::ast::ASTRules; +pub use self::types::{AnalysisPass, ContractAnalysis}; +use crate::vm::ast::{build_ast_with_rules, ASTRules}; +use crate::vm::costs::LimitedCostTracker; +use crate::vm::database::{MemoryBackingStore, STORE_CONTRACT_SRC_INTERFACE}; +use crate::vm::representations::SymbolicExpression; +use crate::vm::types::{QualifiedContractIdentifier, TypeSignature}; +use crate::vm::ClarityVersion; /// Used by CLI tools like the docs generator. Not used in production pub fn mem_type_check( diff --git a/clarity/src/vm/analysis/read_only_checker/mod.rs b/clarity/src/vm/analysis/read_only_checker/mod.rs index 7b2491f35..8261eb8ee 100644 --- a/clarity/src/vm/analysis/read_only_checker/mod.rs +++ b/clarity/src/vm/analysis/read_only_checker/mod.rs @@ -14,12 +14,17 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::HashMap; + use stacks_common::types::StacksEpochId; +pub use super::errors::{ + check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult, +}; +use super::AnalysisDatabase; use crate::vm::analysis::types::{AnalysisPass, ContractAnalysis}; use crate::vm::functions::define::DefineFunctionsParsed; -use crate::vm::functions::tuples; -use crate::vm::functions::NativeFunctions; +use crate::vm::functions::{tuples, NativeFunctions}; use crate::vm::representations::SymbolicExpressionType::{ Atom, AtomValue, Field, List, LiteralValue, TraitReference, }; @@ -27,17 +32,9 @@ use crate::vm::representations::{ClarityName, SymbolicExpression, SymbolicExpres use crate::vm::types::{ parse_name_type_pairs, PrincipalData, TupleTypeSignature, TypeSignature, Value, }; - use crate::vm::variables::NativeVariables; -use std::collections::HashMap; - use crate::vm::ClarityVersion; -pub use super::errors::{ - check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult, -}; -use super::AnalysisDatabase; - #[cfg(test)] mod tests; diff --git a/clarity/src/vm/analysis/read_only_checker/tests.rs b/clarity/src/vm/analysis/read_only_checker/tests.rs index ea9802da9..828e5d42b 100644 --- a/clarity/src/vm/analysis/read_only_checker/tests.rs +++ b/clarity/src/vm/analysis/read_only_checker/tests.rs @@ -18,16 +18,15 @@ use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; +use stacks_common::types::StacksEpochId; -use crate::vm::analysis::type_check; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check; -use crate::vm::analysis::{CheckError, CheckErrors}; +use crate::vm::analysis::{type_check, CheckError, CheckErrors}; use crate::vm::ast::parse; use crate::vm::database::MemoryBackingStore; use crate::vm::tests::test_clarity_versions; use crate::vm::types::QualifiedContractIdentifier; use crate::vm::ClarityVersion; -use stacks_common::types::StacksEpochId; #[test] fn test_argument_count_violations() { diff --git a/clarity/src/vm/analysis/tests/mod.rs b/clarity/src/vm/analysis/tests/mod.rs index 2f64266f7..adb36b94f 100644 --- a/clarity/src/vm/analysis/tests/mod.rs +++ b/clarity/src/vm/analysis/tests/mod.rs @@ -16,8 +16,7 @@ use crate::vm::analysis::errors::CheckErrors; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check; -use crate::vm::analysis::AnalysisDatabase; -use crate::vm::analysis::{type_check, ContractAnalysis}; +use crate::vm::analysis::{type_check, AnalysisDatabase, ContractAnalysis}; use crate::vm::ast::parse; #[test] diff --git a/clarity/src/vm/analysis/trait_checker/tests.rs b/clarity/src/vm/analysis/trait_checker/tests.rs index c2f133861..bc3f99628 100644 --- a/clarity/src/vm/analysis/trait_checker/tests.rs +++ b/clarity/src/vm/analysis/trait_checker/tests.rs @@ -18,17 +18,17 @@ use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; +use stacks_common::types::StacksEpochId; +use crate::vm::analysis::contract_interface_builder::build_contract_interface; use crate::vm::analysis::errors::CheckErrors; -use crate::vm::analysis::{contract_interface_builder::build_contract_interface, AnalysisDatabase}; -use crate::vm::analysis::{type_check, CheckError}; +use crate::vm::analysis::{type_check, AnalysisDatabase, CheckError}; use crate::vm::ast::errors::ParseErrors; use crate::vm::ast::{build_ast, parse}; use crate::vm::database::MemoryBackingStore; use crate::vm::tests::test_clarity_versions; use crate::vm::types::{QualifiedContractIdentifier, TypeSignature}; use crate::vm::ClarityVersion; -use stacks_common::types::StacksEpochId; #[apply(test_clarity_versions)] fn test_dynamic_dispatch_by_defining_trait( diff --git a/clarity/src/vm/analysis/type_checker/contexts.rs b/clarity/src/vm/analysis/type_checker/contexts.rs index 8df33bad6..03968a186 100644 --- a/clarity/src/vm/analysis/type_checker/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/contexts.rs @@ -20,11 +20,8 @@ use stacks_common::types::StacksEpochId; use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult}; use crate::vm::types::signatures::CallableSubtype; -use crate::vm::{ - types::{TraitIdentifier, TypeSignature}, - ClarityName, SymbolicExpression, -}; -use crate::vm::{ClarityVersion, MAX_CONTEXT_DEPTH}; +use crate::vm::types::{TraitIdentifier, TypeSignature}; +use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression, MAX_CONTEXT_DEPTH}; #[derive(Debug, PartialEq, Eq, Clone)] pub struct TypeMap { diff --git a/clarity/src/vm/analysis/type_checker/mod.rs b/clarity/src/vm/analysis/type_checker/mod.rs index 70ed9e175..862d4d7b3 100644 --- a/clarity/src/vm/analysis/type_checker/mod.rs +++ b/clarity/src/vm/analysis/type_checker/mod.rs @@ -20,23 +20,20 @@ pub mod v2_1; use stacks_common::types::StacksEpochId; -use crate::vm::{ - costs::{analysis_typecheck_cost, CostTracker, LimitedCostTracker}, - types::{ - signatures::{CallableSubtype, FunctionArgSignature, FunctionReturnsSignature}, - FixedFunction, FunctionType, PrincipalData, SequenceSubtype, StringSubtype, TypeSignature, - }, - ClarityVersion, Value, +use super::errors::{ + check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckError, + CheckErrors, CheckResult, }; - pub use super::types::{AnalysisPass, ContractAnalysis}; -use super::{ - errors::{ - check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckError, - CheckErrors, CheckResult, - }, - AnalysisDatabase, +use super::AnalysisDatabase; +use crate::vm::costs::{analysis_typecheck_cost, CostTracker, LimitedCostTracker}; +use crate::vm::types::signatures::{ + CallableSubtype, FunctionArgSignature, FunctionReturnsSignature, }; +use crate::vm::types::{ + FixedFunction, FunctionType, PrincipalData, SequenceSubtype, StringSubtype, TypeSignature, +}; +use crate::vm::{ClarityVersion, Value}; impl FunctionType { pub fn check_args( diff --git a/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs b/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs index 743039476..8e23dd082 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs @@ -14,15 +14,14 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::representations::{ClarityName, SymbolicExpression}; -use crate::vm::types::signatures::FunctionSignature; -use crate::vm::types::{FunctionType, TraitIdentifier, TypeSignature}; use std::collections::{BTreeMap, HashMap, HashSet}; -use crate::vm::contexts::MAX_CONTEXT_DEPTH; - use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult}; use crate::vm::analysis::types::ContractAnalysis; +use crate::vm::contexts::MAX_CONTEXT_DEPTH; +use crate::vm::representations::{ClarityName, SymbolicExpression}; +use crate::vm::types::signatures::FunctionSignature; +use crate::vm::types::{FunctionType, TraitIdentifier, TypeSignature}; pub struct ContractContext { map_types: HashMap, diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs index 243003ce8..ad80733f8 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs @@ -18,8 +18,21 @@ pub mod contexts; //mod maps; pub mod natives; +use std::collections::{BTreeMap, HashMap}; +use std::convert::TryInto; + use stacks_common::types::StacksEpochId; +use self::contexts::ContractContext; +pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; +use super::contexts::{TypeMap, TypingContext}; +use super::{AnalysisPass, ContractAnalysis}; +pub use crate::vm::analysis::errors::{ + check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult, +}; +use crate::vm::analysis::AnalysisDatabase; +use crate::vm::contexts::Environment; +use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{ analysis_typecheck_cost, cost_functions, runtime_cost, ClarityCostFunctionReference, CostErrors, CostOverflowingMath, CostTracker, ExecutionCost, LimitedCostTracker, @@ -37,22 +50,6 @@ use crate::vm::types::{ }; use crate::vm::variables::NativeVariables; use crate::vm::ClarityVersion; -use std::collections::{BTreeMap, HashMap}; -use std::convert::TryInto; - -use super::{AnalysisPass, ContractAnalysis}; -use crate::vm::analysis::AnalysisDatabase; - -use self::contexts::ContractContext; -use super::contexts::{TypeMap, TypingContext}; - -pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; - -pub use crate::vm::analysis::errors::{ - check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult, -}; -use crate::vm::contexts::Environment; -use crate::vm::costs::cost_functions::ClarityCostFunction; #[cfg(test)] mod tests; diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs index 556a8766b..497a01da2 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs @@ -16,19 +16,16 @@ use stacks_common::types::StacksEpochId; -use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; -use crate::vm::types::{PrincipalData, TypeSignature, Value}; - -use crate::vm::functions::tuples; - use super::check_special_tuple_cons; use crate::vm::analysis::type_checker::v2_05::{ check_arguments_at_least, no_type, CheckError, CheckErrors, TypeChecker, TypeResult, TypingContext, }; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, cost_functions, runtime_cost}; +use crate::vm::functions::tuples; +use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; +use crate::vm::types::{PrincipalData, TypeSignature, Value}; pub fn check_special_fetch_entry( checker: &mut TypeChecker, diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs index f1dcc89c8..67a90ae5a 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs @@ -14,12 +14,18 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryFrom; + use stacks_common::types::StacksEpochId; use super::{ check_argument_count, check_arguments_at_least, no_type, TypeChecker, TypeResult, TypingContext, }; use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult}; +use crate::vm::costs::cost_functions::ClarityCostFunction; +use crate::vm::costs::{ + analysis_typecheck_cost, cost_functions, runtime_cost, CostOverflowingMath, +}; use crate::vm::errors::{Error as InterpError, RuntimeErrorType}; use crate::vm::functions::{handle_binding_list, NativeFunctions}; use crate::vm::types::{ @@ -28,12 +34,6 @@ use crate::vm::types::{ MAX_VALUE_SIZE, }; use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression, SymbolicExpressionType}; -use std::convert::TryFrom; - -use crate::vm::costs::cost_functions::ClarityCostFunction; -use crate::vm::costs::{ - analysis_typecheck_cost, cost_functions, runtime_cost, CostOverflowingMath, -}; mod assets; mod maps; diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs index 27fe92f9c..b04f38b44 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs @@ -16,16 +16,14 @@ use stacks_common::types::StacksEpochId; -use crate::vm::representations::{ClarityName, SymbolicExpression}; -use crate::vm::types::TypeSignature; - use crate::vm::analysis::type_checker::v2_05::{ check_argument_count, check_arguments_at_least, no_type, CheckError, CheckErrors, TypeChecker, TypeResult, TypingContext, }; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, cost_functions, runtime_cost}; +use crate::vm::representations::{ClarityName, SymbolicExpression}; +use crate::vm::types::TypeSignature; pub fn check_special_okay( checker: &mut TypeChecker, diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs index 7f865526b..48978dcef 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs @@ -14,26 +14,24 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use stacks_common::types::StacksEpochId; +use std::convert::{TryFrom, TryInto}; -use crate::vm::functions::NativeFunctions; -use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; -pub use crate::vm::types::signatures::{BufferLength, ListTypeData, StringUTF8Length, BUFF_1}; -use crate::vm::types::{FunctionType, TypeSignature}; -use crate::vm::types::{SequenceSubtype::*, StringSubtype::*}; -use crate::vm::types::{Value, MAX_VALUE_SIZE}; -use crate::vm::ClarityVersion; -use std::convert::TryFrom; -use std::convert::TryInto; +use stacks_common::types::StacksEpochId; use super::{SimpleNativeFunction, TypedNativeFunction}; use crate::vm::analysis::type_checker::v2_05::{ check_argument_count, check_arguments_at_least, no_type, CheckErrors, CheckResult, TypeChecker, TypeResult, TypingContext, }; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, cost_functions, runtime_cost}; +use crate::vm::functions::NativeFunctions; +use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; +pub use crate::vm::types::signatures::{BufferLength, ListTypeData, StringUTF8Length, BUFF_1}; +use crate::vm::types::SequenceSubtype::*; +use crate::vm::types::StringSubtype::*; +use crate::vm::types::{FunctionType, TypeSignature, Value, MAX_VALUE_SIZE}; +use crate::vm::ClarityVersion; fn get_simple_native_or_user_define( function_name: &str, diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs index a858c531d..918e09967 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryInto; + use stacks_common::types::StacksEpochId; use crate::vm::analysis::errors::CheckErrors; @@ -24,7 +26,6 @@ use crate::vm::types::{ QualifiedContractIdentifier, SequenceSubtype, StringSubtype, TypeSignature, }; use crate::vm::ClarityVersion; -use std::convert::TryInto; fn string_ascii_type(size: u32) -> TypeSignature { TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII( diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs index 73c109382..edab6db39 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs @@ -14,23 +14,19 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use assert_json_diff; -use serde_json; use stacks_common::types::StacksEpochId; +use {assert_json_diff, serde_json}; +use crate::vm::analysis::contract_interface_builder::build_contract_interface; use crate::vm::analysis::errors::CheckErrors; -use crate::vm::analysis::mem_type_check; -use crate::vm::analysis::type_check; -use crate::vm::analysis::{contract_interface_builder::build_contract_interface, AnalysisDatabase}; +use crate::vm::analysis::{ + mem_type_check, type_check, AnalysisDatabase, CheckError, ContractAnalysis, +}; use crate::vm::ast::parse; +use crate::vm::costs::LimitedCostTracker; use crate::vm::database::MemoryBackingStore; use crate::vm::types::QualifiedContractIdentifier; -use crate::vm::ClarityVersion; -use crate::vm::{ - analysis::{CheckError, ContractAnalysis}, - costs::LimitedCostTracker, - SymbolicExpression, -}; +use crate::vm::{ClarityVersion, SymbolicExpression}; const SIMPLE_TOKENS: &str = "(define-map tokens { account: principal } { balance: uint }) (define-read-only (my-get-token-balance (account principal)) diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs index 6e321e50c..22b87e425 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs @@ -14,30 +14,28 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryInto; + use stacks_common::types::StacksEpochId; use crate::vm::analysis::errors::CheckErrors; -use crate::vm::analysis::mem_type_check; -use crate::vm::analysis::type_check; use crate::vm::analysis::type_checker::v2_05::{TypeChecker, TypeResult, TypingContext}; use crate::vm::analysis::types::ContractAnalysis; -use crate::vm::analysis::AnalysisDatabase; +use crate::vm::analysis::{mem_type_check, type_check, AnalysisDatabase}; use crate::vm::ast::errors::ParseErrors; use crate::vm::ast::{build_ast, parse}; use crate::vm::contexts::OwnedEnvironment; +use crate::vm::database::MemoryBackingStore; use crate::vm::representations::SymbolicExpression; +use crate::vm::types::SequenceSubtype::*; +use crate::vm::types::StringSubtype::*; +use crate::vm::types::TypeSignature::{BoolType, IntType, PrincipalType, SequenceType, UIntType}; use crate::vm::types::{ FixedFunction, FunctionType, PrincipalData, QualifiedContractIdentifier, TypeSignature, Value, BUFF_32, BUFF_64, }; use crate::vm::ClarityVersion; -use crate::vm::database::MemoryBackingStore; -use crate::vm::types::TypeSignature::{BoolType, IntType, PrincipalType, SequenceType, UIntType}; -use crate::vm::types::{SequenceSubtype::*, StringSubtype::*}; - -use std::convert::TryInto; - mod assets; mod contracts; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs b/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs index 3218794b6..95b856b88 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs @@ -14,16 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{BTreeMap, HashMap, HashSet}; + +use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult}; +use crate::vm::analysis::types::ContractAnalysis; +use crate::vm::contexts::MAX_CONTEXT_DEPTH; use crate::vm::representations::{ClarityName, SymbolicExpression}; use crate::vm::types::signatures::{CallableSubtype, FunctionSignature}; use crate::vm::types::{FunctionType, QualifiedContractIdentifier, TraitIdentifier, TypeSignature}; use crate::vm::ClarityVersion; -use std::collections::{BTreeMap, HashMap, HashSet}; - -use crate::vm::contexts::MAX_CONTEXT_DEPTH; - -use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult}; -use crate::vm::analysis::types::ContractAnalysis; enum TraitContext { /// Traits stored in this context use the trait type-checking behavior defined in Clarity1 diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs index 457b18dae..1686c5c2a 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs @@ -17,8 +17,22 @@ pub mod contexts; pub mod natives; +use std::collections::{BTreeMap, HashMap}; +use std::convert::TryInto; + use stacks_common::types::StacksEpochId; +use self::contexts::ContractContext; +pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; +use super::contexts::{TypeMap, TypingContext}; +use super::{AnalysisPass, ContractAnalysis}; +pub use crate::vm::analysis::errors::{ + check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckError, + CheckErrors, CheckResult, +}; +use crate::vm::analysis::AnalysisDatabase; +use crate::vm::contexts::Environment; +use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{ analysis_typecheck_cost, cost_functions, runtime_cost, ClarityCostFunctionReference, CostErrors, CostOverflowingMath, CostTracker, ExecutionCost, LimitedCostTracker, @@ -39,25 +53,8 @@ use crate::vm::types::{ TypeSignature, Value, MAX_TYPE_DEPTH, }; use crate::vm::variables::NativeVariables; -use std::collections::{BTreeMap, HashMap}; -use std::convert::TryInto; - use crate::vm::ClarityVersion; -use self::contexts::ContractContext; -use super::contexts::{TypeMap, TypingContext}; -use super::{AnalysisPass, ContractAnalysis}; -use crate::vm::analysis::AnalysisDatabase; - -pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; - -pub use crate::vm::analysis::errors::{ - check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckError, - CheckErrors, CheckResult, -}; -use crate::vm::contexts::Environment; -use crate::vm::costs::cost_functions::ClarityCostFunction; - #[cfg(test)] pub mod tests; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs index f22ab4104..65ad45233 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs @@ -14,8 +14,9 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use super::{no_type, FunctionType, TypeChecker, TypeResult, TypingContext}; +use stacks_common::consts::TOKEN_TRANSFER_MEMO_LENGTH; +use super::{no_type, FunctionType, TypeChecker, TypeResult, TypingContext}; use crate::vm::analysis::errors::{check_argument_count, CheckError, CheckErrors, CheckResult}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{cost_functions, runtime_cost}; @@ -24,7 +25,6 @@ use crate::vm::types::{ BlockInfoProperty, BufferLength, SequenceSubtype, TupleTypeSignature, TypeSignature, MAX_VALUE_SIZE, }; -use stacks_common::consts::TOKEN_TRANSFER_MEMO_LENGTH; pub fn check_special_get_owner( checker: &mut TypeChecker, diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs index 767fec341..7ce4cfad2 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs @@ -16,18 +16,15 @@ use stacks_common::types::StacksEpochId; -use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; -use crate::vm::types::{PrincipalData, TypeSignature, Value}; - -use crate::vm::functions::tuples; - use super::check_special_tuple_cons; use crate::vm::analysis::type_checker::v2_1::{ check_arguments_at_least, CheckError, CheckErrors, TypeChecker, TypeResult, TypingContext, }; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, cost_functions, runtime_cost}; +use crate::vm::functions::tuples; +use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; +use crate::vm::types::{PrincipalData, TypeSignature, Value}; pub fn check_special_fetch_entry( checker: &mut TypeChecker, diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs index 948fb5273..55401f181 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs @@ -14,21 +14,25 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryFrom; + use stacks_common::types::StacksEpochId; use super::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, no_type, TypeChecker, TypeResult, TypingContext, }; -use std::convert::TryFrom; - use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult}; +use crate::vm::costs::cost_functions::ClarityCostFunction; +use crate::vm::costs::{ + analysis_typecheck_cost, cost_functions, runtime_cost, CostOverflowingMath, +}; use crate::vm::errors::{Error as InterpError, RuntimeErrorType}; use crate::vm::functions::{handle_binding_list, NativeFunctions}; use crate::vm::types::signatures::{ - CallableSubtype, FunctionArgSignature, FunctionReturnsSignature, SequenceSubtype, + CallableSubtype, FunctionArgSignature, FunctionReturnsSignature, SequenceSubtype, ASCII_40, + UTF8_40, }; -use crate::vm::types::signatures::{ASCII_40, UTF8_40}; use crate::vm::types::TypeSignature::SequenceType; use crate::vm::types::{ BlockInfoProperty, BufferLength, BurnBlockInfoProperty, FixedFunction, FunctionArg, @@ -37,11 +41,6 @@ use crate::vm::types::{ }; use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression, SymbolicExpressionType}; -use crate::vm::costs::cost_functions::ClarityCostFunction; -use crate::vm::costs::{ - analysis_typecheck_cost, cost_functions, runtime_cost, CostOverflowingMath, -}; - mod assets; mod conversions; mod maps; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs index 8b2ab6ab1..207308745 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs @@ -16,19 +16,17 @@ use stacks_common::types::StacksEpochId; -use crate::vm::representations::{ClarityName, SymbolicExpression}; -use crate::vm::types::TypeSignature; -use crate::vm::ClarityVersion; - use super::{ check_argument_count, check_arguments_at_least, no_type, CheckError, CheckErrors, TypeChecker, TypeResult, }; use crate::vm::analysis::type_checker::contexts::TypingContext; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, cost_functions, runtime_cost}; +use crate::vm::representations::{ClarityName, SymbolicExpression}; use crate::vm::types::signatures::CallableSubtype; +use crate::vm::types::TypeSignature; +use crate::vm::ClarityVersion; pub fn check_special_okay( checker: &mut TypeChecker, diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs index 66b8c8021..5317487d7 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs @@ -14,25 +14,23 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use stacks_common::types::StacksEpochId; +use std::convert::{TryFrom, TryInto}; -use crate::vm::functions::NativeFunctions; -use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; -pub use crate::vm::types::signatures::{BufferLength, ListTypeData, StringUTF8Length, BUFF_1}; -use crate::vm::types::{FunctionType, TypeSignature}; -use crate::vm::types::{SequenceSubtype::*, StringSubtype::*}; -use crate::vm::types::{Value, MAX_VALUE_SIZE}; -use std::convert::TryFrom; -use std::convert::TryInto; +use stacks_common::types::StacksEpochId; use super::{SimpleNativeFunction, TypedNativeFunction}; use crate::vm::analysis::type_checker::v2_1::{ check_argument_count, check_arguments_at_least, CheckErrors, CheckResult, TypeChecker, TypeResult, TypingContext, }; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, cost_functions, runtime_cost}; +use crate::vm::functions::NativeFunctions; +use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; +pub use crate::vm::types::signatures::{BufferLength, ListTypeData, StringUTF8Length, BUFF_1}; +use crate::vm::types::SequenceSubtype::*; +use crate::vm::types::StringSubtype::*; +use crate::vm::types::{FunctionType, TypeSignature, Value, MAX_VALUE_SIZE}; use crate::vm::ClarityVersion; fn get_simple_native_or_user_define( diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs index aed8e3c01..8989fb295 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs @@ -14,12 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use super::contracts::type_check; +use std::convert::TryInto; + #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; +use stacks_common::types::StacksEpochId; +use super::contracts::type_check; use crate::vm::analysis::errors::CheckErrors; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check; use crate::vm::analysis::AnalysisDatabase; @@ -30,8 +33,6 @@ use crate::vm::types::{ QualifiedContractIdentifier, SequenceSubtype, StringSubtype, TypeSignature, }; use crate::vm::ClarityVersion; -use stacks_common::types::StacksEpochId; -use std::convert::TryInto; fn string_ascii_type(size: u32) -> TypeSignature { TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII( diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs index eb6473e8a..6f700df9a 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs @@ -17,14 +17,18 @@ use std::convert::TryFrom; use std::fs::read_to_string; -use assert_json_diff; -use serde_json; +use stacks_common::types::StacksEpochId; +use {assert_json_diff, serde_json}; +use crate::vm::analysis::contract_interface_builder::build_contract_interface; use crate::vm::analysis::errors::CheckErrors; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check; -use crate::vm::analysis::{contract_interface_builder::build_contract_interface, AnalysisDatabase}; -use crate::vm::analysis::{mem_type_check as mem_run_analysis, run_analysis, CheckResult}; +use crate::vm::analysis::{ + mem_type_check as mem_run_analysis, run_analysis, AnalysisDatabase, CheckError, CheckResult, + ContractAnalysis, +}; use crate::vm::ast::parse; +use crate::vm::costs::LimitedCostTracker; use crate::vm::database::MemoryBackingStore; use crate::vm::errors::Error; use crate::vm::tests::test_clarity_versions; @@ -32,13 +36,7 @@ use crate::vm::types::signatures::CallableSubtype; use crate::vm::types::{ PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, TypeSignature, }; -use crate::vm::ContractName; -use crate::vm::{ - analysis::{CheckError, ContractAnalysis}, - costs::LimitedCostTracker, - ClarityVersion, SymbolicExpression, -}; -use stacks_common::types::StacksEpochId; +use crate::vm::{ClarityVersion, ContractName, SymbolicExpression}; fn mem_type_check_v1(snippet: &str) -> CheckResult<(Option, ContractAnalysis)> { mem_run_analysis(snippet, ClarityVersion::Clarity1, StacksEpochId::latest()) diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs index 4aff12aef..24263c7a8 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs @@ -14,42 +14,37 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::{TryFrom, TryInto}; + #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; +use stacks_common::types::StacksEpochId; +use super::CheckResult; use crate::vm::analysis::errors::CheckErrors; -use crate::vm::analysis::mem_type_check as mem_run_analysis; use crate::vm::analysis::type_checker::v2_1::{TypeChecker, TypeResult, TypingContext}; +use crate::vm::analysis::type_checker::SequenceSubtype; use crate::vm::analysis::types::ContractAnalysis; -use crate::vm::analysis::AnalysisDatabase; +use crate::vm::analysis::{mem_type_check as mem_run_analysis, AnalysisDatabase}; use crate::vm::ast::errors::ParseErrors; use crate::vm::ast::{build_ast, parse}; use crate::vm::contexts::OwnedEnvironment; +use crate::vm::database::MemoryBackingStore; use crate::vm::representations::SymbolicExpression; +use crate::vm::tests::test_clarity_versions; +use crate::vm::types::signatures::TypeSignature::OptionalType; +use crate::vm::types::signatures::{ListTypeData, StringUTF8Length}; +use crate::vm::types::SequenceSubtype::*; +use crate::vm::types::StringSubtype::*; +use crate::vm::types::TypeSignature::{BoolType, IntType, PrincipalType, SequenceType, UIntType}; +use crate::vm::types::Value::Sequence; use crate::vm::types::{ BufferLength, FixedFunction, FunctionType, PrincipalData, QualifiedContractIdentifier, TraitIdentifier, TypeSignature, Value, BUFF_1, BUFF_20, BUFF_21, BUFF_32, BUFF_64, }; -use crate::vm::{execute_v2, ClarityName}; -use stacks_common::types::StacksEpochId; - -use crate::vm::database::MemoryBackingStore; -use crate::vm::types::TypeSignature::{BoolType, IntType, PrincipalType, SequenceType, UIntType}; -use crate::vm::types::{SequenceSubtype::*, StringSubtype::*}; - -use crate::vm::types::signatures::TypeSignature::OptionalType; -use crate::vm::types::signatures::{ListTypeData, StringUTF8Length}; -use crate::vm::types::Value::Sequence; -use std::convert::TryFrom; -use std::convert::TryInto; - -use super::CheckResult; -use crate::vm::ClarityVersion; - -use crate::vm::analysis::type_checker::SequenceSubtype; -use crate::vm::tests::test_clarity_versions; +use crate::vm::{execute_v2, ClarityName, ClarityVersion}; mod assets; pub mod contracts; diff --git a/clarity/src/vm/analysis/types.rs b/clarity/src/vm/analysis/types.rs index 6771c5c51..f82f7f059 100644 --- a/clarity/src/vm/analysis/types.rs +++ b/clarity/src/vm/analysis/types.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{BTreeMap, BTreeSet, HashMap}; + use stacks_common::types::StacksEpochId; use crate::vm::analysis::analysis_db::AnalysisDatabase; @@ -24,7 +26,6 @@ use crate::vm::costs::{CostTracker, ExecutionCost, LimitedCostTracker}; use crate::vm::types::signatures::FunctionSignature; use crate::vm::types::{FunctionType, QualifiedContractIdentifier, TraitIdentifier, TypeSignature}; use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression}; -use std::collections::{BTreeMap, BTreeSet, HashMap}; const DESERIALIZE_FAIL_MESSAGE: &str = "PANIC: Failed to deserialize bad database data in contract analysis."; @@ -269,13 +270,11 @@ impl ContractAnalysis { #[cfg(test)] mod test { use super::*; - use crate::vm::{ - analysis::ContractAnalysis, - costs::LimitedCostTracker, - types::{ - signatures::CallableSubtype, FixedFunction, FunctionArg, QualifiedContractIdentifier, - StandardPrincipalData, - }, + use crate::vm::analysis::ContractAnalysis; + use crate::vm::costs::LimitedCostTracker; + use crate::vm::types::signatures::CallableSubtype; + use crate::vm::types::{ + FixedFunction, FunctionArg, QualifiedContractIdentifier, StandardPrincipalData, }; #[test] diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs index b63a96d80..b7d5b6738 100644 --- a/clarity/src/vm/ast/definition_sorter/mod.rs +++ b/clarity/src/vm/ast/definition_sorter/mod.rs @@ -14,6 +14,9 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{HashMap, HashSet}; +use std::iter::FromIterator; + use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult}; use crate::vm::ast::types::{BuildASTPass, ContractAST}; use crate::vm::costs::cost_functions::ClarityCostFunction; @@ -26,9 +29,6 @@ use crate::vm::representations::PreSymbolicExpressionType::{ }; use crate::vm::representations::{ClarityName, PreSymbolicExpression}; use crate::vm::types::Value; -use std::collections::{HashMap, HashSet}; -use std::iter::FromIterator; - use crate::vm::ClarityVersion; #[cfg(test)] diff --git a/clarity/src/vm/ast/definition_sorter/tests.rs b/clarity/src/vm/ast/definition_sorter/tests.rs index 77e8f8cde..02996004a 100644 --- a/clarity/src/vm/ast/definition_sorter/tests.rs +++ b/clarity/src/vm/ast/definition_sorter/tests.rs @@ -21,8 +21,7 @@ use rstest_reuse::{self, *}; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check as run_analysis_helper; use crate::vm::ast::definition_sorter::DefinitionSorter; -use crate::vm::ast::errors::ParseErrors; -use crate::vm::ast::errors::ParseResult; +use crate::vm::ast::errors::{ParseErrors, ParseResult}; use crate::vm::ast::expression_identifier::ExpressionIdentifier; use crate::vm::ast::parser; use crate::vm::ast::types::{BuildASTPass, ContractAST}; diff --git a/clarity/src/vm/ast/errors.rs b/clarity/src/vm/ast/errors.rs index 95f2ec2a4..ce34f09e8 100644 --- a/clarity/src/vm/ast/errors.rs +++ b/clarity/src/vm/ast/errors.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::{error, fmt}; + use crate::vm::ast::parser::v2::lexer::error::LexerError; use crate::vm::ast::parser::v2::lexer::token::Token; use crate::vm::costs::{CostErrors, ExecutionCost}; @@ -21,8 +23,6 @@ use crate::vm::diagnostic::{DiagnosableError, Diagnostic, Level}; use crate::vm::representations::{PreSymbolicExpression, Span}; use crate::vm::types::{TupleTypeSignature, TypeSignature}; use crate::vm::MAX_CALL_STACK_DEPTH; -use std::error; -use std::fmt; pub type ParseResult = Result; diff --git a/clarity/src/vm/ast/mod.rs b/clarity/src/vm/ast/mod.rs index 994f151ec..7bfa61b7f 100644 --- a/clarity/src/vm/ast/mod.rs +++ b/clarity/src/vm/ast/mod.rs @@ -23,29 +23,25 @@ pub mod errors; pub mod stack_depth_checker; pub mod sugar_expander; pub mod types; -use crate::vm::costs::{cost_functions, runtime_cost, CostTracker, LimitedCostTracker}; -use crate::vm::errors::{Error, RuntimeErrorType}; - -use crate::vm::representations::SymbolicExpression; -use crate::vm::types::QualifiedContractIdentifier; +use stacks_common::types::StacksEpochId; use self::definition_sorter::DefinitionSorter; use self::errors::ParseResult; use self::expression_identifier::ExpressionIdentifier; -use self::parser::v1::parse as parse_v1; -use self::parser::v1::parse_no_stack_limit as parse_v1_no_stack_limit; +use self::parser::v1::{parse as parse_v1, parse_no_stack_limit as parse_v1_no_stack_limit}; use self::parser::v2::parse as parse_v2; -use self::stack_depth_checker::StackDepthChecker; -use self::stack_depth_checker::VaryStackDepthChecker; +use self::stack_depth_checker::{StackDepthChecker, VaryStackDepthChecker}; use self::sugar_expander::SugarExpander; use self::traits_resolver::TraitsResolver; use self::types::BuildASTPass; pub use self::types::ContractAST; use crate::vm::costs::cost_functions::ClarityCostFunction; +use crate::vm::costs::{cost_functions, runtime_cost, CostTracker, LimitedCostTracker}; use crate::vm::diagnostic::{Diagnostic, Level}; -use crate::vm::representations::PreSymbolicExpression; +use crate::vm::errors::{Error, RuntimeErrorType}; +use crate::vm::representations::{PreSymbolicExpression, SymbolicExpression}; +use crate::vm::types::QualifiedContractIdentifier; use crate::vm::ClarityVersion; -use stacks_common::types::StacksEpochId; /// Legacy function #[cfg(any(test, features = "testing"))] @@ -322,19 +318,17 @@ pub fn build_ast( #[cfg(test)] mod test { + use std::collections::HashMap; + + use stacks_common::types::StacksEpochId; + use crate::vm::ast::errors::ParseErrors; use crate::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; use crate::vm::ast::{build_ast, build_ast_with_rules, ASTRules}; - use crate::vm::costs::LimitedCostTracker; - use crate::vm::costs::*; + use crate::vm::costs::{LimitedCostTracker, *}; use crate::vm::representations::depth_traverse; use crate::vm::types::QualifiedContractIdentifier; - use crate::vm::ClarityCostFunction; - use crate::vm::ClarityName; - use crate::vm::ClarityVersion; - use crate::vm::MAX_CALL_STACK_DEPTH; - use stacks_common::types::StacksEpochId; - use std::collections::HashMap; + use crate::vm::{ClarityCostFunction, ClarityName, ClarityVersion, MAX_CALL_STACK_DEPTH}; #[derive(PartialEq, Debug)] struct UnitTestTracker { diff --git a/clarity/src/vm/ast/parser/v1.rs b/clarity/src/vm/ast/parser/v1.rs index bf459675b..d3cfb2c62 100644 --- a/clarity/src/vm/ast/parser/v1.rs +++ b/clarity/src/vm/ast/parser/v1.rs @@ -14,19 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::cmp; +use std::convert::TryInto; + +use regex::{Captures, Regex}; +use stacks_common::address::c32::c32_address_decode; +use stacks_common::util::hash::hex_bytes; + use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult}; +use crate::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; use crate::vm::errors::{InterpreterResult as Result, RuntimeErrorType}; use crate::vm::representations::{ ClarityName, ContractName, PreSymbolicExpression, PreSymbolicExpressionType, MAX_STRING_LEN, }; use crate::vm::types::{PrincipalData, QualifiedContractIdentifier, TraitIdentifier, Value}; -use regex::{Captures, Regex}; -use stacks_common::address::c32::c32_address_decode; -use stacks_common::util::hash::hex_bytes; -use std::cmp; -use std::convert::TryInto; - -use crate::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; use crate::vm::MAX_CALL_STACK_DEPTH; pub const CONTRACT_MIN_NAME_LENGTH: usize = 1; @@ -731,15 +732,13 @@ pub fn parse_no_stack_limit(input: &str) -> ParseResult = Result; diff --git a/clarity/src/vm/ast/parser/v2/lexer/token.rs b/clarity/src/vm/ast/parser/v2/lexer/token.rs index d2b6a2307..d83a7717a 100644 --- a/clarity/src/vm/ast/parser/v2/lexer/token.rs +++ b/clarity/src/vm/ast/parser/v2/lexer/token.rs @@ -3,7 +3,8 @@ use std::fmt::Display; use stacks_common::util::hash; use super::error::LexerError; -use crate::vm::{representations::Span, types::UTF8Data}; +use crate::vm::representations::Span; +use crate::vm::types::UTF8Data; #[derive(Debug, PartialEq, Clone)] pub enum Token { diff --git a/clarity/src/vm/ast/parser/v2/mod.rs b/clarity/src/vm/ast/parser/v2/mod.rs index cea85b232..582bfe14e 100644 --- a/clarity/src/vm/ast/parser/v2/mod.rs +++ b/clarity/src/vm/ast/parser/v2/mod.rs @@ -1128,14 +1128,11 @@ pub fn parse_collect_diagnostics( #[cfg(test)] #[cfg(feature = "developer-mode")] mod tests { - use crate::vm::{ - diagnostic::Level, - types::{ - ASCIIData, CharType, PrincipalData, SequenceData, StandardPrincipalData, UTF8Data, - }, - }; - use super::*; + use crate::vm::diagnostic::Level; + use crate::vm::types::{ + ASCIIData, CharType, PrincipalData, SequenceData, StandardPrincipalData, UTF8Data, + }; #[test] fn test_parse_int() { diff --git a/clarity/src/vm/ast/stack_depth_checker.rs b/clarity/src/vm/ast/stack_depth_checker.rs index e9a62d8ec..172e6be6c 100644 --- a/clarity/src/vm/ast/stack_depth_checker.rs +++ b/clarity/src/vm/ast/stack_depth_checker.rs @@ -17,9 +17,7 @@ use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult}; use crate::vm::ast::types::{BuildASTPass, ContractAST}; use crate::vm::representations::PreSymbolicExpression; -use crate::vm::representations::PreSymbolicExpressionType::List; -use crate::vm::representations::PreSymbolicExpressionType::Tuple; - +use crate::vm::representations::PreSymbolicExpressionType::{List, Tuple}; use crate::vm::{ClarityVersion, MAX_CALL_STACK_DEPTH}; // allow the AST to get deeper than the max call stack depth, diff --git a/clarity/src/vm/ast/sugar_expander/mod.rs b/clarity/src/vm/ast/sugar_expander/mod.rs index 1e1d978e4..8f0f3c9d7 100644 --- a/clarity/src/vm/ast/sugar_expander/mod.rs +++ b/clarity/src/vm/ast/sugar_expander/mod.rs @@ -14,6 +14,9 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{HashMap, HashSet}; +use std::convert::TryInto; + use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult}; use crate::vm::ast::types::{BuildASTPass, ContractAST, PreExpressionsDrain}; use crate::vm::functions::define::{DefineFunctions, DefineFunctionsParsed}; @@ -27,9 +30,6 @@ use crate::vm::types::{ }; use crate::vm::ClarityVersion; -use std::collections::{HashMap, HashSet}; -use std::convert::TryInto; - pub struct SugarExpander { issuer: StandardPrincipalData, defined_traits: HashSet, diff --git a/clarity/src/vm/ast/types.rs b/clarity/src/vm/ast/types.rs index 7191601ad..79c5513b3 100644 --- a/clarity/src/vm/ast/types.rs +++ b/clarity/src/vm/ast/types.rs @@ -14,13 +14,14 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{HashMap, HashSet}; +use std::vec::Drain; + use crate::vm::ast::errors::ParseResult; use crate::vm::representations::{PreSymbolicExpression, SymbolicExpression, TraitDefinition}; use crate::vm::types::signatures::FunctionSignature; use crate::vm::types::{QualifiedContractIdentifier, TraitIdentifier}; use crate::vm::{ClarityName, ClarityVersion}; -use std::collections::{HashMap, HashSet}; -use std::vec::Drain; pub trait BuildASTPass { fn run_pass(contract_ast: &mut ContractAST, _version: ClarityVersion) -> ParseResult<()>; diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs index e9edd2fe4..c589e4b39 100644 --- a/clarity/src/vm/callables.rs +++ b/clarity/src/vm/callables.rs @@ -21,11 +21,13 @@ use std::iter::FromIterator; use stacks_common::types::StacksEpochId; -use crate::vm::costs::{cost_functions, runtime_cost}; - +use super::costs::CostOverflowingMath; +use super::types::signatures::CallableSubtype; +use super::ClarityVersion; use crate::vm::analysis::errors::CheckErrors; use crate::vm::contexts::ContractContext; use crate::vm::costs::cost_functions::ClarityCostFunction; +use crate::vm::costs::{cost_functions, runtime_cost}; use crate::vm::errors::{check_argument_count, Error, InterpreterResult as Result}; use crate::vm::representations::{ClarityName, Span, SymbolicExpression}; use crate::vm::types::Value::UInt; @@ -36,10 +38,6 @@ use crate::vm::types::{ }; use crate::vm::{eval, Environment, LocalContext, Value}; -use super::costs::CostOverflowingMath; -use super::types::signatures::CallableSubtype; -use super::ClarityVersion; - type SpecialFunctionType = dyn Fn(&[SymbolicExpression], &mut Environment, &LocalContext) -> Result; @@ -503,9 +501,8 @@ fn clarity2_implicit_cast(type_sig: &TypeSignature, value: &Value) -> Result. +use std::convert::TryInto; + use stacks_common::types::StacksEpochId; use crate::vm::ast::ContractAST; @@ -24,7 +26,6 @@ use crate::vm::representations::SymbolicExpression; use crate::vm::types::{PrincipalData, QualifiedContractIdentifier}; use crate::vm::version::ClarityVersion; use crate::vm::{apply, eval_all, Value}; -use std::convert::TryInto; #[derive(Serialize, Deserialize)] pub struct Contract { diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs index add63a9c4..c2c257755 100644 --- a/clarity/src/vm/costs/mod.rs +++ b/clarity/src/vm/costs/mod.rs @@ -20,12 +20,14 @@ use std::{cmp, fmt}; use rusqlite::types::{FromSql, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; use serde::{Deserialize, Serialize}; +use stacks_common::types::StacksEpochId; use crate::boot_util::boot_code_id; use crate::vm::ast::ContractAST; use crate::vm::contexts::{ContractContext, Environment, GlobalContext, OwnedEnvironment}; use crate::vm::costs::cost_functions::ClarityCostFunction; -use crate::vm::database::{clarity_store::NullBackingStore, ClarityDatabase}; +use crate::vm::database::clarity_store::NullBackingStore; +use crate::vm::database::ClarityDatabase; use crate::vm::errors::{Error, InterpreterResult}; use crate::vm::types::signatures::FunctionType::Fixed; use crate::vm::types::signatures::{FunctionSignature, TupleTypeSignature}; @@ -35,7 +37,6 @@ use crate::vm::types::{ TypeSignature, NONE, }; use crate::vm::{ast, eval_all, ClarityName, SymbolicExpression, Value}; -use stacks_common::types::StacksEpochId; pub mod constants; pub mod cost_functions; diff --git a/clarity/src/vm/coverage.rs b/clarity/src/vm/coverage.rs index 1d0756457..4ac9d459a 100644 --- a/clarity/src/vm/coverage.rs +++ b/clarity/src/vm/coverage.rs @@ -1,14 +1,13 @@ -use std::{ - collections::{BTreeMap, HashMap, HashSet}, - fs::File, - io::Write, -}; +use std::collections::{BTreeMap, HashMap, HashSet}; +use std::fs::File; +use std::io::Write; -use crate::vm::types::QualifiedContractIdentifier; -use crate::vm::SymbolicExpression; use serde_json::Value as JsonValue; -use super::{functions::define::DefineFunctionsParsed, EvalHook}; +use super::functions::define::DefineFunctionsParsed; +use super::EvalHook; +use crate::vm::types::QualifiedContractIdentifier; +use crate::vm::SymbolicExpression; pub struct CoverageReporter { executed_lines: HashMap>, diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs index 0585f2005..7a74357f5 100644 --- a/clarity/src/vm/database/clarity_db.rs +++ b/clarity/src/vm/database/clarity_db.rs @@ -17,55 +17,44 @@ use std::collections::{HashMap, VecDeque}; use std::convert::{TryFrom, TryInto}; +use serde_json; +use stacks_common::address::AddressHashMode; +use stacks_common::consts::{ + BITCOIN_REGTEST_FIRST_BLOCK_HASH, BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT, + BITCOIN_REGTEST_FIRST_BLOCK_TIMESTAMP, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, + MINER_REWARD_MATURITY, +}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksAddress, StacksBlockId, + VRFSeed, +}; +use stacks_common::types::{ + Address, StacksEpoch as GenericStacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_2_0, +}; +use stacks_common::util::hash::{to_hex, Hash160, Sha256Sum, Sha512Trunc256Sum}; + +use super::clarity_store::SpecialCaseHandler; +use super::key_value_wrapper::ValueResult; use crate::vm::analysis::{AnalysisDatabase, ContractAnalysis}; use crate::vm::ast::ASTRules; use crate::vm::contracts::Contract; -use crate::vm::costs::CostOverflowingMath; -use crate::vm::costs::ExecutionCost; +use crate::vm::costs::{CostOverflowingMath, ExecutionCost}; use crate::vm::database::structures::{ ClarityDeserializable, ClaritySerializable, ContractMetadata, DataMapMetadata, DataVariableMetadata, FungibleTokenMetadata, NonFungibleTokenMetadata, STXBalance, STXBalanceSnapshot, SimmedBlock, }; -use crate::vm::database::ClarityBackingStore; -use crate::vm::database::RollbackWrapper; +use crate::vm::database::{ClarityBackingStore, RollbackWrapper}; use crate::vm::errors::{ CheckErrors, Error, IncomparableError, InterpreterError, InterpreterResult as Result, RuntimeErrorType, }; use crate::vm::representations::ClarityName; -use crate::vm::types::serialization::SerializationError; +use crate::vm::types::serialization::{SerializationError, NONE_SERIALIZATION_LEN}; use crate::vm::types::{ - serialization::NONE_SERIALIZATION_LEN, OptionalData, PrincipalData, - QualifiedContractIdentifier, SequenceData, StandardPrincipalData, TupleData, - TupleTypeSignature, TypeSignature, Value, NONE, + byte_len_of_serialization, OptionalData, PrincipalData, QualifiedContractIdentifier, + SequenceData, StandardPrincipalData, TupleData, TupleTypeSignature, TypeSignature, Value, NONE, }; -use stacks_common::util::hash::{to_hex, Hash160, Sha256Sum, Sha512Trunc256Sum}; - -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, VRFSeed, -}; - -use crate::vm::types::byte_len_of_serialization; - -use stacks_common::types::{ - StacksEpoch as GenericStacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_2_0, -}; - -use stacks_common::consts::MINER_REWARD_MATURITY; -use stacks_common::consts::{ - BITCOIN_REGTEST_FIRST_BLOCK_HASH, BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT, - BITCOIN_REGTEST_FIRST_BLOCK_TIMESTAMP, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, -}; - -use stacks_common::address::AddressHashMode; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::Address; - -use super::clarity_store::SpecialCaseHandler; -use super::key_value_wrapper::ValueResult; - -use serde_json; pub const STORE_CONTRACT_SRC_INTERFACE: bool = true; diff --git a/clarity/src/vm/database/clarity_store.rs b/clarity/src/vm/database/clarity_store.rs index 0a2c13aa4..b9400c227 100644 --- a/clarity/src/vm/database/clarity_store.rs +++ b/clarity/src/vm/database/clarity_store.rs @@ -18,8 +18,11 @@ use std::convert::TryInto; use std::path::PathBuf; use rusqlite::Connection; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, VRFSeed}; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum}; use crate::vm::analysis::AnalysisDatabase; +use crate::vm::contexts::GlobalContext; use crate::vm::database::{ BurnStateDB, ClarityDatabase, ClarityDeserializable, ClaritySerializable, HeadersDB, SqliteConnection, NULL_BURN_STATE_DB, NULL_HEADER_DB, @@ -29,13 +32,8 @@ use crate::vm::errors::{ InterpreterResult, RuntimeErrorType, }; use crate::vm::events::StacksTransactionEvent; -use crate::vm::types::QualifiedContractIdentifier; -use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum}; - -use crate::vm::contexts::GlobalContext; -use crate::vm::types::PrincipalData; +use crate::vm::types::{PrincipalData, QualifiedContractIdentifier}; use crate::vm::Value; -use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, VRFSeed}; pub struct NullBackingStore {} diff --git a/clarity/src/vm/database/key_value_wrapper.rs b/clarity/src/vm/database/key_value_wrapper.rs index 778ba8396..8431a1742 100644 --- a/clarity/src/vm/database/key_value_wrapper.rs +++ b/clarity/src/vm/database/key_value_wrapper.rs @@ -14,9 +14,17 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::clone::Clone; +use std::cmp::Eq; use std::collections::HashMap; -use std::{clone::Clone, cmp::Eq, hash::Hash}; +use std::hash::Hash; +use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::StacksEpochId; +use stacks_common::util::hash::Sha512Trunc256Sum; + +use super::clarity_store::SpecialCaseHandler; +use super::{ClarityBackingStore, ClarityDeserializable}; use crate::vm::database::clarity_store::make_contract_hash_key; use crate::vm::errors::InterpreterResult; use crate::vm::types::serialization::SerializationError; @@ -24,13 +32,6 @@ use crate::vm::types::{ QualifiedContractIdentifier, SequenceData, SequenceSubtype, TupleData, TypeSignature, }; use crate::vm::{StacksEpoch, Value}; -use stacks_common::types::StacksEpochId; -use stacks_common::util::hash::Sha512Trunc256Sum; - -use stacks_common::types::chainstate::StacksBlockId; - -use super::clarity_store::SpecialCaseHandler; -use super::{ClarityBackingStore, ClarityDeserializable}; #[cfg(rollback_value_check)] type RollbackValueCheck = String; diff --git a/clarity/src/vm/database/mod.rs b/clarity/src/vm/database/mod.rs index fd1f06557..e02aee5c3 100644 --- a/clarity/src/vm/database/mod.rs +++ b/clarity/src/vm/database/mod.rs @@ -20,8 +20,7 @@ pub use self::clarity_db::{ BurnStateDB, ClarityDatabase, HeadersDB, StoreType, NULL_BURN_STATE_DB, NULL_HEADER_DB, STORE_CONTRACT_SRC_INTERFACE, }; -pub use self::clarity_store::MemoryBackingStore; -pub use self::clarity_store::{ClarityBackingStore, SpecialCaseHandler}; +pub use self::clarity_store::{ClarityBackingStore, MemoryBackingStore, SpecialCaseHandler}; pub use self::key_value_wrapper::{RollbackWrapper, RollbackWrapperPersistedLog}; pub use self::sqlite::SqliteConnection; pub use self::structures::{ diff --git a/clarity/src/vm/database/sqlite.rs b/clarity/src/vm/database/sqlite.rs index 9fd48656e..273473c9b 100644 --- a/clarity/src/vm/database/sqlite.rs +++ b/clarity/src/vm/database/sqlite.rs @@ -19,9 +19,7 @@ use rusqlite::{ Connection, Error as SqliteError, ErrorCode as SqliteErrorCode, OptionalExtension, Row, Savepoint, NO_PARAMS, }; - use stacks_common::types::chainstate::StacksBlockId; - use stacks_common::util::db_common::tx_busy_handler; use crate::vm::contracts::Contract; diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs index b96563aa4..89a635765 100644 --- a/clarity/src/vm/database/structures.rs +++ b/clarity/src/vm/database/structures.rs @@ -14,6 +14,12 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryInto; +use std::io::Write; + +use serde::Deserialize; +use stacks_common::util::hash::{hex_bytes, to_hex}; + use crate::vm::analysis::ContractAnalysis; use crate::vm::contracts::Contract; use crate::vm::database::ClarityDatabase; @@ -23,10 +29,6 @@ use crate::vm::errors::{ use crate::vm::types::{ OptionalData, PrincipalData, TupleTypeSignature, TypeSignature, Value, NONE, }; -use serde::Deserialize; -use stacks_common::util::hash::{hex_bytes, to_hex}; -use std::convert::TryInto; -use std::io::Write; pub trait ClaritySerializable { fn serialize(&self) -> String; diff --git a/clarity/src/vm/diagnostic.rs b/clarity/src/vm/diagnostic.rs index f07b53d8b..ee0ac0b56 100644 --- a/clarity/src/vm/diagnostic.rs +++ b/clarity/src/vm/diagnostic.rs @@ -14,9 +14,10 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::representations::Span; use std::fmt; +use crate::vm::representations::Span; + /// In a near future, we can go further in our static analysis and provide different levels /// of diagnostics, such as warnings, hints, best practices, etc. #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)] diff --git a/clarity/src/vm/docs/contracts.rs b/clarity/src/vm/docs/contracts.rs index 05b7de422..a8b9a5e3f 100644 --- a/clarity/src/vm/docs/contracts.rs +++ b/clarity/src/vm/docs/contracts.rs @@ -1,20 +1,18 @@ -use crate::vm::analysis::{mem_type_check, ContractAnalysis}; -use crate::vm::docs::{get_input_type_string, get_output_type_string, get_signature}; -use crate::vm::types::{FunctionType, Value}; - use std::collections::{BTreeMap, HashMap, HashSet}; use std::iter::FromIterator; +use stacks_common::consts::CHAIN_ID_TESTNET; +use stacks_common::types::StacksEpochId; + +use crate::vm::analysis::{mem_type_check, ContractAnalysis}; use crate::vm::ast::{build_ast_with_rules, ASTRules}; use crate::vm::contexts::GlobalContext; use crate::vm::costs::LimitedCostTracker; use crate::vm::database::MemoryBackingStore; -use crate::vm::types::QualifiedContractIdentifier; +use crate::vm::docs::{get_input_type_string, get_output_type_string, get_signature}; +use crate::vm::types::{FunctionType, QualifiedContractIdentifier, Value}; use crate::vm::version::ClarityVersion; use crate::vm::{self, ContractContext}; -use stacks_common::types::StacksEpochId; - -use stacks_common::consts::CHAIN_ID_TESTNET; const DOCS_GENERATION_EPOCH: StacksEpochId = StacksEpochId::Epoch2_05; diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs index 24587da82..81e4ce343 100644 --- a/clarity/src/vm/docs/mod.rs +++ b/clarity/src/vm/docs/mod.rs @@ -14,6 +14,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use super::types::signatures::{FunctionArgSignature, FunctionReturnsSignature}; use crate::vm::analysis::type_checker::v2_1::natives::SimpleNativeFunction; use crate::vm::analysis::type_checker::v2_1::TypedNativeFunction; use crate::vm::costs::ExecutionCost; @@ -24,8 +25,6 @@ use crate::vm::types::{FixedFunction, FunctionType, SequenceSubtype, StringSubty use crate::vm::variables::NativeVariables; use crate::vm::ClarityVersion; -use super::types::signatures::{FunctionArgSignature, FunctionReturnsSignature}; - pub mod contracts; #[derive(Serialize)] @@ -2630,39 +2629,33 @@ pub fn make_json_api_reference() -> String { #[cfg(test)] mod test { - use crate::vm::{ - ast, - contexts::OwnedEnvironment, - database::{BurnStateDB, HeadersDB, STXBalance}, - docs::get_output_type_string, - eval_all, execute, - types::{ - signatures::{FunctionArgSignature, FunctionReturnsSignature, ASCII_40}, - BufferLength, FunctionType, PrincipalData, SequenceSubtype, StringSubtype, - TypeSignature, - }, - ClarityVersion, ContractContext, Error, GlobalContext, LimitedCostTracker, - QualifiedContractIdentifier, Value, + use stacks_common::address::AddressHashMode; + use stacks_common::consts::CHAIN_ID_TESTNET; + use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksAddress, + StacksBlockId, VRFSeed, }; - use stacks_common::types::{StacksEpochId, PEER_VERSION_EPOCH_2_1}; + use stacks_common::types::{Address, StacksEpochId, PEER_VERSION_EPOCH_2_1}; use stacks_common::util::hash::hex_bytes; - use super::make_json_api_reference; - use super::{get_input_type_string, make_all_api_reference}; + use super::{get_input_type_string, make_all_api_reference, make_json_api_reference}; use crate::vm::analysis::type_check; - use crate::vm::database::{ClarityDatabase, MemoryBackingStore}; - use crate::vm::types::TupleData; - use crate::vm::StacksEpoch; - use stacks_common::address::AddressHashMode; - use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, VRFSeed, - }; - use stacks_common::types::chainstate::{SortitionId, StacksAddress, StacksBlockId}; - use stacks_common::types::Address; - use crate::vm::ast::ASTRules; + use crate::vm::contexts::OwnedEnvironment; use crate::vm::costs::ExecutionCost; - use stacks_common::consts::CHAIN_ID_TESTNET; + use crate::vm::database::{ + BurnStateDB, ClarityDatabase, HeadersDB, MemoryBackingStore, STXBalance, + }; + use crate::vm::docs::get_output_type_string; + use crate::vm::types::signatures::{FunctionArgSignature, FunctionReturnsSignature, ASCII_40}; + use crate::vm::types::{ + BufferLength, FunctionType, PrincipalData, SequenceSubtype, StringSubtype, TupleData, + TypeSignature, + }; + use crate::vm::{ + ast, eval_all, execute, ClarityVersion, ContractContext, Error, GlobalContext, + LimitedCostTracker, QualifiedContractIdentifier, StacksEpoch, Value, + }; struct DocHeadersDB {} const DOC_HEADER_DB: DocHeadersDB = DocHeadersDB {}; diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs index 71dc0a21d..d03e75e03 100644 --- a/clarity/src/vm/errors.rs +++ b/clarity/src/vm/errors.rs @@ -14,20 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -pub use crate::vm::analysis::errors::CheckErrors; +use std::error::Error as ErrorTrait; +use std::{error, fmt}; + +use rusqlite::Error as SqliteError; +use serde_json::Error as SerdeJSONErr; +use stacks_common::types::chainstate::BlockHeaderHash; + pub use crate::vm::analysis::errors::{ - check_argument_count, check_arguments_at_least, check_arguments_at_most, + check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrors, }; use crate::vm::ast::errors::ParseError; use crate::vm::contexts::StackTrace; use crate::vm::costs::CostErrors; use crate::vm::types::{TypeSignature, Value}; -use rusqlite::Error as SqliteError; -use serde_json::Error as SerdeJSONErr; -use stacks_common::types::chainstate::BlockHeaderHash; -use std::error; -use std::error::Error as ErrorTrait; -use std::fmt; #[derive(Debug)] pub struct IncomparableError { diff --git a/clarity/src/vm/events.rs b/clarity/src/vm/events.rs index 8b693ea9f..18fc84bb2 100644 --- a/clarity/src/vm/events.rs +++ b/clarity/src/vm/events.rs @@ -14,14 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use stacks_common::codec::StacksMessageCodec; +use stacks_common::types::chainstate::StacksAddress; + use crate::vm::analysis::ContractAnalysis; use crate::vm::costs::ExecutionCost; use crate::vm::types::{ AssetIdentifier, BuffData, PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, Value, }; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::StacksAddress; #[derive(Debug, Clone, PartialEq)] pub enum StacksTransactionEvent { diff --git a/clarity/src/vm/functions/arithmetic.rs b/clarity/src/vm/functions/arithmetic.rs index ec493d9de..6b30ce085 100644 --- a/clarity/src/vm/functions/arithmetic.rs +++ b/clarity/src/vm/functions/arithmetic.rs @@ -14,19 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::costs::cost_functions::ClarityCostFunction; -use crate::vm::errors::{check_argument_count, CheckErrors, InterpreterResult, RuntimeErrorType}; -use crate::vm::types::{ - ASCIIData, BuffData, CharType, SequenceData, TypeSignature, UTF8Data, Value, -}; use std::cmp; use std::convert::TryFrom; -use crate::vm::costs::runtime_cost; use integer_sqrt::IntegerSquareRoot; +use crate::vm::costs::cost_functions::ClarityCostFunction; +use crate::vm::costs::runtime_cost; +use crate::vm::errors::{check_argument_count, CheckErrors, InterpreterResult, RuntimeErrorType}; use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; -use crate::vm::types::{signatures::ListTypeData, ListData, TypeSignature::BoolType}; +use crate::vm::types::signatures::ListTypeData; +use crate::vm::types::TypeSignature::BoolType; +use crate::vm::types::{ + ASCIIData, BuffData, CharType, ListData, SequenceData, TypeSignature, UTF8Data, Value, +}; use crate::vm::version::ClarityVersion; use crate::vm::{apply, eval, lookup_function, CallableType, Environment, LocalContext}; diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs index 8b621b9d2..e117b81af 100644 --- a/clarity/src/vm/functions/assets.rs +++ b/clarity/src/vm/functions/assets.rs @@ -14,9 +14,10 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::functions::tuples; use std::convert::{TryFrom, TryInto}; +use stacks_common::types::StacksEpochId; + use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{cost_functions, runtime_cost, CostTracker}; use crate::vm::database::{ClarityDatabase, ClaritySerializable, STXBalance}; @@ -24,17 +25,14 @@ use crate::vm::errors::{ check_argument_count, CheckErrors, Error, InterpreterError, InterpreterResult as Result, RuntimeErrorType, }; +use crate::vm::functions::tuples; use crate::vm::representations::SymbolicExpression; use crate::vm::types::{ AssetIdentifier, BlockInfoProperty, BuffData, CharType, OptionalData, PrincipalData, - SequenceData, TypeSignature, Value, + SequenceData, TupleData, TypeSignature, Value, }; use crate::vm::{eval, Environment, LocalContext}; -use stacks_common::types::StacksEpochId; - -use crate::vm::types::TupleData; - enum MintAssetErrorCodes { ALREADY_EXIST = 1, } diff --git a/clarity/src/vm/functions/conversions.rs b/clarity/src/vm/functions/conversions.rs index 5f362c707..b42e8490c 100644 --- a/clarity/src/vm/functions/conversions.rs +++ b/clarity/src/vm/functions/conversions.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryFrom; + use stacks_common::codec::StacksMessageCodec; use stacks_common::types::StacksEpochId; @@ -28,7 +30,6 @@ use crate::vm::types::{ ASCIIData, BuffData, BufferLength, CharType, SequenceData, TypeSignature, UTF8Data, Value, }; use crate::vm::{apply, eval, lookup_function, Environment, LocalContext}; -use std::convert::TryFrom; #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum EndianDirection { diff --git a/clarity/src/vm/functions/crypto.rs b/clarity/src/vm/functions/crypto.rs index 4ef4dd76f..30de1e9af 100644 --- a/clarity/src/vm/functions/crypto.rs +++ b/clarity/src/vm/functions/crypto.rs @@ -14,6 +14,13 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use stacks_common::address::{ + AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, +}; +use stacks_common::types::chainstate::StacksAddress; +use stacks_common::util::hash; +use stacks_common::util::secp256k1::{secp256k1_recover, secp256k1_verify, Secp256k1PublicKey}; + use crate::vm::callables::{CallableType, NativeHandle}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{ @@ -25,20 +32,11 @@ use crate::vm::errors::{ }; use crate::vm::representations::SymbolicExpressionType::{Atom, List}; use crate::vm::representations::{ClarityName, SymbolicExpression, SymbolicExpressionType}; -use crate::vm::types::StacksAddressExtensions; use crate::vm::types::{ - BuffData, CharType, PrincipalData, ResponseData, SequenceData, TypeSignature, Value, BUFF_32, - BUFF_33, BUFF_65, + BuffData, CharType, PrincipalData, ResponseData, SequenceData, StacksAddressExtensions, + TypeSignature, Value, BUFF_32, BUFF_33, BUFF_65, }; use crate::vm::{eval, ClarityVersion, Environment, LocalContext}; -use stacks_common::address::AddressHashMode; -use stacks_common::address::{ - C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, -}; -use stacks_common::util::hash; -use stacks_common::util::secp256k1::{secp256k1_recover, secp256k1_verify, Secp256k1PublicKey}; - -use stacks_common::types::chainstate::StacksAddress; macro_rules! native_hash_func { ($name:ident, $module:ty) => { diff --git a/clarity/src/vm/functions/database.rs b/clarity/src/vm/functions/database.rs index 664140f86..ead11ab0e 100644 --- a/clarity/src/vm/functions/database.rs +++ b/clarity/src/vm/functions/database.rs @@ -17,9 +17,11 @@ use std::cmp; use std::convert::{TryFrom, TryInto}; -use crate::vm::functions::tuples; +use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::StacksEpochId; use crate::vm::callables::DefineType; +use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{ constants as cost_constants, cost_functions, runtime_cost, CostTracker, MemoryConsumer, }; @@ -27,16 +29,13 @@ use crate::vm::errors::{ check_argument_count, check_arguments_at_least, CheckErrors, InterpreterError, InterpreterResult as Result, RuntimeErrorType, }; +use crate::vm::functions::tuples; use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; use crate::vm::types::{ BlockInfoProperty, BuffData, BurnBlockInfoProperty, OptionalData, PrincipalData, SequenceData, TupleData, TypeSignature, Value, BUFF_32, }; use crate::vm::{eval, Environment, LocalContext}; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::StacksEpochId; - -use crate::vm::costs::cost_functions::ClarityCostFunction; switch_on_global_epoch!(special_fetch_variable( special_fetch_variable_v200, diff --git a/clarity/src/vm/functions/define.rs b/clarity/src/vm/functions/define.rs index fbe8f99f9..9451f17ff 100644 --- a/clarity/src/vm/functions/define.rs +++ b/clarity/src/vm/functions/define.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::{BTreeMap, HashMap}; + use crate::vm::callables::{DefineType, DefinedFunction}; use crate::vm::contexts::{ContractContext, Environment, LocalContext}; use crate::vm::errors::{ @@ -30,7 +32,6 @@ use crate::vm::types::{ parse_name_type_pairs, PrincipalData, QualifiedContractIdentifier, TraitIdentifier, TupleTypeSignature, TypeSignature, Value, }; -use std::collections::{BTreeMap, HashMap}; define_named_enum!(DefineFunctions { Constant("define-constant"), diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs index 9c3a9551d..d81a4b2ab 100644 --- a/clarity/src/vm/functions/mod.rs +++ b/clarity/src/vm/functions/mod.rs @@ -14,7 +14,12 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::callables::{CallableType, NativeHandle}; +use stacks_common::address::AddressHashMode; +use stacks_common::types::chainstate::StacksAddress; +use stacks_common::types::StacksEpochId; +use stacks_common::util::hash; + +use crate::vm::callables::{cost_input_sized_vararg, CallableType, NativeHandle}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{ constants as cost_constants, cost_functions, runtime_cost, CostTracker, MemoryConsumer, @@ -24,7 +29,6 @@ use crate::vm::errors::{ InterpreterResult as Result, RuntimeErrorType, ShortReturnType, }; pub use crate::vm::functions::assets::stx_transfer_consolidated; -use crate::vm::is_reserved; use crate::vm::representations::SymbolicExpressionType::{Atom, List}; use crate::vm::representations::{ClarityName, SymbolicExpression, SymbolicExpressionType}; use crate::vm::types::{ @@ -32,14 +36,7 @@ use crate::vm::types::{ BUFF_33, BUFF_65, }; use crate::vm::Value::CallableContract; -use crate::vm::{eval, Environment, LocalContext}; -use stacks_common::address::AddressHashMode; -use stacks_common::util::hash; - -use crate::vm::callables::cost_input_sized_vararg; -use stacks_common::types::chainstate::StacksAddress; - -use stacks_common::types::StacksEpochId; +use crate::vm::{eval, is_reserved, Environment, LocalContext}; macro_rules! switch_on_global_epoch { ($Name:ident ($Epoch2Version:ident, $Epoch205Version:ident)) => { diff --git a/clarity/src/vm/functions/options.rs b/clarity/src/vm/functions/options.rs index 70ea138a9..b03d464be 100644 --- a/clarity/src/vm/functions/options.rs +++ b/clarity/src/vm/functions/options.rs @@ -23,8 +23,7 @@ use crate::vm::errors::{ }; use crate::vm::types::{CallableData, OptionalData, ResponseData, TypeSignature, Value}; use crate::vm::Value::CallableContract; -use crate::vm::{self, ClarityVersion}; -use crate::vm::{ClarityName, SymbolicExpression}; +use crate::vm::{self, ClarityName, ClarityVersion, SymbolicExpression}; fn inner_unwrap(to_unwrap: Value) -> Result> { let result = match to_unwrap { diff --git a/clarity/src/vm/functions/principals.rs b/clarity/src/vm/functions/principals.rs index cecfbb65c..579761dfa 100644 --- a/clarity/src/vm/functions/principals.rs +++ b/clarity/src/vm/functions/principals.rs @@ -1,3 +1,11 @@ +use std::convert::TryFrom; + +use stacks_common::address::{ + C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, + C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, +}; +use stacks_common::util::hash::hex_bytes; + use crate::vm::contexts::GlobalContext; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{cost_functions, runtime_cost, CostTracker}; @@ -5,23 +13,16 @@ use crate::vm::errors::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrors, Error, InterpreterError, InterpreterResult as Result, RuntimeErrorType, }; -use crate::vm::representations::ClarityName; -use crate::vm::representations::SymbolicExpression; +use crate::vm::representations::{ + ClarityName, SymbolicExpression, CONTRACT_MAX_NAME_LENGTH, CONTRACT_MIN_NAME_LENGTH, +}; +use crate::vm::types::signatures::{BUFF_1, BUFF_20}; use crate::vm::types::{ - signatures::BUFF_1, signatures::BUFF_20, ASCIIData, BuffData, BufferLength, CharType, - OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, SequenceData, - SequenceSubtype, StandardPrincipalData, TupleData, TypeSignature, Value, + ASCIIData, BuffData, BufferLength, CharType, OptionalData, PrincipalData, + QualifiedContractIdentifier, ResponseData, SequenceData, SequenceSubtype, + StandardPrincipalData, TupleData, TypeSignature, Value, }; use crate::vm::{eval, ContractName, Environment, LocalContext}; -use stacks_common::util::hash::hex_bytes; -use std::convert::TryFrom; - -use stacks_common::address::{ - C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, - C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, -}; - -use crate::vm::representations::{CONTRACT_MAX_NAME_LENGTH, CONTRACT_MIN_NAME_LENGTH}; pub enum PrincipalConstructErrorCode { VERSION_BYTE = 0, diff --git a/clarity/src/vm/functions/sequences.rs b/clarity/src/vm/functions/sequences.rs index 3beee7401..16e7d8d07 100644 --- a/clarity/src/vm/functions/sequences.rs +++ b/clarity/src/vm/functions/sequences.rs @@ -14,6 +14,11 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::cmp; +use std::convert::{TryFrom, TryInto}; + +use stacks_common::types::StacksEpochId; + use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{cost_functions, runtime_cost, CostOverflowingMath}; use crate::vm::errors::{ @@ -21,14 +26,10 @@ use crate::vm::errors::{ RuntimeErrorType, }; use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType}; -use crate::vm::types::{ - signatures::ListTypeData, CharType, ListData, SequenceData, TypeSignature, - TypeSignature::BoolType, Value, -}; +use crate::vm::types::signatures::ListTypeData; +use crate::vm::types::TypeSignature::BoolType; +use crate::vm::types::{CharType, ListData, SequenceData, TypeSignature, Value}; use crate::vm::{apply, eval, lookup_function, CallableType, Environment, LocalContext}; -use stacks_common::types::StacksEpochId; -use std::cmp; -use std::convert::{TryFrom, TryInto}; pub fn list_cons( args: &[SymbolicExpression], diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs index 18bc734c5..dcdc02574 100644 --- a/clarity/src/vm/mod.rs +++ b/clarity/src/vm/mod.rs @@ -52,44 +52,41 @@ pub mod test_util; #[allow(clippy::result_large_err)] pub mod clarity; -use serde_json; +use std::collections::BTreeMap; +use std::convert::{TryFrom, TryInto}; -// publish the non-generic StacksEpoch form for use throughout module -pub use crate::vm::database::clarity_db::StacksEpoch; +use serde_json; use stacks_common::types::StacksEpochId; +use self::analysis::ContractAnalysis; +use self::ast::{ASTRules, ContractAST}; +use self::costs::ExecutionCost; +use self::diagnostic::Diagnostic; use crate::vm::callables::CallableType; use crate::vm::contexts::GlobalContext; -pub use crate::vm::contexts::{CallStack, ContractContext, Environment, LocalContext}; +pub use crate::vm::contexts::{ + CallStack, ContractContext, Environment, LocalContext, MAX_CONTEXT_DEPTH, +}; +use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{ cost_functions, runtime_cost, CostOverflowingMath, CostTracker, LimitedCostTracker, MemoryConsumer, }; +// publish the non-generic StacksEpoch form for use throughout module +pub use crate::vm::database::clarity_db::StacksEpoch; use crate::vm::errors::{ CheckErrors, Error, InterpreterError, InterpreterResult as Result, RuntimeErrorType, }; use crate::vm::functions::define::DefineResult; +pub use crate::vm::functions::stx_transfer_consolidated; +pub use crate::vm::representations::{ + ClarityName, ContractName, SymbolicExpression, SymbolicExpressionType, +}; pub use crate::vm::types::Value; use crate::vm::types::{ PrincipalData, QualifiedContractIdentifier, TraitIdentifier, TypeSignature, }; - -pub use crate::vm::representations::{ - ClarityName, ContractName, SymbolicExpression, SymbolicExpressionType, -}; - -pub use crate::vm::contexts::MAX_CONTEXT_DEPTH; -use crate::vm::costs::cost_functions::ClarityCostFunction; -pub use crate::vm::functions::stx_transfer_consolidated; pub use crate::vm::version::ClarityVersion; -use std::collections::BTreeMap; -use std::convert::{TryFrom, TryInto}; - -use self::analysis::ContractAnalysis; -use self::ast::ASTRules; -use self::ast::ContractAST; -use self::costs::ExecutionCost; -use self::diagnostic::Diagnostic; pub const MAX_CALL_STACK_DEPTH: usize = 64; @@ -581,23 +578,21 @@ pub fn execute_v2(program: &str) -> Result> { #[cfg(test)] mod test { + use std::collections::HashMap; + + use stacks_common::consts::CHAIN_ID_TESTNET; + use stacks_common::types::StacksEpochId; + + use super::ClarityVersion; use crate::vm::callables::{DefineType, DefinedFunction}; use crate::vm::costs::LimitedCostTracker; use crate::vm::database::MemoryBackingStore; use crate::vm::errors::RuntimeErrorType; - use crate::vm::eval; - use crate::vm::execute; use crate::vm::types::{QualifiedContractIdentifier, TypeSignature}; use crate::vm::{ - CallStack, ContractContext, Environment, GlobalContext, LocalContext, SymbolicExpression, - Value, + eval, execute, CallStack, ContractContext, Environment, GlobalContext, LocalContext, + SymbolicExpression, Value, }; - use stacks_common::types::StacksEpochId; - use std::collections::HashMap; - - use super::ClarityVersion; - - use stacks_common::consts::CHAIN_ID_TESTNET; #[test] fn test_simple_user_function() { diff --git a/clarity/src/vm/representations.rs b/clarity/src/vm/representations.rs index b8a751bfd..a7cc12fce 100644 --- a/clarity/src/vm/representations.rs +++ b/clarity/src/vm/representations.rs @@ -14,11 +14,6 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::errors::RuntimeErrorType; -use crate::vm::types::{QualifiedContractIdentifier, TraitIdentifier, Value}; -use regex::Regex; -use stacks_common::codec::Error as codec_error; -use stacks_common::codec::{read_next, read_next_at_most, write_next, StacksMessageCodec}; use std::borrow::Borrow; use std::cmp::Ordering; use std::convert::TryFrom; @@ -26,6 +21,14 @@ use std::fmt; use std::io::{Read, Write}; use std::ops::Deref; +use regex::Regex; +use stacks_common::codec::{ + read_next, read_next_at_most, write_next, Error as codec_error, StacksMessageCodec, +}; + +use crate::vm::errors::RuntimeErrorType; +use crate::vm::types::{QualifiedContractIdentifier, TraitIdentifier, Value}; + pub const CONTRACT_MIN_NAME_LENGTH: usize = 1; pub const CONTRACT_MAX_NAME_LENGTH: usize = 40; pub const MAX_STRING_LEN: u8 = 128; diff --git a/clarity/src/vm/test_util/mod.rs b/clarity/src/vm/test_util/mod.rs index fa751026e..136866027 100644 --- a/clarity/src/vm/test_util/mod.rs +++ b/clarity/src/vm/test_util/mod.rs @@ -1,24 +1,21 @@ -use crate::vm::ast::ASTRules; -use crate::vm::costs::ExecutionCost; -use crate::vm::database::{BurnStateDB, HeadersDB}; -use crate::vm::execute as vm_execute; -use crate::vm::execute_on_network as vm_execute_on_network; -use crate::vm::representations::SymbolicExpression; -use crate::vm::types::StandardPrincipalData; -use crate::vm::types::{PrincipalData, ResponseData, TupleData, Value}; -use crate::vm::StacksEpoch; use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG}; use stacks_common::consts::{ BITCOIN_REGTEST_FIRST_BLOCK_HASH, BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT, BITCOIN_REGTEST_FIRST_BLOCK_TIMESTAMP, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, }; -use stacks_common::types::chainstate::ConsensusHash; use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, VRFSeed, + BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksAddress, StacksBlockId, + StacksPrivateKey, StacksPublicKey, VRFSeed, }; -use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey}; use stacks_common::types::{StacksEpochId, PEER_VERSION_EPOCH_2_0}; +use crate::vm::ast::ASTRules; +use crate::vm::costs::ExecutionCost; +use crate::vm::database::{BurnStateDB, HeadersDB}; +use crate::vm::representations::SymbolicExpression; +use crate::vm::types::{PrincipalData, ResponseData, StandardPrincipalData, TupleData, Value}; +use crate::vm::{execute as vm_execute, execute_on_network as vm_execute_on_network, StacksEpoch}; + pub struct UnitTestBurnStateDB { pub epoch_id: StacksEpochId, pub ast_rules: ASTRules, diff --git a/clarity/src/vm/tests/assets.rs b/clarity/src/vm/tests/assets.rs index f257bd95f..0f6551c36 100644 --- a/clarity/src/vm/tests/assets.rs +++ b/clarity/src/vm/tests/assets.rs @@ -14,20 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use stacks_common::types::StacksEpochId; + use crate::vm::ast::ASTRules; use crate::vm::contexts::{AssetMap, AssetMapEntry, OwnedEnvironment}; use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType}; use crate::vm::events::StacksTransactionEvent; use crate::vm::representations::SymbolicExpression; -use crate::vm::tests::{execute, is_committed, is_err_code, symbols_from_values}; use crate::vm::tests::{ - test_clarity_versions, test_epochs, tl_env_factory as env_factory, - TopLevelMemoryEnvironmentGenerator, + execute, is_committed, is_err_code, symbols_from_values, test_clarity_versions, test_epochs, + tl_env_factory as env_factory, TopLevelMemoryEnvironmentGenerator, }; use crate::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier, Value}; use crate::vm::version::ClarityVersion; use crate::vm::ContractContext; -use stacks_common::types::StacksEpochId; const FIRST_CLASS_TOKENS: &str = "(define-fungible-token stackaroos) (define-read-only (my-ft-get-balance (account principal)) diff --git a/clarity/src/vm/tests/contracts.rs b/clarity/src/vm/tests/contracts.rs index 10061417e..4f30b9f77 100644 --- a/clarity/src/vm/tests/contracts.rs +++ b/clarity/src/vm/tests/contracts.rs @@ -14,27 +14,25 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::ast::errors::ParseErrors; -use crate::vm::ast::ASTRules; -use crate::vm::contexts::Environment; -use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType}; -use crate::vm::execute as vm_execute; -use crate::vm::tests::{ - env_factory, execute, is_committed, is_err_code_i128 as is_err_code, symbols_from_values, - tl_env_factory, MemoryEnvironmentGenerator, TopLevelMemoryEnvironmentGenerator, -}; -use crate::vm::tests::{test_clarity_versions, test_epochs}; -use crate::vm::types::{ - OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, - TypeSignature, Value, -}; -use crate::vm::ClarityVersion; #[cfg(any(test, feature = "testing"))] use rstest::rstest; use stacks_common::types::chainstate::BlockHeaderHash; use stacks_common::types::StacksEpochId; -use crate::vm::ContractContext; +use crate::vm::ast::errors::ParseErrors; +use crate::vm::ast::ASTRules; +use crate::vm::contexts::Environment; +use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType}; +use crate::vm::tests::{ + env_factory, execute, is_committed, is_err_code_i128 as is_err_code, symbols_from_values, + test_clarity_versions, test_epochs, tl_env_factory, MemoryEnvironmentGenerator, + TopLevelMemoryEnvironmentGenerator, +}; +use crate::vm::types::{ + OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, + TypeSignature, Value, +}; +use crate::vm::{execute as vm_execute, ClarityVersion, ContractContext}; const FACTORIAL_CONTRACT: &str = "(define-map factorials { id: int } { current: int, index: int }) (define-private (init-factorial (id int) (factorial int)) diff --git a/clarity/src/vm/tests/datamaps.rs b/clarity/src/vm/tests/datamaps.rs index dbf8d74f0..87f5dbcf3 100644 --- a/clarity/src/vm/tests/datamaps.rs +++ b/clarity/src/vm/tests/datamaps.rs @@ -14,14 +14,13 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::{From, TryFrom}; + use crate::vm::errors::{CheckErrors, Error, ShortReturnType}; -use crate::vm::execute; use crate::vm::types::{ ListData, SequenceData, TupleData, TupleTypeSignature, TypeSignature, Value, }; -use crate::vm::ClarityName; -use std::convert::From; -use std::convert::TryFrom; +use crate::vm::{execute, ClarityName}; fn assert_executes(expected: Result, input: &str) { assert_eq!(expected.unwrap(), execute(input).unwrap().unwrap()); diff --git a/clarity/src/vm/tests/defines.rs b/clarity/src/vm/tests/defines.rs index 9d8e511f2..d77b693aa 100644 --- a/clarity/src/vm/tests/defines.rs +++ b/clarity/src/vm/tests/defines.rs @@ -14,19 +14,18 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::tests::test_clarity_versions; - #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; +use stacks_common::types::StacksEpochId; use crate::vm::ast::build_ast; use crate::vm::ast::errors::{ParseError, ParseErrors}; use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType}; +use crate::vm::tests::test_clarity_versions; use crate::vm::types::{QualifiedContractIdentifier, TypeSignature, Value}; use crate::vm::{execute, ClarityVersion}; -use stacks_common::types::StacksEpochId; fn assert_eq_err(e1: CheckErrors, e2: Error) { let e1: Error = e1.into(); diff --git a/clarity/src/vm/tests/mod.rs b/clarity/src/vm/tests/mod.rs index 518b063e4..2f5da7e0a 100644 --- a/clarity/src/vm/tests/mod.rs +++ b/clarity/src/vm/tests/mod.rs @@ -13,18 +13,16 @@ // // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::contexts::OwnedEnvironment; -use crate::vm::database::MemoryBackingStore; -use crate::vm::errors::Error; -use crate::vm::types::Value; - -use stacks_common::types::StacksEpochId; - -pub use crate::vm::database::BurnStateDB; use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; +use stacks_common::types::StacksEpochId; pub use super::test_util::*; use super::ClarityVersion; +use crate::vm::contexts::OwnedEnvironment; +pub use crate::vm::database::BurnStateDB; +use crate::vm::database::MemoryBackingStore; +use crate::vm::errors::Error; +use crate::vm::types::Value; mod assets; mod contracts; diff --git a/clarity/src/vm/tests/principals.rs b/clarity/src/vm/tests/principals.rs index 684347406..92de68254 100644 --- a/clarity/src/vm/tests/principals.rs +++ b/clarity/src/vm/tests/principals.rs @@ -1,20 +1,17 @@ -use crate::vm::ast::ASTRules; -use crate::vm::execute_with_parameters; -use crate::vm::types::TypeSignature::PrincipalType; -use crate::vm::types::{ASCIIData, BuffData, CharType, SequenceData, Value}; -use crate::vm::ClarityVersion; - -use crate::vm::errors::CheckErrors; -use crate::vm::types::{ - OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, - TupleData, TypeSignature, BUFF_1, BUFF_20, -}; use stacks_common::types::StacksEpochId; - -use crate::vm::functions::principals::PrincipalConstructErrorCode; - use stacks_common::util::hash::hex_bytes; +use crate::vm::ast::ASTRules; +use crate::vm::errors::CheckErrors; +use crate::vm::functions::principals::PrincipalConstructErrorCode; +use crate::vm::types::TypeSignature::PrincipalType; +use crate::vm::types::{ + ASCIIData, BuffData, CharType, OptionalData, PrincipalData, QualifiedContractIdentifier, + ResponseData, SequenceData, StandardPrincipalData, TupleData, TypeSignature, Value, BUFF_1, + BUFF_20, +}; +use crate::vm::{execute_with_parameters, ClarityVersion}; + #[test] fn test_simple_is_standard_check_inputs() { let wrong_type_test = "(is-standard u10)"; diff --git a/clarity/src/vm/tests/sequences.rs b/clarity/src/vm/tests/sequences.rs index 29704fd39..62cca99e6 100644 --- a/clarity/src/vm/tests/sequences.rs +++ b/clarity/src/vm/tests/sequences.rs @@ -14,20 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::vm::types::signatures::SequenceSubtype; -use crate::vm::types::TypeSignature::{BoolType, IntType, SequenceType, UIntType}; -use crate::vm::types::{StringSubtype, StringUTF8Length, TypeSignature, Value}; +use std::convert::{TryFrom, TryInto}; + use rstest::rstest; use rstest_reuse::{self, *}; +use stacks_common::types::StacksEpochId; use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType}; use crate::vm::tests::test_clarity_versions; +use crate::vm::types::signatures::SequenceSubtype; use crate::vm::types::signatures::SequenceSubtype::{BufferType, StringType}; use crate::vm::types::signatures::StringSubtype::ASCII; -use crate::vm::types::BufferLength; +use crate::vm::types::TypeSignature::{BoolType, IntType, SequenceType, UIntType}; +use crate::vm::types::{BufferLength, StringSubtype, StringUTF8Length, TypeSignature, Value}; use crate::vm::{execute, execute_v2, ClarityVersion}; -use stacks_common::types::StacksEpochId; -use std::convert::{TryFrom, TryInto}; #[test] fn test_simple_list_admission() { diff --git a/clarity/src/vm/tests/simple_apply_eval.rs b/clarity/src/vm/tests/simple_apply_eval.rs index ff17accf2..86818063c 100644 --- a/clarity/src/vm/tests/simple_apply_eval.rs +++ b/clarity/src/vm/tests/simple_apply_eval.rs @@ -16,35 +16,30 @@ use rstest::rstest; use rstest_reuse::{self, *}; +use stacks_common::address::{ + AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, +}; +use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; +use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey}; +use stacks_common::types::StacksEpochId; +use stacks_common::util::hash::{hex_bytes, to_hex}; -use crate::vm::ast::parse; - -use crate::vm::ast::ASTRules; +use crate::vm::ast::{parse, ASTRules}; use crate::vm::callables::DefinedFunction; use crate::vm::contexts::OwnedEnvironment; use crate::vm::costs::LimitedCostTracker; use crate::vm::database::MemoryBackingStore; use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType, ShortReturnType}; -use crate::vm::tests::execute; -use crate::vm::tests::test_clarity_versions; +use crate::vm::tests::{execute, test_clarity_versions}; use crate::vm::types::signatures::*; -use crate::vm::types::StacksAddressExtensions; -use crate::vm::types::{ASCIIData, BuffData, CharType, QualifiedContractIdentifier, TypeSignature}; -use crate::vm::types::{PrincipalData, SequenceData}; -use crate::vm::ClarityVersion; -use crate::vm::{ - eval, execute as vm_execute, execute_v2 as vm_execute_v2, execute_with_parameters, +use crate::vm::types::{ + ASCIIData, BuffData, CharType, PrincipalData, QualifiedContractIdentifier, SequenceData, + StacksAddressExtensions, TypeSignature, +}; +use crate::vm::{ + eval, execute as vm_execute, execute_v2 as vm_execute_v2, execute_with_parameters, CallStack, + ClarityVersion, ContractContext, Environment, GlobalContext, LocalContext, Value, }; -use crate::vm::{CallStack, ContractContext, Environment, GlobalContext, LocalContext, Value}; -use stacks_common::address::AddressHashMode; -use stacks_common::address::C32_ADDRESS_VERSION_MAINNET_SINGLESIG; -use stacks_common::address::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; -use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::StacksPrivateKey; -use stacks_common::types::chainstate::StacksPublicKey; -use stacks_common::types::StacksEpochId; -use stacks_common::util::hash::{hex_bytes, to_hex}; #[test] fn test_doubly_defined_persisted_vars() { diff --git a/clarity/src/vm/tests/traits.rs b/clarity/src/vm/tests/traits.rs index 6d231f55d..190503178 100644 --- a/clarity/src/vm/tests/traits.rs +++ b/clarity/src/vm/tests/traits.rs @@ -16,19 +16,16 @@ use stacks_common::types::StacksEpochId; +use super::MemoryEnvironmentGenerator; use crate::vm::ast::ASTRules; use crate::vm::errors::{CheckErrors, Error}; -use crate::vm::tests::{execute, symbols_from_values}; +use crate::vm::tests::{ + env_factory, execute, symbols_from_values, test_clarity_versions, test_epochs, +}; use crate::vm::types::{PrincipalData, QualifiedContractIdentifier, Value}; - -use crate::vm::tests::env_factory; -use crate::vm::tests::test_clarity_versions; -use crate::vm::tests::test_epochs; use crate::vm::version::ClarityVersion; use crate::vm::ContractContext; -use super::MemoryEnvironmentGenerator; - #[apply(test_clarity_versions)] fn test_dynamic_dispatch_by_defining_trait( version: ClarityVersion, diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs index 39694bf18..5aa298a13 100644 --- a/clarity/src/vm/types/mod.rs +++ b/clarity/src/vm/types/mod.rs @@ -21,31 +21,26 @@ pub mod signatures; use std::collections::BTreeMap; use std::convert::{TryFrom, TryInto}; -use std::{char, str}; -use std::{cmp, fmt}; +use std::{char, cmp, fmt, str}; use regex::Regex; - use stacks_common::address::c32; +use stacks_common::types::chainstate::StacksAddress; use stacks_common::types::StacksEpochId; use stacks_common::util::hash; -use stacks_common::types::chainstate::StacksAddress; - use crate::vm::errors::{ CheckErrors, IncomparableError, InterpreterError, InterpreterResult as Result, RuntimeErrorType, }; use crate::vm::representations::{ ClarityName, ContractName, SymbolicExpression, SymbolicExpressionType, }; - pub use crate::vm::types::signatures::{ parse_name_type_pairs, AssetIdentifier, BufferLength, FixedFunction, FunctionArg, FunctionSignature, FunctionType, ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length, TupleTypeSignature, TypeSignature, BUFF_1, BUFF_20, BUFF_21, BUFF_32, BUFF_33, BUFF_64, BUFF_65, }; - use crate::vm::ClarityVersion; pub const MAX_VALUE_SIZE: u32 = 1024 * 1024; // 1MB diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs index cebd2f6eb..6862f24b1 100644 --- a/clarity/src/vm/types/serialization.rs +++ b/clarity/src/vm/types/serialization.rs @@ -21,8 +21,12 @@ use std::io::{Read, Write}; use std::{cmp, error, fmt, str}; use serde_json::Value as JSONValue; +use stacks_common::codec::{Error as codec_error, StacksMessageCodec}; use stacks_common::types::StacksEpochId; +use stacks_common::util::hash::{hex_bytes, to_hex}; +use stacks_common::util::retry::BoundReader; +use super::{ListTypeData, TupleTypeSignature}; use crate::vm::database::{ClarityDeserializable, ClaritySerializable}; use crate::vm::errors::{ CheckErrors, Error as ClarityError, IncomparableError, InterpreterError, InterpreterResult, @@ -31,18 +35,11 @@ use crate::vm::errors::{ use crate::vm::representations::{ClarityName, ContractName, MAX_STRING_LEN}; use crate::vm::types::signatures::CallableSubtype; use crate::vm::types::{ - BufferLength, CallableData, CharType, OptionalData, PrincipalData, QualifiedContractIdentifier, - ResponseData, SequenceData, SequenceSubtype, StandardPrincipalData, StringSubtype, - StringUTF8Length, TupleData, TypeSignature, Value, BOUND_VALUE_SERIALIZATION_BYTES, - MAX_TYPE_DEPTH, MAX_VALUE_SIZE, + byte_len_of_serialization, BufferLength, CallableData, CharType, OptionalData, PrincipalData, + QualifiedContractIdentifier, ResponseData, SequenceData, SequenceSubtype, + StandardPrincipalData, StringSubtype, StringUTF8Length, TupleData, TypeSignature, Value, + BOUND_VALUE_SERIALIZATION_BYTES, MAX_TYPE_DEPTH, MAX_VALUE_SIZE, }; -use stacks_common::util::hash::{hex_bytes, to_hex}; -use stacks_common::util::retry::BoundReader; - -use crate::vm::types::byte_len_of_serialization; -use stacks_common::codec::{Error as codec_error, StacksMessageCodec}; - -use super::{ListTypeData, TupleTypeSignature}; /// Errors that may occur in serialization or deserialization /// If deserialization failed because the described type is a bad type and @@ -1348,20 +1345,19 @@ impl std::hash::Hash for Value { #[cfg(test)] pub mod tests { - use rstest::rstest; - use rstest_reuse::{self, *}; - use std::io::Write; + use rstest::rstest; + use rstest_reuse::{self, *}; + use stacks_common::types::StacksEpochId; + + use super::super::*; + use super::SerializationError; use crate::vm::database::{ClarityDeserializable, ClaritySerializable, RollbackWrapper}; use crate::vm::errors::Error; use crate::vm::tests::test_clarity_versions; use crate::vm::types::TypeSignature::{BoolType, IntType}; - - use super::super::*; - use super::SerializationError; use crate::vm::ClarityVersion; - use stacks_common::types::StacksEpochId; fn buff_type(size: u32) -> TypeSignature { TypeSignature::SequenceType(SequenceSubtype::BufferType(size.try_into().unwrap())) diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs index 417936435..88b59c3ba 100644 --- a/clarity/src/vm/types/signatures.rs +++ b/clarity/src/vm/types/signatures.rs @@ -21,20 +21,21 @@ use std::convert::{TryFrom, TryInto}; use std::hash::{Hash, Hasher}; use std::{cmp, fmt}; +use stacks_common::address::c32; +use stacks_common::types::StacksEpochId; +use stacks_common::util::hash; + use crate::vm::costs::{cost_functions, runtime_cost, CostOverflowingMath}; use crate::vm::errors::{CheckErrors, Error as VMError, IncomparableError, RuntimeErrorType}; -use crate::vm::representations::CONTRACT_MAX_NAME_LENGTH; use crate::vm::representations::{ ClarityName, ContractName, SymbolicExpression, SymbolicExpressionType, TraitDefinition, + CONTRACT_MAX_NAME_LENGTH, }; use crate::vm::types::{ CharType, PrincipalData, QualifiedContractIdentifier, SequenceData, SequencedValue, StandardPrincipalData, TraitIdentifier, Value, MAX_TYPE_DEPTH, MAX_VALUE_SIZE, WRAPPER_VALUE_SIZE, }; -use stacks_common::address::c32; -use stacks_common::types::StacksEpochId; -use stacks_common::util::hash; type Result = std::result::Result; @@ -1932,15 +1933,15 @@ impl fmt::Display for FunctionArg { #[cfg(test)] mod test { - use super::CheckErrors::*; - use super::*; - use crate::vm::{execute, ClarityVersion}; #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; + use super::CheckErrors::*; + use super::*; use crate::vm::tests::test_clarity_versions; + use crate::vm::{execute, ClarityVersion}; fn fail_parse(val: &str, version: ClarityVersion, epoch: StacksEpochId) -> CheckErrors { use crate::vm::ast::parse; diff --git a/clarity/src/vm/variables.rs b/clarity/src/vm/variables.rs index ca5154b81..286d661b4 100644 --- a/clarity/src/vm/variables.rs +++ b/clarity/src/vm/variables.rs @@ -16,13 +16,11 @@ use std::convert::TryFrom; use crate::vm::contexts::{Environment, LocalContext}; -use crate::vm::errors::{InterpreterResult as Result, RuntimeErrorType}; -use crate::vm::types::BuffData; -use crate::vm::types::Value; -use crate::vm::ClarityVersion; - use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::runtime_cost; +use crate::vm::errors::{InterpreterResult as Result, RuntimeErrorType}; +use crate::vm::types::{BuffData, Value}; +use crate::vm::ClarityVersion; define_versioned_named_enum!(NativeVariables(ClarityVersion) { ContractCaller("contract-caller", ClarityVersion::Clarity1), diff --git a/clarity/src/vm/version.rs b/clarity/src/vm/version.rs index 62b625e0a..7da1f744f 100644 --- a/clarity/src/vm/version.rs +++ b/clarity/src/vm/version.rs @@ -1,8 +1,10 @@ -use crate::vm::errors::{Error, RuntimeErrorType}; -use stacks_common::types::StacksEpochId; use std::fmt; use std::str::FromStr; +use stacks_common::types::StacksEpochId; + +use crate::vm::errors::{Error, RuntimeErrorType}; + #[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, PartialOrd)] pub enum ClarityVersion { Clarity1, diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs index 8ca2547d1..23f5d0e4b 100644 --- a/libsigner/src/events.rs +++ b/libsigner/src/events.rs @@ -14,22 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::sync::mpsc::Sender; - -use std::sync::atomic::{AtomicBool, Ordering}; -use std::sync::Arc; - -use std::net::SocketAddr; -use std::net::TcpListener; -use std::net::TcpStream; - use std::io::{Read, Write}; +use std::net::{SocketAddr, TcpListener, TcpStream}; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::mpsc::Sender; +use std::sync::Arc; use clarity::vm::types::QualifiedContractIdentifier; use libstackerdb::StackerDBChunkData; - use serde::{Deserialize, Serialize}; - use tiny_http::{ Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer, }; diff --git a/libsigner/src/http.rs b/libsigner/src/http.rs index 7bb7045e5..8926a3c4e 100644 --- a/libsigner/src/http.rs +++ b/libsigner/src/http.rs @@ -17,15 +17,13 @@ use std::collections::HashMap; use std::io; use std::io::{Read, Write}; - use std::net::SocketAddr; use stacks_common::codec::MAX_MESSAGE_LEN; use stacks_common::deps_common::httparse; use stacks_common::util::chunked_encoding::*; -use crate::error::EventError; -use crate::error::RPCError; +use crate::error::{EventError, RPCError}; pub const MAX_HTTP_HEADERS: usize = 32; pub const MAX_HTTP_HEADER_LEN: usize = 4096; diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs index 38819b7f5..3ab25f46e 100644 --- a/libsigner/src/libsigner.rs +++ b/libsigner/src/libsigner.rs @@ -42,13 +42,10 @@ mod http; mod runloop; mod session; -pub use crate::session::{SignerSession, StackerDBSession}; - pub use crate::error::{EventError, RPCError}; - -pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop}; - pub use crate::events::{ EventReceiver, EventStopSignaler, StackerDBChunksEvent, StackerDBEventReceiver, StackerDBStopSignaler, }; +pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop}; +pub use crate::session::{SignerSession, StackerDBSession}; diff --git a/libsigner/src/runloop.rs b/libsigner/src/runloop.rs index 03c50bae4..7f0a2a73d 100644 --- a/libsigner/src/runloop.rs +++ b/libsigner/src/runloop.rs @@ -24,13 +24,12 @@ use std::thread; use std::thread::JoinHandle; use std::time::Duration; -use crate::events::{EventReceiver, EventStopSignaler, StackerDBChunksEvent}; - -use crate::error::EventError; - use stacks_common::deps_common::ctrlc as termination; use stacks_common::deps_common::ctrlc::SignalId; +use crate::error::EventError; +use crate::events::{EventReceiver, EventStopSignaler, StackerDBChunksEvent}; + /// Some libcs, like musl, have a very small stack size. /// Make sure it's big enough. const THREAD_STACK_SIZE: usize = 128 * 1024 * 1024; // 128 MB diff --git a/libsigner/src/session.rs b/libsigner/src/session.rs index 75b64dc5a..b65e43467 100644 --- a/libsigner/src/session.rs +++ b/libsigner/src/session.rs @@ -14,17 +14,15 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::net::SocketAddr; -use std::net::TcpStream; +use std::net::{SocketAddr, TcpStream}; use std::str; +use clarity::vm::types::QualifiedContractIdentifier; use libstackerdb::{ stackerdb_get_chunk_path, stackerdb_get_metadata_path, stackerdb_post_chunk_path, SlotMetadata, StackerDBChunkAckData, StackerDBChunkData, }; -use clarity::vm::types::QualifiedContractIdentifier; - use crate::error::RPCError; use crate::http::run_http_request; diff --git a/libsigner/src/tests/http.rs b/libsigner/src/tests/http.rs index be34036ff..eb187700e 100644 --- a/libsigner/src/tests/http.rs +++ b/libsigner/src/tests/http.rs @@ -15,17 +15,14 @@ // along with this program. If not, see . use std::collections::HashMap; -use std::io; -use std::io::Read; -use std::io::Write; -use std::str; - -use crate::error::EventError; -use crate::error::RPCError; -use crate::http::{decode_http_body, decode_http_request, decode_http_response, run_http_request}; +use std::io::{Read, Write}; +use std::{io, str}; use stacks_common::util::chunked_encoding::*; +use crate::error::{EventError, RPCError}; +use crate::http::{decode_http_body, decode_http_request, decode_http_response, run_http_request}; + #[test] fn test_decode_http_request_ok() { let tests = vec![ diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs index fc4d45ddf..ffe8d4d9e 100644 --- a/libsigner/src/tests/mod.rs +++ b/libsigner/src/tests/mod.rs @@ -17,20 +17,17 @@ mod http; use std::io::Write; -use std::mem; use std::net::{SocketAddr, TcpStream, ToSocketAddrs}; use std::sync::mpsc::{channel, Receiver, Sender}; -use std::thread; use std::time::Duration; - -use crate::{Signer, SignerRunLoop, StackerDBChunksEvent, StackerDBEventReceiver}; +use std::{mem, thread}; use clarity::vm::types::QualifiedContractIdentifier; - +use libstackerdb::StackerDBChunkData; use stacks_common::util::secp256k1::Secp256k1PrivateKey; use stacks_common::util::sleep_ms; -use libstackerdb::StackerDBChunkData; +use crate::{Signer, SignerRunLoop, StackerDBChunksEvent, StackerDBEventReceiver}; /// Simple runloop implementation. It receives `max_events` events and returns `events` from the /// last call to `run_one_pass` as its final state. diff --git a/libstackerdb/src/libstackerdb.rs b/libstackerdb/src/libstackerdb.rs index 34136433e..d4ae0740b 100644 --- a/libstackerdb/src/libstackerdb.rs +++ b/libstackerdb/src/libstackerdb.rs @@ -19,28 +19,20 @@ extern crate serde; extern crate sha2; extern crate stacks_common; -use std::error; -use std::fmt; use std::io::{Read, Write}; +use std::{error, fmt}; +use clarity::vm::types::QualifiedContractIdentifier; +use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha512_256}; - +use stacks_common::codec::{ + read_next, read_next_at_most, write_next, Error as CodecError, StacksMessageCodec, +}; use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey}; use stacks_common::types::PrivateKey; use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum}; - -use stacks_common::codec::read_next; -use stacks_common::codec::read_next_at_most; -use stacks_common::codec::write_next; -use stacks_common::codec::Error as CodecError; -use stacks_common::codec::StacksMessageCodec; - use stacks_common::util::secp256k1::MessageSignature; -use serde::{Deserialize, Serialize}; - -use clarity::vm::types::QualifiedContractIdentifier; - /// maximum chunk size (1 MB) pub const STACKERDB_MAX_CHUNK_SIZE: u32 = 1024 * 1024; diff --git a/libstackerdb/src/tests/mod.rs b/libstackerdb/src/tests/mod.rs index 357e2c8e4..bd63ae7c5 100644 --- a/libstackerdb/src/tests/mod.rs +++ b/libstackerdb/src/tests/mod.rs @@ -14,19 +14,14 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use stacks_common::types::chainstate::StacksAddress; - -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::Sha512Trunc256Sum; +use clarity::vm::types::QualifiedContractIdentifier; +use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG}; +use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey}; +use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum}; use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG}; -use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey}; - use crate::*; -use clarity::vm::types::QualifiedContractIdentifier; - #[test] fn test_stackerdb_slot_metadata_sign_verify() { let pk = StacksPrivateKey::new(); diff --git a/pox-locking/src/pox_1.rs b/pox-locking/src/pox_1.rs index 2f9a1010d..fb8e29097 100644 --- a/pox-locking/src/pox_1.rs +++ b/pox-locking/src/pox_1.rs @@ -19,8 +19,7 @@ use clarity::vm::contexts::GlobalContext; use clarity::vm::costs::cost_functions::ClarityCostFunction; use clarity::vm::costs::runtime_cost; use clarity::vm::database::ClarityDatabase; -use clarity::vm::errors::Error as ClarityError; -use clarity::vm::errors::RuntimeErrorType; +use clarity::vm::errors::{Error as ClarityError, RuntimeErrorType}; use clarity::vm::events::{STXEventType, STXLockEventData, StacksTransactionEvent}; use clarity::vm::types::PrincipalData; use clarity::vm::Value; diff --git a/pox-locking/src/pox_2.rs b/pox-locking/src/pox_2.rs index e49b99257..11a6fff7a 100644 --- a/pox-locking/src/pox_2.rs +++ b/pox-locking/src/pox_2.rs @@ -19,13 +19,11 @@ use clarity::vm::contexts::GlobalContext; use clarity::vm::costs::cost_functions::ClarityCostFunction; use clarity::vm::costs::runtime_cost; use clarity::vm::database::{ClarityDatabase, STXBalance}; -use clarity::vm::errors::Error as ClarityError; -use clarity::vm::errors::RuntimeErrorType; +use clarity::vm::errors::{Error as ClarityError, RuntimeErrorType}; use clarity::vm::events::{STXEventType, STXLockEventData, StacksTransactionEvent}; use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; use clarity::vm::{Environment, Value}; -use slog::slog_debug; -use slog::slog_error; +use slog::{slog_debug, slog_error}; use stacks_common::{debug, error}; use crate::events::synthesize_pox_2_or_3_event_info; diff --git a/pox-locking/src/pox_3.rs b/pox-locking/src/pox_3.rs index 7e045a942..c1bb470a5 100644 --- a/pox-locking/src/pox_3.rs +++ b/pox-locking/src/pox_3.rs @@ -19,20 +19,17 @@ use clarity::vm::contexts::GlobalContext; use clarity::vm::costs::cost_functions::ClarityCostFunction; use clarity::vm::costs::runtime_cost; use clarity::vm::database::{ClarityDatabase, STXBalance}; -use clarity::vm::errors::Error as ClarityError; -use clarity::vm::errors::RuntimeErrorType; +use clarity::vm::errors::{Error as ClarityError, RuntimeErrorType}; use clarity::vm::events::{STXEventType, STXLockEventData, StacksTransactionEvent}; use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; use clarity::vm::{Environment, Value}; -use slog::slog_debug; -use slog::slog_error; +use slog::{slog_debug, slog_error}; use stacks_common::{debug, error}; use crate::events::synthesize_pox_2_or_3_event_info; -use crate::LockingError; -use crate::POX_3_NAME; // Note: PoX-3 uses the same contract-call result parsing routines as PoX-2 use crate::pox_2::{parse_pox_extend_result, parse_pox_increase, parse_pox_stacking_result}; +use crate::{LockingError, POX_3_NAME}; /////////////////////// PoX-3 ///////////////////////////////// diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs index 1978a661a..c8d0a507f 100644 --- a/stacks-common/src/address/c32.rs +++ b/stacks-common/src/address/c32.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use super::Error; - -use sha2::Digest; -use sha2::Sha256; use std::convert::TryFrom; +use sha2::{Digest, Sha256}; + +use super::Error; + const C32_CHARACTERS: &[u8; 32] = b"0123456789ABCDEFGHJKMNPQRSTVWXYZ"; /// C32 chars as an array, indexed by their ASCII code for O(1) lookups. @@ -370,12 +370,13 @@ pub fn c32_address(version: u8, data: &[u8]) -> Result { #[cfg(test)] mod test { + use rand::Rng; + use super::super::c32_old::{ c32_address as c32_address_old, c32_address_decode as c32_address_decode_old, }; use super::*; use crate::util::hash::hex_bytes; - use rand::Rng; #[test] fn old_c32_validation() { diff --git a/stacks-common/src/address/c32_old.rs b/stacks-common/src/address/c32_old.rs index d4ac6dbf7..e4b36338d 100644 --- a/stacks-common/src/address/c32_old.rs +++ b/stacks-common/src/address/c32_old.rs @@ -17,10 +17,9 @@ //! This module (`c32_old`) is only here to test compatibility with the new `c32` //! module. It will be removed in the next network upgrade. -use super::Error; +use sha2::{Digest, Sha256}; -use sha2::Digest; -use sha2::Sha256; +use super::Error; const C32_CHARACTERS: &str = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; diff --git a/stacks-common/src/address/mod.rs b/stacks-common/src/address/mod.rs index d89b86334..27c621cac 100644 --- a/stacks-common/src/address/mod.rs +++ b/stacks-common/src/address/mod.rs @@ -14,21 +14,16 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; -use std::fmt; +use std::convert::TryFrom; +use std::{error, fmt}; -use crate::types::PublicKey; +use sha2::{Digest, Sha256}; use crate::deps_common::bitcoin::blockdata::opcodes::All as btc_opcodes; use crate::deps_common::bitcoin::blockdata::script::{Builder, Instruction, Script}; - +use crate::types::PublicKey; use crate::util::hash::Hash160; -use sha2::Digest; -use sha2::Sha256; - -use std::convert::TryFrom; - pub mod b58; pub mod c32; #[cfg(test)] diff --git a/stacks-common/src/deps_common/bech32/mod.rs b/stacks-common/src/deps_common/bech32/mod.rs index 95580ec26..3d2c22dda 100644 --- a/stacks-common/src/deps_common/bech32/mod.rs +++ b/stacks-common/src/deps_common/bech32/mod.rs @@ -62,16 +62,14 @@ extern crate alloc; #[cfg(any(test, feature = "std"))] extern crate core; -#[cfg(all(not(feature = "std"), not(test)))] -use alloc::{string::String, vec::Vec}; - #[cfg(all(not(feature = "std"), not(test)))] use alloc::borrow::Cow; +#[cfg(all(not(feature = "std"), not(test)))] +use alloc::{string::String, vec::Vec}; +use core::{fmt, mem}; #[cfg(any(feature = "std", test))] use std::borrow::Cow; -use core::{fmt, mem}; - /// Integer in the range `0..32` #[derive(PartialEq, Eq, Debug, Copy, Clone, Default, PartialOrd, Ord, Hash)] #[allow(non_camel_case_types)] diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/block.rs b/stacks-common/src/deps_common/bitcoin/blockdata/block.rs index 40a103771..af064511b 100644 --- a/stacks-common/src/deps_common/bitcoin/blockdata/block.rs +++ b/stacks-common/src/deps_common/bitcoin/blockdata/block.rs @@ -20,8 +20,6 @@ //! these blocks and the blockchain. //! -use crate::util::uint::Uint256; - use crate::deps_common::bitcoin::blockdata::constants::max_target; use crate::deps_common::bitcoin::blockdata::transaction::Transaction; use crate::deps_common::bitcoin::network::constants::Network; @@ -31,6 +29,7 @@ use crate::deps_common::bitcoin::util; use crate::deps_common::bitcoin::util::hash::Sha256dHash; use crate::deps_common::bitcoin::util::Error; use crate::deps_common::bitcoin::util::Error::{SpvBadProofOfWork, SpvBadTarget}; +use crate::util::uint::Uint256; /// A block header, which contains all the block's information except /// the actual transactions @@ -179,10 +178,9 @@ impl_consensus_encoding!(LoneBlockHeader, header, tx_count); #[cfg(test)] mod tests { - use crate::util::hash::hex_bytes as hex_decode; - use crate::deps_common::bitcoin::blockdata::block::{Block, BlockHeader}; use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; + use crate::util::hash::hex_bytes as hex_decode; #[test] fn block_test() { diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs b/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs index 20656276e..8c832c85d 100644 --- a/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs +++ b/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs @@ -22,9 +22,8 @@ use std::default::Default; use crate::deps_common::bitcoin::blockdata::block::{Block, BlockHeader}; -use crate::deps_common::bitcoin::blockdata::opcodes; -use crate::deps_common::bitcoin::blockdata::script; use crate::deps_common::bitcoin::blockdata::transaction::{OutPoint, Transaction, TxIn, TxOut}; +use crate::deps_common::bitcoin::blockdata::{opcodes, script}; use crate::deps_common::bitcoin::network::constants::Network; use crate::deps_common::bitcoin::util::hash::MerkleRoot; use crate::util::hash::hex_bytes; @@ -140,13 +139,14 @@ pub fn genesis_block(network: Network) -> Block { #[cfg(test)] mod test { - use crate::util::hash::hex_bytes as hex_decode; use std::default::Default; - use crate::deps_common::bitcoin::blockdata::constants::{bitcoin_genesis_tx, genesis_block}; - use crate::deps_common::bitcoin::blockdata::constants::{COIN_VALUE, MAX_SEQUENCE}; + use crate::deps_common::bitcoin::blockdata::constants::{ + bitcoin_genesis_tx, genesis_block, COIN_VALUE, MAX_SEQUENCE, + }; use crate::deps_common::bitcoin::network::constants::Network; use crate::deps_common::bitcoin::network::serialize::{serialize, BitcoinHash}; + use crate::util::hash::hex_bytes as hex_decode; #[test] fn bitcoin_genesis_first_transaction() { diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/opcodes.rs b/stacks-common/src/deps_common/bitcoin/blockdata/opcodes.rs index 1f2cf1f9a..5e628b06f 100644 --- a/stacks-common/src/deps_common/bitcoin/blockdata/opcodes.rs +++ b/stacks-common/src/deps_common/bitcoin/blockdata/opcodes.rs @@ -20,12 +20,12 @@ #![allow(non_camel_case_types)] -#[cfg(feature = "serde")] -use serde; - // Heavy stick to translate between opcode types use std::mem::transmute; +#[cfg(feature = "serde")] +use serde; + use crate::deps_common::bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable}; use crate::deps_common::bitcoin::network::serialize::{self, SimpleDecoder, SimpleEncoder}; diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs index 22cbc29f9..da5eb3d21 100644 --- a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs +++ b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs @@ -28,17 +28,14 @@ use std::default::Default; use std::{error, fmt}; use serde; +use sha2::{Digest, Sha256}; use crate::deps_common::bitcoin::blockdata::opcodes; use crate::deps_common::bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable}; use crate::deps_common::bitcoin::network::serialize::{self, SimpleDecoder, SimpleEncoder}; - // careful... use crate::deps_common::bitcoin::util::hash::Hash160; -use sha2::Digest; -use sha2::Sha256; - #[derive(Clone, Default, PartialOrd, Ord, PartialEq, Eq, Hash)] /// A Bitcoin script pub struct Script(Box<[u8]>); @@ -702,13 +699,10 @@ impl ConsensusDecodable for Script { #[cfg(test)] mod test { - use crate::util::hash::hex_bytes as hex_decode; - - use super::build_scriptint; - use super::*; - + use super::{build_scriptint, *}; use crate::deps_common::bitcoin::blockdata::opcodes; use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; + use crate::util::hash::hex_bytes as hex_decode; #[test] fn script() { diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs index 441483e74..4457f3df8 100644 --- a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs +++ b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs @@ -35,7 +35,6 @@ use crate::deps_common::bitcoin::network::serialize::{ self, serialize, BitcoinHash, SimpleDecoder, SimpleEncoder, }; use crate::deps_common::bitcoin::util::hash::Sha256dHash; - use crate::util::hash::to_hex; /// A reference to a transaction output @@ -674,11 +673,9 @@ impl SigHashType { #[cfg(test)] mod tests { use super::{SigHashType, Transaction, TxIn}; - use crate::deps_common; use crate::deps_common::bitcoin::blockdata::script::Script; - use crate::deps_common::bitcoin::network::serialize::deserialize; - use crate::deps_common::bitcoin::network::serialize::BitcoinHash; + use crate::deps_common::bitcoin::network::serialize::{deserialize, BitcoinHash}; use crate::deps_common::bitcoin::util::hash::Sha256dHash; use crate::util::hash::hex_bytes; diff --git a/stacks-common/src/deps_common/bitcoin/network/address.rs b/stacks-common/src/deps_common/bitcoin/network/address.rs index 3fff2bfee..b041bbb85 100644 --- a/stacks-common/src/deps_common/bitcoin/network/address.rs +++ b/stacks-common/src/deps_common/bitcoin/network/address.rs @@ -18,9 +18,8 @@ //! network addresses in Bitcoin messages. //! -use std::fmt; -use std::io; use std::net::{Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; +use std::{fmt, io}; use crate::deps_common::bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable}; use crate::deps_common::bitcoin::network::serialize::{self, SimpleDecoder, SimpleEncoder}; @@ -137,10 +136,10 @@ impl Eq for Address {} #[cfg(test)] mod test { - use super::Address; use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}; use std::str::FromStr; + use super::Address; use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; #[test] diff --git a/stacks-common/src/deps_common/bitcoin/network/encodable.rs b/stacks-common/src/deps_common/bitcoin/network/encodable.rs index 7cfeeafd3..68d3af8b4 100644 --- a/stacks-common/src/deps_common/bitcoin/network/encodable.rs +++ b/stacks-common/src/deps_common/bitcoin/network/encodable.rs @@ -449,7 +449,6 @@ where #[cfg(test)] mod tests { use super::{CheckedData, VarInt}; - use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize, Error}; #[test] diff --git a/stacks-common/src/deps_common/bitcoin/network/message.rs b/stacks-common/src/deps_common/bitcoin/network/message.rs index ca116dee3..aabecc905 100644 --- a/stacks-common/src/deps_common/bitcoin/network/message.rs +++ b/stacks-common/src/deps_common/bitcoin/network/message.rs @@ -22,16 +22,15 @@ use std::io::Cursor; use std::iter; -use crate::deps_common::bitcoin::blockdata::block; -use crate::deps_common::bitcoin::blockdata::transaction; +use crate::deps_common::bitcoin::blockdata::{block, transaction}; use crate::deps_common::bitcoin::network::address::Address; -use crate::deps_common::bitcoin::network::encodable::CheckedData; -use crate::deps_common::bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable}; -use crate::deps_common::bitcoin::network::message_blockdata; -use crate::deps_common::bitcoin::network::message_network; +use crate::deps_common::bitcoin::network::encodable::{ + CheckedData, ConsensusDecodable, ConsensusEncodable, +}; use crate::deps_common::bitcoin::network::serialize::{ self, serialize, RawDecoder, SimpleDecoder, SimpleEncoder, }; +use crate::deps_common::bitcoin::network::{message_blockdata, message_network}; /// Serializer for command string #[derive(PartialEq, Eq, Clone, Debug)] @@ -211,7 +210,6 @@ impl ConsensusDecodable for RawNetworkMessage { #[cfg(test)] mod test { use super::{CommandString, NetworkMessage, RawNetworkMessage}; - use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; #[test] diff --git a/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs b/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs index a3662b8ce..90f26677d 100644 --- a/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs +++ b/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs @@ -135,13 +135,12 @@ impl ConsensusDecodable for Inventory { #[cfg(test)] mod tests { - use super::{GetBlocksMessage, GetHeadersMessage}; - - use crate::util::hash::hex_bytes as hex_decode; - - use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; use std::default::Default; + use super::{GetBlocksMessage, GetHeadersMessage}; + use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; + use crate::util::hash::hex_bytes as hex_decode; + #[test] fn getblocks_message_test() { let from_sat = hex_decode("72110100014a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b0000000000000000000000000000000000000000000000000000000000000000").unwrap(); diff --git a/stacks-common/src/deps_common/bitcoin/network/message_network.rs b/stacks-common/src/deps_common/bitcoin/network/message_network.rs index bd2a9cf1a..4b5f3569e 100644 --- a/stacks-common/src/deps_common/bitcoin/network/message_network.rs +++ b/stacks-common/src/deps_common/bitcoin/network/message_network.rs @@ -65,10 +65,8 @@ impl_consensus_encoding!( #[cfg(test)] mod tests { use super::VersionMessage; - - use crate::util::hash::hex_bytes as hex_decode; - use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize}; + use crate::util::hash::hex_bytes as hex_decode; #[test] fn version_message_test() { diff --git a/stacks-common/src/deps_common/bitcoin/network/mod.rs b/stacks-common/src/deps_common/bitcoin/network/mod.rs index 43745f10d..e4dbdaae2 100644 --- a/stacks-common/src/deps_common/bitcoin/network/mod.rs +++ b/stacks-common/src/deps_common/bitcoin/network/mod.rs @@ -18,9 +18,7 @@ //! of Bitcoin data and network messages. //! -use std::error; -use std::fmt; -use std::io; +use std::{error, fmt, io}; pub mod address; pub mod constants; diff --git a/stacks-common/src/deps_common/bitcoin/network/serialize.rs b/stacks-common/src/deps_common/bitcoin/network/serialize.rs index 64c68295b..cdaed40c4 100644 --- a/stacks-common/src/deps_common/bitcoin/network/serialize.rs +++ b/stacks-common/src/deps_common/bitcoin/network/serialize.rs @@ -19,16 +19,13 @@ //! It also defines (de)serialization routines for many primitives. //! -use crate::util::hash::to_hex as hex_encode; -use std::error; -use std::fmt; -use std::io; use std::io::{Cursor, Read, Write}; +use std::{error, fmt, io}; use crate::address; - use crate::deps_common::bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable}; use crate::deps_common::bitcoin::util::hash::Sha256dHash; +use crate::util::hash::to_hex as hex_encode; /// Serialization error #[derive(Debug)] diff --git a/stacks-common/src/deps_common/bitcoin/util/hash.rs b/stacks-common/src/deps_common/bitcoin/util/hash.rs index c4680a09e..a091cf12f 100644 --- a/stacks-common/src/deps_common/bitcoin/util/hash.rs +++ b/stacks-common/src/deps_common/bitcoin/util/hash.rs @@ -15,19 +15,16 @@ //! //! Utility functions related to hashing data, including merkleization -#[cfg(feature = "serde")] -use serde; use std::char::from_digit; use std::cmp::min; use std::default::Default; -use std::error; -use std::fmt; use std::io::{Cursor, Write}; -use std::mem; +use std::{error, fmt, mem}; use ripemd::Ripemd160; -use sha2::Digest; -use sha2::Sha256; +#[cfg(feature = "serde")] +use serde; +use sha2::{Digest, Sha256}; use crate::deps_common::bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable}; use crate::deps_common::bitcoin::network::serialize::{ diff --git a/stacks-common/src/deps_common/ctrlc/error.rs b/stacks-common/src/deps_common/ctrlc/error.rs index 5d18cf41c..81bb981b8 100644 --- a/stacks-common/src/deps_common/ctrlc/error.rs +++ b/stacks-common/src/deps_common/ctrlc/error.rs @@ -1,6 +1,7 @@ -use crate::deps_common::ctrlc::platform; use std::fmt; +use crate::deps_common::ctrlc::platform; + /// Ctrl-C error. #[derive(Debug)] pub enum Error { diff --git a/stacks-common/src/deps_common/ctrlc/mod.rs b/stacks-common/src/deps_common/ctrlc/mod.rs index 2d62628d7..d0ff20168 100644 --- a/stacks-common/src/deps_common/ctrlc/mod.rs +++ b/stacks-common/src/deps_common/ctrlc/mod.rs @@ -11,10 +11,11 @@ mod error; mod platform; -pub use self::error::Error; use std::sync::atomic::{AtomicBool, Ordering}; use std::thread; +pub use self::error::Error; + #[cfg(test)] mod tests; diff --git a/stacks-common/src/deps_common/ctrlc/platform/mod.rs b/stacks-common/src/deps_common/ctrlc/platform/mod.rs index f3b37e958..a6ec544a0 100644 --- a/stacks-common/src/deps_common/ctrlc/platform/mod.rs +++ b/stacks-common/src/deps_common/ctrlc/platform/mod.rs @@ -15,6 +15,5 @@ mod windows; #[cfg(unix)] pub use self::unix::*; - #[cfg(windows)] pub use self::windows::*; diff --git a/stacks-common/src/deps_common/ctrlc/platform/unix/mod.rs b/stacks-common/src/deps_common/ctrlc/platform/unix/mod.rs index c60aead51..840c977c1 100644 --- a/stacks-common/src/deps_common/ctrlc/platform/unix/mod.rs +++ b/stacks-common/src/deps_common/ctrlc/platform/unix/mod.rs @@ -7,10 +7,12 @@ // notice may not be copied, modified, or distributed except // according to those terms. +use std::os::unix::io::RawFd; + +use nix::unistd; + use crate::deps_common::ctrlc::error::Error as CtrlcError; use crate::deps_common::ctrlc::SignalId; -use nix::unistd; -use std::os::unix::io::RawFd; static mut PIPE: (RawFd, RawFd) = (-1, -1); diff --git a/stacks-common/src/deps_common/ctrlc/platform/windows/mod.rs b/stacks-common/src/deps_common/ctrlc/platform/windows/mod.rs index c4b9ca54a..1a79f6b12 100644 --- a/stacks-common/src/deps_common/ctrlc/platform/windows/mod.rs +++ b/stacks-common/src/deps_common/ctrlc/platform/windows/mod.rs @@ -7,8 +7,8 @@ // notice may not be copied, modified, or distributed except // according to those terms. -use std::io; -use std::ptr; +use std::{io, ptr}; + use winapi::ctypes::c_long; use winapi::shared::minwindef::{BOOL, DWORD, FALSE, TRUE}; use winapi::shared::ntdef::HANDLE; diff --git a/stacks-common/src/deps_common/ctrlc/tests.rs b/stacks-common/src/deps_common/ctrlc/tests.rs index 8d46f8d3d..de2743892 100644 --- a/stacks-common/src/deps_common/ctrlc/tests.rs +++ b/stacks-common/src/deps_common/ctrlc/tests.rs @@ -34,8 +34,7 @@ mod platform { #[cfg(windows)] mod platform { - use std::io; - use std::ptr; + use std::{io, ptr}; use winapi::shared::minwindef::DWORD; use winapi::shared::ntdef::{CHAR, HANDLE}; diff --git a/stacks-common/src/deps_common/httparse/mod.rs b/stacks-common/src/deps_common/httparse/mod.rs index b4e114ccd..aa95007d9 100644 --- a/stacks-common/src/deps_common/httparse/mod.rs +++ b/stacks-common/src/deps_common/httparse/mod.rs @@ -31,11 +31,7 @@ //! Originally written by Sean McArthur. //! //! Modified by Jude Nelson to remove all unsafe code. -use std::error; -use std::fmt; -use std::mem; -use std::result; -use std::str; +use std::{error, fmt, mem, result, str}; macro_rules! next { ($bytes:ident) => {{ @@ -1288,8 +1284,9 @@ mod tests { #[cfg(feature = "std")] #[test] fn test_std_error() { - use super::Error; use std::error::Error as StdError; + + use super::Error; let err = Error::HeaderName; assert_eq!(err.to_string(), err.description_str()); } diff --git a/stacks-common/src/libcommon.rs b/stacks-common/src/libcommon.rs index 79954d2ef..3da0d0e5a 100644 --- a/stacks-common/src/libcommon.rs +++ b/stacks-common/src/libcommon.rs @@ -52,8 +52,7 @@ pub mod deps_common; use crate::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId}; pub mod consts { - use crate::types::chainstate::BlockHeaderHash; - use crate::types::chainstate::ConsensusHash; + use crate::types::chainstate::{BlockHeaderHash, ConsensusHash}; pub const TOKEN_TRANSFER_MEMO_LENGTH: usize = 34; // same as it is in Stacks v1 diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs index eb3694810..d7f21babf 100644 --- a/stacks-common/src/types/chainstate.rs +++ b/stacks-common/src/types/chainstate.rs @@ -1,34 +1,21 @@ use std::fmt; -use std::io::Read; -use std::io::Write; +use std::io::{Read, Write}; use std::str::FromStr; use curve25519_dalek::digest::Digest; -use sha2::Sha256; -use sha2::{Digest as Sha2Digest, Sha512_256}; - -use crate::util::hash::{to_hex, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE}; -use crate::util::secp256k1::MessageSignature; -use crate::util::uint::Uint256; -use crate::util::vrf::VRFProof; - -use serde::de::Deserialize; -use serde::de::Error as de_Error; +use rand::{Rng, SeedableRng}; +use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; +use serde::de::{Deserialize, Error as de_Error}; use serde::ser::Error as ser_Error; use serde::Serialize; - -use crate::util::secp256k1::Secp256k1PrivateKey; -use crate::util::secp256k1::Secp256k1PublicKey; -use crate::util::vrf::VRF_PROOF_ENCODED_SIZE; +use sha2::{Digest as Sha2Digest, Sha256, Sha512_256}; use crate::codec::{read_next, write_next, Error as CodecError, StacksMessageCodec}; - use crate::deps_common::bitcoin::util::hash::Sha256dHash; -use rand::Rng; -use rand::SeedableRng; -use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; - -use crate::util::hash::DoubleSha256; +use crate::util::hash::{to_hex, DoubleSha256, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE}; +use crate::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey}; +use crate::util::uint::Uint256; +use crate::util::vrf::{VRFProof, VRF_PROOF_ENCODED_SIZE}; pub type StacksPublicKey = Secp256k1PublicKey; pub type StacksPrivateKey = Secp256k1PrivateKey; diff --git a/stacks-common/src/types/mod.rs b/stacks-common/src/types/mod.rs index 35bb97d86..919f027b5 100644 --- a/stacks-common/src/types/mod.rs +++ b/stacks-common/src/types/mod.rs @@ -1,22 +1,17 @@ -use crate::address::public_keys_to_address_hash; -use crate::types::chainstate::StacksPublicKey; -use crate::util::secp256k1::MessageSignature; -use crate::util::secp256k1::Secp256k1PublicKey; +use std::cmp::Ordering; use std::convert::TryFrom; use std::fmt; +use crate::address::c32::{c32_address, c32_address_decode}; use crate::address::{ - C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, - C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, + public_keys_to_address_hash, AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG, + C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, + C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; - -use crate::address::c32::c32_address; -use crate::address::c32::c32_address_decode; -use crate::address::AddressHashMode; use crate::deps_common::bitcoin::blockdata::transaction::TxOut; -use crate::types::chainstate::StacksAddress; +use crate::types::chainstate::{StacksAddress, StacksPublicKey}; use crate::util::hash::Hash160; -use std::cmp::Ordering; +use crate::util::secp256k1::{MessageSignature, Secp256k1PublicKey}; pub mod chainstate; diff --git a/stacks-common/src/util/chunked_encoding.rs b/stacks-common/src/util/chunked_encoding.rs index f8a411759..29c26379d 100644 --- a/stacks-common/src/util/chunked_encoding.rs +++ b/stacks-common/src/util/chunked_encoding.rs @@ -14,10 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; -use std::fmt; -use std::io; use std::io::{Read, Write}; +use std::{error, fmt, io}; use crate::codec::MAX_MESSAGE_LEN; use crate::deps_common::httparse; @@ -454,12 +452,13 @@ impl<'a, 'state, W: Write> Write for HttpChunkedTransferWriter<'a, 'state, W> { } mod test { - use super::*; use std::io; use std::io::{Read, Write}; use rand::RngCore; + use super::*; + /// Simulate reading variable-length segments struct SegmentReader { segments: Vec>, diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs index 3f7c16551..58a71969b 100644 --- a/stacks-common/src/util/hash.rs +++ b/stacks-common/src/util/hash.rs @@ -16,27 +16,21 @@ use std::char::from_digit; use std::convert::TryInto; -use std::fmt; use std::fmt::Write; -use std::mem; - -use crate::util::log; -use crate::util::pair::*; -use crate::util::secp256k1::Secp256k1PublicKey; -use crate::util::HexError; +use std::{fmt, mem}; use ripemd::Ripemd160; +use serde::de::{Deserialize, Error as de_Error}; +use serde::ser::Error as ser_Error; +use serde::Serialize; use sha2::{Digest, Sha256, Sha512, Sha512_256}; use sha3::Keccak256; -use crate::util::uint::Uint256; - use crate::types::StacksPublicKeyBuffer; - -use serde::de::Deserialize; -use serde::de::Error as de_Error; -use serde::ser::Error as ser_Error; -use serde::Serialize; +use crate::util::pair::*; +use crate::util::secp256k1::Secp256k1PublicKey; +use crate::util::uint::Uint256; +use crate::util::{log, HexError}; // hash function for Merkle trees pub trait MerkleHashFunc { @@ -686,13 +680,9 @@ pub fn bytes_to_hex(s: &[u8]) -> String { #[cfg(test)] mod test { - use super::bin_bytes; - use super::hex_bytes; - use super::to_bin; - use super::DoubleSha256; - use super::MerkleHashFunc; - use super::MerklePath; - use super::MerkleTree; + use super::{ + bin_bytes, hex_bytes, to_bin, DoubleSha256, MerkleHashFunc, MerklePath, MerkleTree, + }; struct MerkleTreeFixture { data: Vec>, diff --git a/stacks-common/src/util/log.rs b/stacks-common/src/util/log.rs index 73463cc45..4117a40c3 100644 --- a/stacks-common/src/util/log.rs +++ b/stacks-common/src/util/log.rs @@ -14,15 +14,14 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::io::Write; +use std::sync::Mutex; +use std::time::{Duration, SystemTime}; +use std::{env, io, thread}; + use chrono::prelude::*; use slog::{BorrowedKV, Drain, FnValue, Level, Logger, OwnedKVList, Record, KV}; use slog_term::{CountingWriter, Decorator, RecordDecorator, Serializer}; -use std::env; -use std::io; -use std::io::Write; -use std::sync::Mutex; -use std::thread; -use std::time::{Duration, SystemTime}; lazy_static! { pub static ref LOGGER: Logger = make_logger(); diff --git a/stacks-common/src/util/mod.rs b/stacks-common/src/util/mod.rs index 02e650158..dde6d8bc8 100644 --- a/stacks-common/src/util/mod.rs +++ b/stacks-common/src/util/mod.rs @@ -27,11 +27,8 @@ pub mod secp256k1; pub mod uint; pub mod vrf; -use std::error; -use std::fmt; -use std::thread; -use std::time; use std::time::{SystemTime, UNIX_EPOCH}; +use std::{error, fmt, thread, time}; pub fn get_epoch_time_secs() -> u64 { let start = SystemTime::now(); @@ -98,9 +95,9 @@ pub fn slice_partialeq(s1: &[T], s2: &[T]) -> bool { } pub mod db_common { + use std::{thread, time}; + use rand::{thread_rng, Rng}; - use std::thread; - use std::time; pub fn tx_busy_handler(run_count: i32) -> bool { let mut sleep_count = 10; diff --git a/stacks-common/src/util/pipe.rs b/stacks-common/src/util/pipe.rs index e04a8f8fb..ebb90f07b 100644 --- a/stacks-common/src/util/pipe.rs +++ b/stacks-common/src/util/pipe.rs @@ -19,12 +19,7 @@ use std::io; use std::io::{Read, Write}; - -use std::sync::mpsc::sync_channel; -use std::sync::mpsc::Receiver; -use std::sync::mpsc::SyncSender; -use std::sync::mpsc::TryRecvError; -use std::sync::mpsc::TrySendError; +use std::sync::mpsc::{sync_channel, Receiver, SyncSender, TryRecvError, TrySendError}; use crate::util::log; @@ -322,14 +317,15 @@ impl Write for PipeWrite { #[cfg(test)] mod test { - use super::*; - use crate::util::*; - use rand; - use rand::RngCore; - use std::io; use std::io::prelude::*; use std::io::{Read, Write}; - use std::thread; + use std::{io, thread}; + + use rand; + use rand::RngCore; + + use super::*; + use crate::util::*; #[test] fn test_connection_pipe_oneshot() { diff --git a/stacks-common/src/util/secp256k1.rs b/stacks-common/src/util/secp256k1.rs index 47a042129..811918ad2 100644 --- a/stacks-common/src/util/secp256k1.rs +++ b/stacks-common/src/util/secp256k1.rs @@ -14,30 +14,23 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use rand::{thread_rng, RngCore}; use secp256k1; -use secp256k1::constants as LibSecp256k1Constants; -use secp256k1::ecdsa::RecoverableSignature as LibSecp256k1RecoverableSignature; -use secp256k1::ecdsa::RecoveryId as LibSecp256k1RecoveryID; -use secp256k1::ecdsa::Signature as LibSecp256k1Signature; -use secp256k1::Error as LibSecp256k1Error; -use secp256k1::Message as LibSecp256k1Message; -use secp256k1::PublicKey as LibSecp256k1PublicKey; -use secp256k1::Secp256k1; -use secp256k1::SecretKey as LibSecp256k1PrivateKey; - -use crate::types::PrivateKey; -use crate::types::PublicKey; -use crate::util::hash::{hex_bytes, to_hex}; - -use serde::de::Deserialize; -use serde::de::Error as de_Error; +use secp256k1::ecdsa::{ + RecoverableSignature as LibSecp256k1RecoverableSignature, RecoveryId as LibSecp256k1RecoveryID, + Signature as LibSecp256k1Signature, +}; +use secp256k1::{ + constants as LibSecp256k1Constants, Error as LibSecp256k1Error, Message as LibSecp256k1Message, + PublicKey as LibSecp256k1PublicKey, Secp256k1, SecretKey as LibSecp256k1PrivateKey, +}; +use serde::de::{Deserialize, Error as de_Error}; use serde::ser::Error as ser_Error; use serde::Serialize; -use rand::thread_rng; -use rand::RngCore; - use super::hash::Sha256Sum; +use crate::types::{PrivateKey, PublicKey}; +use crate::util::hash::{hex_bytes, to_hex}; // per-thread Secp256k1 context thread_local!(static _secp256k1: Secp256k1 = Secp256k1::new()); @@ -427,16 +420,12 @@ pub fn secp256k1_verify( #[cfg(test)] mod tests { - use super::*; - - use crate::util::hash::hex_bytes; - use secp256k1; - use secp256k1::PublicKey as LibSecp256k1PublicKey; - use secp256k1::Secp256k1; + use secp256k1::{PublicKey as LibSecp256k1PublicKey, Secp256k1}; - use crate::util::get_epoch_time_ms; - use crate::util::log; + use super::*; + use crate::util::hash::hex_bytes; + use crate::util::{get_epoch_time_ms, log}; struct KeyFixture { input: I, diff --git a/stacks-common/src/util/uint.rs b/stacks-common/src/util/uint.rs index 87fc881a6..2ae441d27 100644 --- a/stacks-common/src/util/uint.rs +++ b/stacks-common/src/util/uint.rs @@ -19,10 +19,11 @@ //! Implementation of a various large-but-fixed sized unsigned integer types. //! The functions here are designed to be fast. //! -use crate::util::hash::{hex_bytes, to_hex}; /// Borrowed with gratitude from Andrew Poelstra's rust-bitcoin library use std::fmt; +use crate::util::hash::{hex_bytes, to_hex}; + /// A trait which allows numbers to act as fixed-size bit arrays pub trait BitArray { /// Is bit set? @@ -514,8 +515,7 @@ impl Uint512 { #[cfg(test)] mod tests { - use crate::util::uint::BitArray; - use crate::util::uint::Uint256; + use crate::util::uint::{BitArray, Uint256}; #[test] pub fn uint256_bits_test() { diff --git a/stacks-common/src/util/vrf.rs b/stacks-common/src/util/vrf.rs index 7a628d1a9..80622ff06 100644 --- a/stacks-common/src/util/vrf.rs +++ b/stacks-common/src/util/vrf.rs @@ -17,35 +17,26 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] -use crate::util::hash::to_hex; use std::clone::Clone; -use std::cmp::Eq; -use std::cmp::Ord; -use std::cmp::Ordering; -use std::cmp::PartialEq; +use std::cmp::{Eq, Ord, Ordering, PartialEq}; use std::fmt::Debug; use std::hash::{Hash, Hasher}; /// This codebase is based on routines defined in the IETF draft for verifiable random functions /// over elliptic curves (https://tools.ietf.org/id/draft-irtf-cfrg-vrf-02.html). use std::ops::Deref; use std::ops::DerefMut; - -use ed25519_dalek::Keypair as VRFKeypair; -use ed25519_dalek::PublicKey as ed25519_PublicKey; -use ed25519_dalek::SecretKey as ed25519_PrivateKey; +use std::{error, fmt}; use curve25519_dalek::constants::ED25519_BASEPOINT_POINT; use curve25519_dalek::edwards::{CompressedEdwardsY, EdwardsPoint}; use curve25519_dalek::scalar::Scalar as ed25519_Scalar; - -use sha2::Digest; -use sha2::Sha512; - -use std::error; -use std::fmt; - -use crate::util::hash::hex_bytes; +use ed25519_dalek::{ + Keypair as VRFKeypair, PublicKey as ed25519_PublicKey, SecretKey as ed25519_PrivateKey, +}; use rand; +use sha2::{Digest, Sha512}; + +use crate::util::hash::{hex_bytes, to_hex}; #[derive(Clone)] pub struct VRFPublicKey(pub ed25519_PublicKey); @@ -588,16 +579,13 @@ impl VRF { #[cfg(test)] mod tests { - use super::*; - - use crate::util::hash::hex_bytes; - use curve25519_dalek::scalar::Scalar as ed25519_Scalar; - - use sha2::Sha512; - use rand; use rand::RngCore; + use sha2::Sha512; + + use super::*; + use crate::util::hash::hex_bytes; #[derive(Debug)] struct VRF_Proof_Fixture { diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs index 5614c4219..732913384 100644 --- a/stacks-signer/src/cli.rs +++ b/stacks-signer/src/cli.rs @@ -1,8 +1,6 @@ -use std::{ - io::{self, Read}, - net::SocketAddr, - path::PathBuf, -}; +use std::io::{self, Read}; +use std::net::SocketAddr; +use std::path::PathBuf; use clap::Parser; use clarity::vm::types::QualifiedContractIdentifier; diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs index 8bd556c85..35965d648 100644 --- a/stacks-signer/src/config.rs +++ b/stacks-signer/src/config.rs @@ -14,18 +14,18 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::convert::TryFrom; +use std::fs; +use std::net::{SocketAddr, ToSocketAddrs}; +use std::path::PathBuf; +use std::time::Duration; + use clarity::vm::types::QualifiedContractIdentifier; use hashbrown::HashMap; -use p256k1::{ecdsa, scalar::Scalar}; +use p256k1::ecdsa; +use p256k1::scalar::Scalar; use serde::Deserialize; use stacks_common::types::chainstate::StacksPrivateKey; -use std::{ - convert::TryFrom, - fs, - net::{SocketAddr, ToSocketAddrs}, - path::PathBuf, - time::Duration, -}; use wsts::state_machine::PublicKeys; /// List of key_ids for each signer_id diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs index 09f55f6d8..2e1db38a2 100644 --- a/stacks-signer/src/main.rs +++ b/stacks-signer/src/main.rs @@ -26,41 +26,35 @@ extern crate serde; extern crate serde_json; extern crate toml; +use std::fs::File; +use std::io::{self, BufRead, Write}; +use std::net::SocketAddr; +use std::path::PathBuf; +use std::sync::mpsc::{channel, Receiver, Sender}; +use std::time::Duration; + use clap::Parser; use clarity::vm::types::QualifiedContractIdentifier; use libsigner::{RunningSigner, Signer, SignerSession, StackerDBEventReceiver, StackerDBSession}; use libstackerdb::StackerDBChunkData; use slog::slog_debug; -use stacks_common::{ - address::{ - AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, - C32_ADDRESS_VERSION_TESTNET_SINGLESIG, - }, - debug, - types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey}, +use stacks_common::address::{ + AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; -use stacks_signer::{ - cli::{ - Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, - RunDkgArgs, SignArgs, StackerDBArgs, - }, - config::{Config, Network}, - runloop::{RunLoop, RunLoopCommand}, - utils::{build_signer_config_tomls, build_stackerdb_contract}, -}; -use std::{ - fs::File, - io::{self, BufRead, Write}, - net::SocketAddr, - path::PathBuf, - sync::mpsc::{channel, Receiver, Sender}, - time::Duration, -}; -use tracing_subscriber::{fmt, prelude::*, EnvFilter}; -use wsts::{ - state_machine::{coordinator::frost::Coordinator as FrostCoordinator, OperationResult}, - v2, +use stacks_common::debug; +use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey}; +use stacks_signer::cli::{ + Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs, + SignArgs, StackerDBArgs, }; +use stacks_signer::config::{Config, Network}; +use stacks_signer::runloop::{RunLoop, RunLoopCommand}; +use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract}; +use tracing_subscriber::prelude::*; +use tracing_subscriber::{fmt, EnvFilter}; +use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator; +use wsts::state_machine::OperationResult; +use wsts::v2; struct SpawnedSigner { running_signer: RunningSigner>, diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs index c7828e103..69a1904e0 100644 --- a/stacks-signer/src/runloop.rs +++ b/stacks-signer/src/runloop.rs @@ -1,19 +1,21 @@ -use crate::{config::Config, stacks_client::StacksClient}; +use std::collections::VecDeque; +use std::sync::mpsc::Sender; +use std::time::Duration; + use libsigner::{SignerRunLoop, StackerDBChunksEvent}; use p256k1::ecdsa; use slog::{slog_debug, slog_error, slog_info, slog_warn}; use stacks_common::{debug, error, info, warn}; -use std::{collections::VecDeque, sync::mpsc::Sender, time::Duration}; -use wsts::{ - common::MerkleRoot, - net::{Message, Packet, Signable}, - state_machine::{ - coordinator::{frost::Coordinator as FrostCoordinator, Coordinatable}, - signer::SigningRound, - OperationResult, PublicKeys, - }, - v2, -}; +use wsts::common::MerkleRoot; +use wsts::net::{Message, Packet, Signable}; +use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator; +use wsts::state_machine::coordinator::Coordinatable; +use wsts::state_machine::signer::SigningRound; +use wsts::state_machine::{OperationResult, PublicKeys}; +use wsts::v2; + +use crate::config::Config; +use crate::stacks_client::StacksClient; /// Which operation to perform #[derive(PartialEq, Clone)] diff --git a/stacks-signer/src/stacks_client.rs b/stacks-signer/src/stacks_client.rs index 68e1cb60a..a2217be26 100644 --- a/stacks-signer/src/stacks_client.rs +++ b/stacks-signer/src/stacks_client.rs @@ -3,7 +3,8 @@ use hashbrown::HashMap; use libsigner::{RPCError, SignerSession, StackerDBSession}; use libstackerdb::{Error as StackerDBError, StackerDBChunkAckData, StackerDBChunkData}; use slog::{slog_debug, slog_warn}; -use stacks_common::{debug, types::chainstate::StacksPrivateKey, warn}; +use stacks_common::types::chainstate::StacksPrivateKey; +use stacks_common::{debug, warn}; use wsts::net::{Message, Packet}; use crate::config::Config; diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs index d4b5f5126..3c1e1b36c 100644 --- a/stacks-signer/src/utils.rs +++ b/stacks-signer/src/utils.rs @@ -3,10 +3,8 @@ use std::time::Duration; use p256k1::ecdsa; use rand_core::OsRng; use slog::slog_debug; -use stacks_common::{ - debug, - types::chainstate::{StacksAddress, StacksPrivateKey}, -}; +use stacks_common::debug; +use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey}; use wsts::Scalar; use crate::stacks_client::SLOTS_PER_USER; diff --git a/stackslib/src/blockstack_cli.rs b/stackslib/src/blockstack_cli.rs index 27a57b545..e85d02bc7 100644 --- a/stackslib/src/blockstack_cli.rs +++ b/stackslib/src/blockstack_cli.rs @@ -32,11 +32,10 @@ use blockstack_lib::burnchains::bitcoin::address::{ ADDRESS_VERSION_MAINNET_SINGLESIG, ADDRESS_VERSION_TESTNET_SINGLESIG, }; use blockstack_lib::burnchains::Address; -use blockstack_lib::chainstate::stacks::StacksBlockHeader; use blockstack_lib::chainstate::stacks::{ - StacksBlock, StacksMicroblock, StacksPrivateKey, StacksPublicKey, StacksTransaction, - StacksTransactionSigner, TokenTransferMemo, TransactionAnchorMode, TransactionAuth, - TransactionContractCall, TransactionPayload, TransactionSmartContract, + StacksBlock, StacksBlockHeader, StacksMicroblock, StacksPrivateKey, StacksPublicKey, + StacksTransaction, StacksTransactionSigner, TokenTransferMemo, TransactionAnchorMode, + TransactionAuth, TransactionContractCall, TransactionPayload, TransactionSmartContract, TransactionSpendingCondition, TransactionVersion, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; @@ -44,18 +43,13 @@ use blockstack_lib::clarity_cli::vm_execute; use blockstack_lib::core::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; use blockstack_lib::net::Error as NetError; use blockstack_lib::util_lib::strings::StacksString; -use clarity::vm::ClarityVersion; -use clarity::vm::{ - errors::{Error as ClarityError, RuntimeErrorType}, - types::PrincipalData, - ClarityName, ContractName, Value, -}; -use stacks_common::address::b58; -use stacks_common::address::AddressHashMode; +use clarity::vm::errors::{Error as ClarityError, RuntimeErrorType}; +use clarity::vm::types::PrincipalData; +use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value}; +use stacks_common::address::{b58, AddressHashMode}; use stacks_common::codec::{Error as CodecError, StacksMessageCodec}; use stacks_common::types::chainstate::StacksAddress; -use stacks_common::util::hash::hex_bytes; -use stacks_common::util::hash::to_hex; +use stacks_common::util::hash::{hex_bytes, to_hex}; use stacks_common::util::retry::LogReader; const USAGE: &str = "blockstack-cli (options) [method] [args...] diff --git a/stackslib/src/burnchains/affirmation.rs b/stackslib/src/burnchains/affirmation.rs index f7bde0ac5..b7a83f2f1 100644 --- a/stackslib/src/burnchains/affirmation.rs +++ b/stackslib/src/burnchains/affirmation.rs @@ -238,31 +238,27 @@ use std::fmt::Write; use std::sync::mpsc::SyncSender; use std::time::Duration; -use crate::burnchains::{ - db::{BurnchainBlockData, BurnchainDB, BurnchainDBTransaction, BurnchainHeaderReader}, - Address, Burnchain, BurnchainBlockHeader, Error, PoxConstants, Txid, -}; -use crate::chainstate::burn::{ - db::sortdb::SortitionDB, - operations::leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS}, - operations::BlockstackOperationType, - operations::LeaderBlockCommitOp, - BlockSnapshot, ConsensusHash, -}; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as DBError; - -use crate::core::StacksEpochId; - -use crate::util_lib::boot::boot_code_id; +use serde::de::Error as de_Error; +use serde::ser::Error as ser_Error; +use serde::{Deserialize, Serialize}; use stacks_common::types::chainstate::{ BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, StacksBlockId, }; -use serde::de::Error as de_Error; -use serde::ser::Error as ser_Error; -use serde::{Deserialize, Serialize}; +use crate::burnchains::db::{ + BurnchainBlockData, BurnchainDB, BurnchainDBTransaction, BurnchainHeaderReader, +}; +use crate::burnchains::{Address, Burnchain, BurnchainBlockHeader, Error, PoxConstants, Txid}; +use crate::chainstate::burn::db::sortdb::SortitionDB; +use crate::chainstate::burn::operations::leader_block_commit::{ + RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS, +}; +use crate::chainstate::burn::operations::{BlockstackOperationType, LeaderBlockCommitOp}; +use crate::chainstate::burn::{BlockSnapshot, ConsensusHash}; +use crate::chainstate::stacks::StacksBlockHeader; +use crate::core::StacksEpochId; +use crate::util_lib::boot::boot_code_id; +use crate::util_lib::db::{DBConn, Error as DBError}; /// Affirmation map entries. By building on a PoX-mined block, /// a PoB-mined block (in a PoX reward cycle), diff --git a/stackslib/src/burnchains/bitcoin/address.rs b/stackslib/src/burnchains/bitcoin/address.rs index 165906203..bc5ab4b45 100644 --- a/stackslib/src/burnchains/bitcoin/address.rs +++ b/stackslib/src/burnchains/bitcoin/address.rs @@ -14,9 +14,6 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::burnchains::bitcoin::BitcoinNetworkType; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::Address; use stacks_common::address::b58 as base58; use stacks_common::address::c32::c32_address; use stacks_common::deps_common::bech32; @@ -27,6 +24,8 @@ use stacks_common::deps_common::bitcoin::blockdata::transaction::TxOut; use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; use stacks_common::util::log; +use crate::burnchains::bitcoin::{BitcoinNetworkType, Error as btc_error}; +use crate::burnchains::Address; use crate::chainstate::stacks::{ C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, @@ -699,7 +698,6 @@ impl Address for BitcoinAddress { #[cfg(test)] mod tests { - use crate::burnchains::bitcoin::BitcoinNetworkType; use stacks_common::types::Address; use stacks_common::util::hash::{hex_bytes, Hash160}; use stacks_common::util::log; @@ -707,6 +705,7 @@ mod tests { use super::{ BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType, SegwitBitcoinAddress, }; + use crate::burnchains::bitcoin::BitcoinNetworkType; struct AddressFixture { addr: String, diff --git a/stackslib/src/burnchains/bitcoin/bits.rs b/stackslib/src/burnchains/bitcoin/bits.rs index 6fd387ea1..ec721fba3 100644 --- a/stackslib/src/burnchains/bitcoin/bits.rs +++ b/stackslib/src/burnchains/bitcoin/bits.rs @@ -14,34 +14,29 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use sha2::Digest; -use sha2::Sha256; - -use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType}; -use crate::burnchains::bitcoin::keys::BitcoinPublicKey; -use crate::burnchains::bitcoin::BitcoinNetworkType; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::bitcoin::{ - BitcoinInputType, BitcoinTxInput, BitcoinTxInputRaw, BitcoinTxInputStructured, BitcoinTxOutput, -}; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; -use stacks_common::address::public_keys_to_address_hash; -use stacks_common::address::AddressHashMode; -use stacks_common::deps_common::bitcoin::blockdata::opcodes::All as btc_opcodes; -use stacks_common::deps_common::bitcoin::blockdata::opcodes::Class; +use sha2::{Digest, Sha256}; +use stacks_common::address::{public_keys_to_address_hash, AddressHashMode}; +use stacks_common::deps_common::bitcoin::blockdata::opcodes::{All as btc_opcodes, Class}; use stacks_common::deps_common::bitcoin::blockdata::script::{Builder, Instruction, Script}; -use stacks_common::deps_common::bitcoin::blockdata::transaction::TxIn as BtcTxIn; -use stacks_common::deps_common::bitcoin::blockdata::transaction::TxOut as BtcTxOut; +use stacks_common::deps_common::bitcoin::blockdata::transaction::{ + TxIn as BtcTxIn, TxOut as BtcTxOut, +}; use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; +use stacks_common::types::chainstate::BurnchainHeaderHash; use stacks_common::util::hash::{hex_bytes, Hash160}; use stacks_common::util::log; +use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType}; +use crate::burnchains::bitcoin::keys::BitcoinPublicKey; +use crate::burnchains::bitcoin::{ + BitcoinInputType, BitcoinNetworkType, BitcoinTxInput, BitcoinTxInputRaw, + BitcoinTxInputStructured, BitcoinTxOutput, Error as btc_error, +}; +use crate::burnchains::{PublicKey, Txid}; use crate::chainstate::stacks::{ C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; -use stacks_common::types::chainstate::BurnchainHeaderHash; /// Parse a script into its structured constituant opcodes and data and collect them pub fn parse_script<'a>(script: &'a Script) -> Vec> { @@ -639,24 +634,22 @@ impl BitcoinTxOutput { #[cfg(test)] mod tests { + use stacks_common::deps_common::bitcoin::blockdata::script::{Builder, Script}; + use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; + use stacks_common::deps_common::bitcoin::network::serialize::deserialize as bitcoinlib_deserialize; + use stacks_common::util::hash::hex_bytes; + use stacks_common::util::log; + + use super::{ + parse_script, to_txid, BitcoinTxInput, BitcoinTxInputRaw, BitcoinTxInputStructured, + BitcoinTxOutput, + }; use crate::burnchains::bitcoin::address::{ BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType, SegwitBitcoinAddress, }; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; - use crate::burnchains::bitcoin::BitcoinInputType; - use crate::burnchains::bitcoin::BitcoinNetworkType; + use crate::burnchains::bitcoin::{BitcoinInputType, BitcoinNetworkType}; use crate::burnchains::Txid; - use stacks_common::deps_common::bitcoin::blockdata::script::{Builder, Script}; - use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; - use stacks_common::util::hash::hex_bytes; - use stacks_common::util::log; - - use super::parse_script; - use super::to_txid; - use super::BitcoinTxOutput; - use super::{BitcoinTxInput, BitcoinTxInputRaw, BitcoinTxInputStructured}; - - use stacks_common::deps_common::bitcoin::network::serialize::deserialize as bitcoinlib_deserialize; struct ScriptFixture { script: Script, diff --git a/stackslib/src/burnchains/bitcoin/blocks.rs b/stackslib/src/burnchains/bitcoin/blocks.rs index 3123d66c3..0cee9e60e 100644 --- a/stackslib/src/burnchains/bitcoin/blocks.rs +++ b/stackslib/src/burnchains/bitcoin/blocks.rs @@ -16,26 +16,6 @@ use std::ops::Deref; -use crate::burnchains::bitcoin::address::BitcoinAddress; -use crate::burnchains::bitcoin::bits; -use crate::burnchains::bitcoin::indexer::BitcoinIndexer; -use crate::burnchains::bitcoin::keys::BitcoinPublicKey; -use crate::burnchains::bitcoin::messages::BitcoinMessageHandler; -use crate::burnchains::bitcoin::BitcoinInputType; -use crate::burnchains::bitcoin::BitcoinNetworkType; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::bitcoin::PeerMessage; -use crate::burnchains::bitcoin::{ - BitcoinBlock, BitcoinTransaction, BitcoinTxInput, BitcoinTxOutput, -}; -use crate::burnchains::indexer::{ - BurnBlockIPC, BurnHeaderIPC, BurnchainBlockDownloader, BurnchainBlockParser, -}; -use crate::burnchains::Error as burnchain_error; -use crate::burnchains::{ - BurnchainBlock, BurnchainTransaction, MagicBytes, Txid, MAGIC_BYTES_LENGTH, -}; -use crate::deps; use stacks_common::deps_common::bitcoin::blockdata::block::{Block, LoneBlockHeader}; use stacks_common::deps_common::bitcoin::blockdata::opcodes::All as btc_opcodes; use stacks_common::deps_common::bitcoin::blockdata::script::{Instruction, Script}; @@ -43,12 +23,27 @@ use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; use stacks_common::deps_common::bitcoin::network::message as btc_message; use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; use stacks_common::deps_common::bitcoin::util::hash::bitcoin_merkle_root; +use stacks_common::types::chainstate::BurnchainHeaderHash; use stacks_common::util::hash::to_hex; use stacks_common::util::log; -use stacks_common::types::chainstate::BurnchainHeaderHash; - +use crate::burnchains::bitcoin::address::BitcoinAddress; +use crate::burnchains::bitcoin::indexer::BitcoinIndexer; +use crate::burnchains::bitcoin::keys::BitcoinPublicKey; +use crate::burnchains::bitcoin::messages::BitcoinMessageHandler; +use crate::burnchains::bitcoin::{ + bits, BitcoinBlock, BitcoinInputType, BitcoinNetworkType, BitcoinTransaction, BitcoinTxInput, + BitcoinTxOutput, Error as btc_error, PeerMessage, +}; +use crate::burnchains::indexer::{ + BurnBlockIPC, BurnHeaderIPC, BurnchainBlockDownloader, BurnchainBlockParser, +}; +use crate::burnchains::{ + BurnchainBlock, BurnchainTransaction, Error as burnchain_error, MagicBytes, Txid, + MAGIC_BYTES_LENGTH, +}; use crate::core::StacksEpochId; +use crate::deps; #[derive(Debug, Clone, PartialEq)] pub struct BitcoinHeaderIPC { @@ -548,26 +543,24 @@ impl BurnchainBlockParser for BitcoinBlockParser { #[cfg(test)] mod tests { - use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType}; - use crate::burnchains::bitcoin::keys::BitcoinPublicKey; - use crate::burnchains::bitcoin::BitcoinNetworkType; - use crate::burnchains::bitcoin::{ - BitcoinBlock, BitcoinInputType, BitcoinTransaction, BitcoinTxInput, BitcoinTxInputRaw, - BitcoinTxInputStructured, BitcoinTxOutput, - }; - use crate::burnchains::{BurnchainBlock, BurnchainTransaction, MagicBytes, Txid}; - use crate::core::StacksEpochId; use stacks_common::deps_common::bitcoin::blockdata::block::{Block, LoneBlockHeader}; use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; use stacks_common::deps_common::bitcoin::network::encodable::VarInt; use stacks_common::deps_common::bitcoin::network::serialize::deserialize; + use stacks_common::types::chainstate::BurnchainHeaderHash; use stacks_common::types::Address; use stacks_common::util::hash::hex_bytes; use stacks_common::util::log; - use stacks_common::types::chainstate::BurnchainHeaderHash; - use super::BitcoinBlockParser; + use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType}; + use crate::burnchains::bitcoin::keys::BitcoinPublicKey; + use crate::burnchains::bitcoin::{ + BitcoinBlock, BitcoinInputType, BitcoinNetworkType, BitcoinTransaction, BitcoinTxInput, + BitcoinTxInputRaw, BitcoinTxInputStructured, BitcoinTxOutput, + }; + use crate::burnchains::{BurnchainBlock, BurnchainTransaction, MagicBytes, Txid}; + use crate::core::StacksEpochId; struct TxFixture { txstr: String, diff --git a/stackslib/src/burnchains/bitcoin/indexer.rs b/stackslib/src/burnchains/bitcoin/indexer.rs index 5b78b9c47..c273a38de 100644 --- a/stackslib/src/burnchains/bitcoin/indexer.rs +++ b/stackslib/src/burnchains/bitcoin/indexer.rs @@ -14,52 +14,41 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use rand::{thread_rng, Rng}; -use std::cmp; -use std::fs; -use std::net; +use std::convert::TryFrom; use std::net::Shutdown; -use std::ops::Deref; -use std::ops::DerefMut; -use std::path; +use std::ops::{Deref, DerefMut}; use std::path::PathBuf; -use std::time; +use std::sync::atomic::AtomicBool; +use std::sync::Arc; use std::time::Duration; +use std::{cmp, fs, net, path, time}; -use crate::burnchains::bitcoin::blocks::BitcoinHeaderIPC; -use crate::burnchains::bitcoin::messages::BitcoinMessageHandler; -use crate::burnchains::bitcoin::spv::*; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::db::BurnchainHeaderReader; -use crate::burnchains::indexer::BurnchainIndexer; -use crate::burnchains::indexer::*; -use crate::burnchains::Burnchain; -use crate::util_lib::db::Error as DBError; - -use crate::burnchains::bitcoin::blocks::{BitcoinBlockDownloader, BitcoinBlockParser}; -use crate::burnchains::bitcoin::BitcoinNetworkType; - -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::Error as burnchain_error; -use crate::burnchains::MagicBytes; -use crate::burnchains::BLOCKSTACK_MAGIC_MAINNET; -use stacks_common::types::chainstate::BurnchainHeaderHash; - +use rand::{thread_rng, Rng}; use stacks_common::deps_common::bitcoin::blockdata::block::{BlockHeader, LoneBlockHeader}; use stacks_common::deps_common::bitcoin::network::encodable::VarInt; use stacks_common::deps_common::bitcoin::network::message::NetworkMessage; -use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; -use stacks_common::deps_common::bitcoin::network::serialize::Error as btc_serialization_err; +use stacks_common::deps_common::bitcoin::network::serialize::{ + BitcoinHash, Error as btc_serialization_err, +}; use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::log; +use stacks_common::types::chainstate::BurnchainHeaderHash; +use stacks_common::util::{get_epoch_time_secs, log}; +use crate::burnchains::bitcoin::blocks::{ + BitcoinBlockDownloader, BitcoinBlockParser, BitcoinHeaderIPC, +}; +use crate::burnchains::bitcoin::messages::BitcoinMessageHandler; +use crate::burnchains::bitcoin::spv::*; +use crate::burnchains::bitcoin::{BitcoinNetworkType, Error as btc_error}; +use crate::burnchains::db::BurnchainHeaderReader; +use crate::burnchains::indexer::{BurnchainIndexer, *}; +use crate::burnchains::{ + Burnchain, BurnchainBlockHeader, Error as burnchain_error, MagicBytes, BLOCKSTACK_MAGIC_MAINNET, +}; use crate::core::{ StacksEpoch, STACKS_EPOCHS_MAINNET, STACKS_EPOCHS_REGTEST, STACKS_EPOCHS_TESTNET, }; -use std::convert::TryFrom; -use std::sync::atomic::AtomicBool; -use std::sync::Arc; +use crate::util_lib::db::Error as DBError; pub const USER_AGENT: &'static str = "Stacks/2.1"; @@ -1202,11 +1191,8 @@ impl BurnchainHeaderReader for BitcoinIndexer { #[cfg(test)] mod test { - use super::*; - use crate::burnchains::bitcoin::Error as btc_error; - use crate::burnchains::bitcoin::*; - use crate::burnchains::Error as burnchain_error; - use crate::burnchains::*; + use std::sync::atomic::Ordering; + use std::{env, thread}; use stacks_common::deps_common::bitcoin::blockdata::block::{BlockHeader, LoneBlockHeader}; use stacks_common::deps_common::bitcoin::network::encodable::VarInt; @@ -1217,8 +1203,9 @@ mod test { use stacks_common::util::get_epoch_time_secs; use stacks_common::util::uint::Uint256; - use std::sync::atomic::Ordering; - use std::{env, thread}; + use super::*; + use crate::burnchains::bitcoin::{Error as btc_error, *}; + use crate::burnchains::{Error as burnchain_error, *}; #[test] fn test_indexer_find_bitcoin_reorg_genesis() { diff --git a/stackslib/src/burnchains/bitcoin/messages.rs b/stackslib/src/burnchains/bitcoin/messages.rs index 21dba2207..a58f7c039 100644 --- a/stackslib/src/burnchains/bitcoin/messages.rs +++ b/stackslib/src/burnchains/bitcoin/messages.rs @@ -15,8 +15,7 @@ // along with this program. If not, see . use crate::burnchains::bitcoin::indexer::BitcoinIndexer; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::bitcoin::PeerMessage; +use crate::burnchains::bitcoin::{Error as btc_error, PeerMessage}; pub trait BitcoinMessageHandler { fn begin_session(&mut self, indexer: &mut BitcoinIndexer) -> Result; diff --git a/stackslib/src/burnchains/bitcoin/mod.rs b/stackslib/src/burnchains/bitcoin/mod.rs index bfbd5cfa1..d273b1f5f 100644 --- a/stackslib/src/burnchains/bitcoin/mod.rs +++ b/stackslib/src/burnchains/bitcoin/mod.rs @@ -17,10 +17,12 @@ // This module is concerned with the implementation of the BitcoinIndexer // structure and its methods and traits. -use std::error; -use std::fmt; -use std::io; use std::sync::Arc; +use std::{error, fmt, io}; + +use stacks_common::deps_common::bitcoin::network::serialize::Error as btc_serialize_error; +use stacks_common::types::chainstate::BurnchainHeaderHash; +use stacks_common::util::HexError as btc_hex_error; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; @@ -28,10 +30,6 @@ use crate::burnchains::Txid; use crate::chainstate::burn::operations::BlockstackOperationType; use crate::deps; use crate::util_lib::db::Error as db_error; -use stacks_common::deps_common::bitcoin::network::serialize::Error as btc_serialize_error; -use stacks_common::util::HexError as btc_hex_error; - -use stacks_common::types::chainstate::BurnchainHeaderHash; pub mod address; pub mod bits; diff --git a/stackslib/src/burnchains/bitcoin/network.rs b/stackslib/src/burnchains/bitcoin/network.rs index 124430018..d29c7b2aa 100644 --- a/stackslib/src/burnchains/bitcoin/network.rs +++ b/stackslib/src/burnchains/bitcoin/network.rs @@ -14,39 +14,31 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::io; use std::io::Write; use std::net::SocketAddr; use std::ops::Deref; use std::sync::atomic::Ordering; -use std::thread; -use std::time; use std::time::{SystemTime, UNIX_EPOCH}; +use std::{io, thread, time}; use rand::{thread_rng, Rng}; - -use stacks_common::deps_common::bitcoin::network::address as btc_network_address; -use stacks_common::deps_common::bitcoin::network::constants as btc_constants; use stacks_common::deps_common::bitcoin::network::encodable::{ ConsensusDecodable, ConsensusEncodable, }; -use stacks_common::deps_common::bitcoin::network::message as btc_message; -use stacks_common::deps_common::bitcoin::network::message_blockdata as btc_message_blockdata; -use stacks_common::deps_common::bitcoin::network::message_network as btc_message_network; -use stacks_common::deps_common::bitcoin::network::serialize as btc_serialize; use stacks_common::deps_common::bitcoin::network::serialize::{RawDecoder, RawEncoder}; - +use stacks_common::deps_common::bitcoin::network::{ + address as btc_network_address, constants as btc_constants, message as btc_message, + message_blockdata as btc_message_blockdata, message_network as btc_message_network, + serialize as btc_serialize, +}; use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; +use stacks_common::util::{get_epoch_time_secs, log}; use crate::burnchains::bitcoin::indexer::{network_id_to_bytes, BitcoinIndexer}; use crate::burnchains::bitcoin::messages::BitcoinMessageHandler; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::bitcoin::PeerMessage; +use crate::burnchains::bitcoin::{Error as btc_error, PeerMessage}; use crate::burnchains::indexer::BurnchainIndexer; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::log; - // Based on Andrew Poelstra's rust-bitcoin library. impl BitcoinIndexer { /// Send a Bitcoin protocol message on the wire diff --git a/stackslib/src/burnchains/bitcoin/spv.rs b/stackslib/src/burnchains/bitcoin/spv.rs index 28746fcda..a5627db4d 100644 --- a/stackslib/src/burnchains/bitcoin/spv.rs +++ b/stackslib/src/burnchains/bitcoin/spv.rs @@ -14,12 +14,13 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; use std::collections::VecDeque; -use std::fs; use std::io::{Read, Seek, SeekFrom, Write}; use std::ops::Deref; +use std::{cmp, fs}; +use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; +use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS}; use stacks_common::deps_common::bitcoin::blockdata::block::{BlockHeader, LoneBlockHeader}; use stacks_common::deps_common::bitcoin::blockdata::constants::genesis_block; use stacks_common::deps_common::bitcoin::network::constants::Network; @@ -29,30 +30,18 @@ use stacks_common::deps_common::bitcoin::network::serialize::{ deserialize, serialize, BitcoinHash, }; use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; - +use stacks_common::types::chainstate::BurnchainHeaderHash; +use stacks_common::util::hash::{hex_bytes, to_hex}; use stacks_common::util::uint::Uint256; +use stacks_common::util::{get_epoch_time_secs, log}; use crate::burnchains::bitcoin::indexer::BitcoinIndexer; use crate::burnchains::bitcoin::messages::BitcoinMessageHandler; -use crate::burnchains::bitcoin::BitcoinNetworkType; -use crate::burnchains::bitcoin::Error as btc_error; -use crate::burnchains::bitcoin::PeerMessage; - -use stacks_common::types::chainstate::BurnchainHeaderHash; - -use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; -use rusqlite::OptionalExtension; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::{Connection, OpenFlags, NO_PARAMS}; - +use crate::burnchains::bitcoin::{BitcoinNetworkType, Error as btc_error, PeerMessage}; use crate::util_lib::db::{ query_int, query_row, query_rows, sqlite_open, tx_begin_immediate, tx_busy_handler, u64_to_sql, DBConn, DBTx, Error as db_error, FromColumn, FromRow, }; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::{hex_bytes, to_hex}; -use stacks_common::util::log; const BLOCK_HEADER_SIZE: u64 = 81; @@ -1318,10 +1307,7 @@ impl BitcoinMessageHandler for SpvClient { #[cfg(test)] mod test { - use super::*; - use crate::burnchains::bitcoin::Error as btc_error; - use crate::burnchains::bitcoin::*; - + use std::env; use std::fs::*; use stacks_common::deps_common::bitcoin::blockdata::block::{BlockHeader, LoneBlockHeader}; @@ -1329,10 +1315,10 @@ mod test { deserialize, serialize, BitcoinHash, }; use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; - use stacks_common::util::log; - use std::env; + use super::*; + use crate::burnchains::bitcoin::{Error as btc_error, *}; fn get_genesis_regtest_header() -> LoneBlockHeader { let genesis_regtest_header = LoneBlockHeader { @@ -1797,12 +1783,11 @@ mod test { #[test] fn test_witness_size() { - use stacks_common::deps_common::bitcoin::blockdata::script::Script; - use stacks_common::deps_common::bitcoin::blockdata::transaction::OutPoint; - use stacks_common::deps_common::bitcoin::blockdata::transaction::TxIn; - use stacks_common::deps_common::bitcoin::blockdata::transaction::TxOut; use std::mem; + use stacks_common::deps_common::bitcoin::blockdata::script::Script; + use stacks_common::deps_common::bitcoin::blockdata::transaction::{OutPoint, TxIn, TxOut}; + println!("OutPoint size in memory {}", mem::size_of::()); println!("TxIn in memory {}", mem::size_of::()); println!("TxOut size in memory {}", mem::size_of::()); diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs index 7b4d97c73..4ba47f804 100644 --- a/stackslib/src/burnchains/burnchain.rs +++ b/stackslib/src/burnchains/burnchain.rs @@ -14,80 +14,61 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::collections::HashMap; -use std::collections::HashSet; +use std::collections::{HashMap, HashSet}; use std::convert::TryFrom; -use std::fs; use std::marker::Send; use std::path::PathBuf; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::mpsc::sync_channel; -use std::sync::{ - atomic::{AtomicBool, AtomicU64, Ordering}, - Arc, -}; -use std::thread; +use std::sync::Arc; use std::time::{Duration, Instant}; +use std::{fs, thread}; + +use stacks_common::address::{public_keys_to_address_hash, AddressHashMode}; +use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash as BitcoinSha256dHash; +use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId, StacksAddress, TrieHash}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::vrf::VRFPublicKey; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log, sleep_ms}; use crate::burnchains::affirmation::update_pox_affirmation_maps; -use crate::burnchains::bitcoin::address::to_c32_version_byte; -use crate::burnchains::bitcoin::address::BitcoinAddress; -use crate::burnchains::bitcoin::address::LegacyBitcoinAddressType; -use crate::burnchains::bitcoin::BitcoinNetworkType; -use crate::burnchains::bitcoin::{BitcoinInputType, BitcoinTxInput, BitcoinTxOutput}; +use crate::burnchains::bitcoin::address::{ + to_c32_version_byte, BitcoinAddress, LegacyBitcoinAddressType, +}; +use crate::burnchains::bitcoin::indexer::BitcoinIndexer; +use crate::burnchains::bitcoin::{ + BitcoinInputType, BitcoinNetworkType, BitcoinTxInput, BitcoinTxOutput, +}; use crate::burnchains::db::{BurnchainDB, BurnchainHeaderReader}; use crate::burnchains::indexer::{ BurnBlockIPC, BurnHeaderIPC, BurnchainBlockDownloader, BurnchainBlockParser, BurnchainIndexer, }; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; use crate::burnchains::{ - BurnchainBlock, BurnchainBlockHeader, BurnchainParameters, BurnchainRecipient, BurnchainSigner, - BurnchainStateTransition, BurnchainStateTransitionOps, BurnchainTransaction, - Error as burnchain_error, PoxConstants, + Address, Burnchain, BurnchainBlock, BurnchainBlockHeader, BurnchainParameters, + BurnchainRecipient, BurnchainSigner, BurnchainStateTransition, BurnchainStateTransitionOps, + BurnchainTransaction, Error as burnchain_error, PoxConstants, PublicKey, Txid, +}; +use crate::chainstate::burn::db::sortdb::{ + SortitionDB, SortitionHandle, SortitionHandleConn, SortitionHandleTx, }; -use crate::chainstate::burn::db::sortdb::SortitionHandle; -use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleConn, SortitionHandleTx}; use crate::chainstate::burn::distribution::BurnSamplePoint; +use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit; use crate::chainstate::burn::operations::{ - leader_block_commit::MissedBlockCommit, BlockstackOperationType, DelegateStxOp, - LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, - UserBurnSupportOp, + BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, + StackStxOp, TransferStxOp, UserBurnSupportOp, }; use crate::chainstate::burn::{BlockSnapshot, Opcodes}; use crate::chainstate::coordinator::comm::CoordinatorChannels; -use crate::chainstate::stacks::address::PoxAddress; +use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; +use crate::chainstate::stacks::boot::{POX_2_MAINNET_CODE, POX_2_TESTNET_CODE}; use crate::chainstate::stacks::StacksPublicKey; -use crate::core::MINING_COMMITMENT_WINDOW; -use crate::core::NETWORK_ID_MAINNET; -use crate::core::NETWORK_ID_TESTNET; -use crate::core::PEER_VERSION_MAINNET; -use crate::core::PEER_VERSION_TESTNET; -use crate::core::{StacksEpoch, StacksEpochId}; +use crate::core::{ + StacksEpoch, StacksEpochId, MINING_COMMITMENT_WINDOW, NETWORK_ID_MAINNET, NETWORK_ID_TESTNET, + PEER_VERSION_MAINNET, PEER_VERSION_TESTNET, STACKS_2_0_LAST_BLOCK_TO_PROCESS, +}; use crate::deps; use crate::monitoring::update_burnchain_height; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; -use crate::util_lib::db::Error as db_error; -use stacks_common::address::public_keys_to_address_hash; -use stacks_common::address::AddressHashMode; -use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash as BitcoinSha256dHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::vrf::VRFPublicKey; -use stacks_common::util::{get_epoch_time_ms, sleep_ms}; - -use crate::burnchains::bitcoin::indexer::BitcoinIndexer; -use crate::chainstate::stacks::boot::POX_2_MAINNET_CODE; -use crate::chainstate::stacks::boot::POX_2_TESTNET_CODE; -use crate::core::STACKS_2_0_LAST_BLOCK_TO_PROCESS; -use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId}; - -use crate::chainstate::stacks::address::StacksAddressExtensions; +use crate::util_lib::db::{DBConn, DBTx, Error as db_error}; impl BurnchainStateTransitionOps { pub fn noop() -> BurnchainStateTransitionOps { @@ -577,8 +558,7 @@ impl Burnchain { first_block_hash: &BurnchainHeaderHash, ) -> Burnchain { use rand::rngs::ThreadRng; - use rand::thread_rng; - use rand::RngCore; + use rand::{thread_rng, RngCore}; let mut rng = thread_rng(); let mut byte_tail = [0u8; 16]; diff --git a/stackslib/src/burnchains/db.rs b/stackslib/src/burnchains/db.rs index c9f817cb4..e9b9f640b 100644 --- a/stackslib/src/burnchains/db.rs +++ b/stackslib/src/burnchains/db.rs @@ -14,33 +14,28 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::fmt; - use std::collections::{HashMap, HashSet}; -use std::{cmp, fs, io, path::Path}; +use std::path::Path; +use std::{cmp, fmt, fs, io}; -use rusqlite::{ - types::ToSql, Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS, -}; +use rusqlite::types::ToSql; +use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS}; use serde_json; +use stacks_common::types::chainstate::BurnchainHeaderHash; use crate::burnchains::affirmation::*; -use crate::burnchains::Txid; -use crate::burnchains::{Burnchain, BurnchainBlock, BurnchainBlockHeader, Error as BurnchainError}; -use crate::chainstate::burn::operations::BlockstackOperationType; -use crate::chainstate::burn::operations::LeaderBlockCommitOp; +use crate::burnchains::{ + Burnchain, BurnchainBlock, BurnchainBlockHeader, Error as BurnchainError, Txid, +}; +use crate::chainstate::burn::operations::{BlockstackOperationType, LeaderBlockCommitOp}; use crate::chainstate::burn::BlockSnapshot; -use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId}; +use crate::core::StacksEpochId; use crate::util_lib::db::{ opt_u64_to_sql, query_row, query_row_panic, query_rows, sql_pragma, sqlite_open, tx_begin_immediate, tx_busy_handler, u64_to_sql, DBConn, Error as DBError, FromColumn, FromRow, }; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use stacks_common::types::chainstate::BurnchainHeaderHash; - -use crate::core::StacksEpochId; - pub struct BurnchainDB { conn: Connection, } diff --git a/stackslib/src/burnchains/indexer.rs b/stackslib/src/burnchains/indexer.rs index a53c3286a..5d8eef99a 100644 --- a/stackslib/src/burnchains/indexer.rs +++ b/stackslib/src/burnchains/indexer.rs @@ -14,13 +14,11 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::burnchains::BurnchainBlock; -use crate::burnchains::Error as burnchain_error; -use crate::burnchains::*; - -use crate::core::{StacksEpoch, StacksEpochId}; use stacks_common::types::chainstate::BurnchainHeaderHash; +use crate::burnchains::{BurnchainBlock, Error as burnchain_error, *}; +use crate::core::{StacksEpoch, StacksEpochId}; + // IPC messages between threads pub trait BurnHeaderIPC { type H: Send + Sync + Clone; diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs index 427f30f18..431629526 100644 --- a/stackslib/src/burnchains/mod.rs +++ b/stackslib/src/burnchains/mod.rs @@ -17,48 +17,38 @@ use std::collections::HashMap; use std::convert::TryFrom; use std::default::Default; -use std::error; -use std::fmt; -use std::io; use std::marker::PhantomData; +use std::{error, fmt, io}; use rusqlite::Error as sqlite_error; - -use crate::chainstate::burn::distribution::BurnSamplePoint; -use crate::chainstate::burn::operations::leader_block_commit::OUTPUTS_PER_COMMIT; -use crate::chainstate::burn::operations::BlockstackOperationType; -use crate::chainstate::burn::operations::Error as op_error; -use crate::chainstate::burn::operations::LeaderKeyRegisterOp; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::boot::POX_3_NAME; -use crate::chainstate::stacks::StacksPublicKey; -use crate::core::*; -use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY; -use crate::util_lib::db::Error as db_error; use stacks_common::address::AddressHashMode; -use stacks_common::util::hash::Hash160; +use stacks_common::types::chainstate::{ + BurnchainHeaderHash, ConsensusHash, PoxId, StacksAddress, TrieHash, +}; +pub use stacks_common::types::{Address, PrivateKey, PublicKey}; +use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum}; use stacks_common::util::secp256k1::MessageSignature; -use crate::chainstate::stacks::boot::{POX_1_NAME, POX_2_NAME}; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::PoxId; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; - -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::util::hash::Sha512Trunc256Sum; - use self::bitcoin::indexer::{ BITCOIN_MAINNET as BITCOIN_NETWORK_ID_MAINNET, BITCOIN_MAINNET_NAME, BITCOIN_REGTEST as BITCOIN_NETWORK_ID_REGTEST, BITCOIN_REGTEST_NAME, BITCOIN_TESTNET as BITCOIN_NETWORK_ID_TESTNET, BITCOIN_TESTNET_NAME, }; -use self::bitcoin::Error as btc_error; use self::bitcoin::{ BitcoinBlock, BitcoinInputType, BitcoinTransaction, BitcoinTxInput, BitcoinTxOutput, + Error as btc_error, }; - -pub use stacks_common::types::{Address, PrivateKey, PublicKey}; +use crate::chainstate::burn::distribution::BurnSamplePoint; +use crate::chainstate::burn::operations::leader_block_commit::OUTPUTS_PER_COMMIT; +use crate::chainstate::burn::operations::{ + BlockstackOperationType, Error as op_error, LeaderKeyRegisterOp, +}; +use crate::chainstate::stacks::address::PoxAddress; +use crate::chainstate::stacks::boot::{POX_1_NAME, POX_2_NAME, POX_3_NAME}; +use crate::chainstate::stacks::StacksPublicKey; +use crate::core::*; +use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY; +use crate::util_lib::db::Error as db_error; /// This module contains drivers and types for all burn chains we support. pub mod affirmation; @@ -696,8 +686,7 @@ impl BurnchainView { ret.insert(i, self.burn_block_hash.clone()); } else { let data = { - use sha2::Digest; - use sha2::Sha256; + use sha2::{Digest, Sha256}; let mut hasher = Sha256::new(); hasher.update(&i.to_le_bytes()); hasher.finalize() diff --git a/stackslib/src/burnchains/tests/affirmation.rs b/stackslib/src/burnchains/tests/affirmation.rs index b5cbc61ae..27de7113a 100644 --- a/stackslib/src/burnchains/tests/affirmation.rs +++ b/stackslib/src/burnchains/tests/affirmation.rs @@ -15,52 +15,41 @@ // along with this program. If not, see . use std::cmp; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::sync::{ - atomic::{AtomicBool, AtomicU64, Ordering}, - mpsc::sync_channel, - Arc, RwLock, -}; +use std::collections::{HashSet, VecDeque}; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::mpsc::sync_channel; +use std::sync::{Arc, RwLock}; +use clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::Value; use rusqlite::Connection; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, StacksBlockId, VRFSeed, +}; +use stacks_common::util::hash::{hex_bytes, Hash160}; +use stacks_common::util::vrf::*; +use stacks_common::{address, types, util}; use crate::burnchains::affirmation::*; use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddress}; use crate::burnchains::bitcoin::indexer::BitcoinIndexer; use crate::burnchains::bitcoin::BitcoinNetworkType; +use crate::burnchains::db::*; use crate::burnchains::tests::db::*; -use crate::burnchains::{db::*, *}; -use crate::burnchains::{BurnchainBlock, BurnchainBlockHeader, Txid}; -use crate::chainstate; +use crate::burnchains::{BurnchainBlock, BurnchainBlockHeader, Txid, *}; use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::burn::operations::leader_block_commit::*; use crate::chainstate::burn::operations::*; use crate::chainstate::burn::*; +use crate::chainstate::coordinator::tests::*; use crate::chainstate::coordinator::{Error as CoordError, *}; +use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::*; use crate::clarity_vm::clarity::ClarityConnection; -use crate::core; use crate::core::*; use crate::monitoring::increment_stx_blocks_processed_counter; -use clarity::vm::{ - costs::{ExecutionCost, LimitedCostTracker}, - types::PrincipalData, - types::QualifiedContractIdentifier, - Value, -}; -use stacks_common::address; -use stacks_common::util::hash::{hex_bytes, Hash160}; -use stacks_common::util::vrf::*; - -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, VRFSeed, -}; -use stacks_common::{types, util}; - -use crate::chainstate::coordinator::tests::*; -use crate::chainstate::stacks::address::StacksAddressExtensions; +use crate::{chainstate, core}; #[test] fn affirmation_map_encode_decode() { diff --git a/stackslib/src/burnchains/tests/burnchain.rs b/stackslib/src/burnchains/tests/burnchain.rs index 8c6b1fe26..acead0710 100644 --- a/stackslib/src/burnchains/tests/burnchain.rs +++ b/stackslib/src/burnchains/tests/burnchain.rs @@ -14,47 +14,38 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::burn::ConsensusHashExtensions; -use crate::chainstate::stacks::address::StacksAddressExtensions; -use crate::chainstate::stacks::index::TrieHashExtension; use ed25519_dalek::Keypair as VRFKeypair; use rand::rngs::ThreadRng; use rand::thread_rng; use serde::Serialize; use sha2::Sha512; +use stacks_common::address::AddressHashMode; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, TrieHash, VRFSeed, +}; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; +use stacks_common::util::secp256k1::Secp256k1PrivateKey; +use stacks_common::util::uint::{BitArray, Uint256, Uint512}; +use stacks_common::util::vrf::{VRFPrivateKey, VRFPublicKey}; +use stacks_common::util::{get_epoch_time_secs, log}; use crate::burnchains::bitcoin::address::*; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; use crate::burnchains::bitcoin::*; -use crate::burnchains::Txid; -use crate::burnchains::*; +use crate::burnchains::{Txid, *}; use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; use crate::chainstate::burn::distribution::BurnSamplePoint; +use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; use crate::chainstate::burn::operations::{ - leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS, BlockstackOperationType, LeaderBlockCommitOp, - LeaderKeyRegisterOp, UserBurnSupportOp, + BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, }; -use crate::chainstate::burn::{BlockSnapshot, ConsensusHash, OpsHash, SortitionHash}; +use crate::chainstate::burn::{ + BlockSnapshot, ConsensusHash, ConsensusHashExtensions, OpsHash, SortitionHash, +}; +use crate::chainstate::stacks::address::StacksAddressExtensions; +use crate::chainstate::stacks::index::TrieHashExtension; use crate::chainstate::stacks::StacksPublicKey; use crate::util_lib::db::Error as db_error; -use stacks_common::address::AddressHashMode; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::hex_bytes; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Hash160; -use stacks_common::util::log; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::uint::BitArray; -use stacks_common::util::uint::Uint256; -use stacks_common::util::uint::Uint512; -use stacks_common::util::vrf::VRFPrivateKey; -use stacks_common::util::vrf::VRFPublicKey; - -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, VRFSeed, -}; #[test] fn test_process_block_ops() { diff --git a/stackslib/src/burnchains/tests/db.rs b/stackslib/src/burnchains/tests/db.rs index b6829929d..77e2420ea 100644 --- a/stackslib/src/burnchains/tests/db.rs +++ b/stackslib/src/burnchains/tests/db.rs @@ -14,25 +14,9 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::stacks::address::StacksAddressExtensions; use std::cmp; use std::convert::TryInto; -use crate::burnchains::affirmation::AffirmationMap; -use crate::burnchains::bitcoin::address::*; -use crate::burnchains::bitcoin::blocks::*; -use crate::burnchains::bitcoin::*; -use crate::burnchains::PoxConstants; -use crate::burnchains::BLOCKSTACK_MAGIC_MAINNET; -use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; -use crate::chainstate::burn::*; -use crate::chainstate::coordinator::tests::next_txid; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::chainstate::stacks::*; -use crate::core::StacksEpochId; -use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH; -use crate::util_lib::db::Error as DBError; use stacks_common::address::AddressHashMode; use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction as BtcTx; use stacks_common::deps_common::bitcoin::network::serialize::deserialize; @@ -40,6 +24,19 @@ use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::hash::*; use super::*; +use crate::burnchains::affirmation::AffirmationMap; +use crate::burnchains::bitcoin::address::*; +use crate::burnchains::bitcoin::blocks::*; +use crate::burnchains::bitcoin::*; +use crate::burnchains::{PoxConstants, BLOCKSTACK_MAGIC_MAINNET}; +use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; +use crate::chainstate::burn::*; +use crate::chainstate::coordinator::tests::next_txid; +use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; +use crate::chainstate::stacks::index::ClarityMarfTrieId; +use crate::chainstate::stacks::*; +use crate::core::{StacksEpochId, BITCOIN_REGTEST_FIRST_BLOCK_HASH}; +use crate::util_lib::db::Error as DBError; impl BurnchainHeaderReader for Vec { fn read_burnchain_headers( diff --git a/stackslib/src/burnchains/tests/mod.rs b/stackslib/src/burnchains/tests/mod.rs index a2e15aab3..b635b9710 100644 --- a/stackslib/src/burnchains/tests/mod.rs +++ b/stackslib/src/burnchains/tests/mod.rs @@ -20,31 +20,27 @@ pub mod db; use std::collections::HashMap; +use stacks_common::address::*; +use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, VRFSeed}; +use stacks_common::util::get_epoch_time_secs; +use stacks_common::util::hash::*; +use stacks_common::util::secp256k1::*; +use stacks_common::util::vrf::*; + +use super::*; use crate::burnchains::bitcoin::indexer::BitcoinIndexer; use crate::burnchains::db::*; -use crate::burnchains::Burnchain; -use crate::burnchains::*; +use crate::burnchains::{Burnchain, *}; use crate::chainstate::burn::db::sortdb::*; -use crate::chainstate::burn::operations::BlockstackOperationType; -use crate::chainstate::burn::operations::*; +use crate::chainstate::burn::operations::{BlockstackOperationType, *}; use crate::chainstate::burn::*; use crate::chainstate::coordinator::comm::*; use crate::chainstate::coordinator::*; use crate::chainstate::stacks::*; use crate::core::STACKS_EPOCH_2_1_MARKER; use crate::cost_estimates::{CostEstimator, FeeEstimator}; -use crate::util_lib::db::*; -use stacks_common::address::*; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::*; -use stacks_common::util::secp256k1::*; -use stacks_common::util::vrf::*; - -use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, VRFSeed}; - use crate::stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; - -use super::*; +use crate::util_lib::db::*; // all SPV headers will have this timestamp, so that multiple burnchain nodes will always have the // same SPV header timestamps regardless of when they are instantiated. diff --git a/stackslib/src/chainstate/burn/db/mod.rs b/stackslib/src/chainstate/burn/db/mod.rs index c36807243..78bacdedf 100644 --- a/stackslib/src/chainstate/burn/db/mod.rs +++ b/stackslib/src/chainstate/burn/db/mod.rs @@ -14,13 +14,16 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; -use std::fmt; +use std::{error, fmt}; -use rusqlite::Connection; -use rusqlite::Error as sqlite_error; -use rusqlite::Row; +use rusqlite::{Connection, Error as sqlite_error, Row}; use serde_json::Error as serde_error; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, TrieHash, VRFSeed, +}; +use stacks_common::util::hash::{hex_bytes, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::secp256k1::MessageSignature; +use stacks_common::util::vrf::*; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::{Address, Txid}; @@ -28,15 +31,7 @@ use crate::chainstate::burn::{ConsensusHash, OpsHash, SortitionHash}; use crate::chainstate::stacks::address::PoxAddress; use crate::chainstate::stacks::StacksPublicKey; use crate::util_lib::db; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::FromColumn; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::util::hash::{hex_bytes, Hash160, Sha512Trunc256Sum}; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::vrf::*; - -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, VRFSeed}; +use crate::util_lib::db::{Error as db_error, FromColumn}; pub mod processing; pub mod sortdb; diff --git a/stackslib/src/chainstate/burn/db/processing.rs b/stackslib/src/chainstate/burn/db/processing.rs index 544396ab0..bf1e83efd 100644 --- a/stackslib/src/chainstate/burn/db/processing.rs +++ b/stackslib/src/chainstate/burn/db/processing.rs @@ -17,27 +17,23 @@ along with Blockstack. If not, see . */ +use stacks_common::address::AddressHashMode; +use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId, SortitionId, TrieHash}; + use crate::burnchains::{ Burnchain, BurnchainBlockHeader, BurnchainStateTransition, Error as BurnchainError, }; -use crate::chainstate::burn::db::sortdb::SortitionDB; -use crate::chainstate::burn::db::sortdb::{InitialMiningBonus, SortitionHandleTx}; -use crate::chainstate::burn::operations::{ - leader_block_commit::{MissedBlockCommit, RewardSetInfo}, - BlockstackOperationType, Error as OpError, -}; +use crate::chainstate::burn::db::sortdb::{InitialMiningBonus, SortitionDB, SortitionHandleTx}; +use crate::chainstate::burn::operations::leader_block_commit::{MissedBlockCommit, RewardSetInfo}; +use crate::chainstate::burn::operations::{BlockstackOperationType, Error as OpError}; use crate::chainstate::burn::BlockSnapshot; use crate::chainstate::coordinator::RewardCycleInfo; use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::index::{ - marf::MARF, storage::TrieFileStorage, Error as MARFError, MARFValue, MarfTrieId, -}; +use crate::chainstate::stacks::index::marf::MARF; +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::index::{Error as MARFError, MARFValue, MarfTrieId}; use crate::core::INITIAL_MINING_BONUS_WINDOW; use crate::util_lib::db::Error as DBError; -use stacks_common::address::AddressHashMode; - -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId, SortitionId}; impl<'a> SortitionHandleTx<'a> { /// Run a blockstack operation's "check()" method and return the result. @@ -367,22 +363,23 @@ impl<'a> SortitionHandleTx<'a> { #[cfg(test)] mod tests { - use crate::burnchains::bitcoin::{address::BitcoinAddress, BitcoinNetworkType}; + use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, VRFSeed}; + use stacks_common::util::hash::hex_bytes; + use stacks_common::util::vrf::VRFPublicKey; + + use super::*; + use crate::burnchains::bitcoin::address::BitcoinAddress; + use crate::burnchains::bitcoin::BitcoinNetworkType; use crate::burnchains::*; - use crate::chainstate::burn::db::sortdb::{tests::test_append_snapshot, SortitionDB}; - use crate::chainstate::burn::operations::{ - leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS, LeaderBlockCommitOp, LeaderKeyRegisterOp, - }; + use crate::chainstate::burn::db::sortdb::tests::test_append_snapshot; + use crate::chainstate::burn::db::sortdb::SortitionDB; + use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; + use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp}; use crate::chainstate::burn::*; use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::index::TrieHashExtension; use crate::chainstate::stacks::StacksPublicKey; use crate::core::MICROSTACKS_PER_STACKS; - use stacks_common::util::{hash::hex_bytes, vrf::VRFPublicKey}; - - use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, VRFSeed}; - - use super::*; #[test] fn test_initial_block_reward() { diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs index 48df0b43a..999d14582 100644 --- a/stackslib/src/chainstate/burn/db/sortdb.rs +++ b/stackslib/src/chainstate/burn/db/sortdb.rs @@ -14,88 +14,76 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp::Ord; -use std::cmp::Ordering; +use std::cmp::{Ord, Ordering}; use std::collections::{HashMap, HashSet}; use std::convert::{From, TryFrom, TryInto}; use std::io::{ErrorKind, Write}; -use std::ops::Deref; -use std::ops::DerefMut; -use std::{cmp, fmt, fs, str::FromStr}; +use std::ops::{Deref, DerefMut}; +use std::str::FromStr; +use std::{cmp, fmt, fs}; +use clarity::vm::ast::ASTRules; use clarity::vm::costs::ExecutionCost; +use clarity::vm::representations::{ClarityName, ContractName}; +use clarity::vm::types::Value; use rand; use rand::RngCore; use rusqlite::types::ToSql; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::TransactionBehavior; -use rusqlite::{Connection, OpenFlags, OptionalExtension, NO_PARAMS}; +use rusqlite::{ + Connection, OpenFlags, OptionalExtension, Row, Transaction, TransactionBehavior, NO_PARAMS, +}; use sha2::{Digest, Sha512_256}; +use stacks_common::address::AddressHashMode; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, StacksBlockId, + TrieHash, VRFSeed, +}; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::secp256k1::MessageSignature; +use stacks_common::util::vrf::*; +use stacks_common::util::{get_epoch_time_secs, log}; use crate::burnchains::affirmation::{AffirmationMap, AffirmationMapEntry}; use crate::burnchains::bitcoin::BitcoinNetworkType; use crate::burnchains::db::{BurnchainDB, BurnchainHeaderReader}; -use crate::burnchains::{Address, PublicKey, Txid}; use crate::burnchains::{ - Burnchain, BurnchainBlockHeader, BurnchainRecipient, BurnchainStateTransition, + Address, Burnchain, BurnchainBlockHeader, BurnchainRecipient, BurnchainStateTransition, BurnchainStateTransitionOps, BurnchainTransaction, BurnchainView, Error as BurnchainError, - PoxConstants, + PoxConstants, PublicKey, Txid, +}; +use crate::chainstate::burn::operations::leader_block_commit::{ + MissedBlockCommit, RewardSetInfo, OUTPUTS_PER_COMMIT, }; -use crate::chainstate::burn::operations::DelegateStxOp; use crate::chainstate::burn::operations::{ - leader_block_commit::{MissedBlockCommit, RewardSetInfo, OUTPUTS_PER_COMMIT}, - BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, - TransferStxOp, UserBurnSupportOp, + BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, + StackStxOp, TransferStxOp, UserBurnSupportOp, +}; +use crate::chainstate::burn::{ + BlockSnapshot, ConsensusHash, ConsensusHashExtensions, Opcodes, OpsHash, SortitionHash, }; -use crate::chainstate::burn::Opcodes; -use crate::chainstate::burn::{BlockSnapshot, ConsensusHash, OpsHash, SortitionHash}; use crate::chainstate::coordinator::{ Error as CoordinatorError, PoxAnchorBlockStatus, RewardCycleInfo, }; -use crate::chainstate::stacks::address::PoxAddress; +use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; use crate::chainstate::stacks::boot::PoxStartCycleInfo; use crate::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo}; -use crate::chainstate::stacks::index::marf::MARFOpenOpts; -use crate::chainstate::stacks::index::marf::MarfConnection; -use crate::chainstate::stacks::index::marf::MARF; +use crate::chainstate::stacks::index::marf::{MARFOpenOpts, MarfConnection, MARF}; use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::index::{Error as MARFError, MarfTrieId}; -use crate::chainstate::stacks::StacksPublicKey; -use crate::chainstate::stacks::*; +use crate::chainstate::stacks::index::{ + ClarityMarfTrieId, Error as MARFError, MARFValue, MarfTrieId, +}; +use crate::chainstate::stacks::{StacksPublicKey, *}; use crate::chainstate::ChainstateDB; -use crate::core::AST_RULES_PRECHECK_SIZE; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; -use crate::core::{StacksEpoch, StacksEpochExtension, StacksEpochId, STACKS_EPOCH_MAX}; +use crate::core::{ + StacksEpoch, StacksEpochExtension, StacksEpochId, AST_RULES_PRECHECK_SIZE, + FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX, +}; use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY; use crate::net::{Error as NetError, Error}; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::tx_busy_handler; -use crate::util_lib::db::DBTx; -use crate::util_lib::db::Error as db_error; use crate::util_lib::db::{ db_mkdirs, opt_u64_to_sql, query_count, query_row, query_row_columns, query_row_panic, - query_rows, sql_pragma, u64_to_sql, DBConn, FromColumn, FromRow, IndexDBConn, IndexDBTx, -}; -use clarity::vm::ast::ASTRules; -use clarity::vm::representations::{ClarityName, ContractName}; -use clarity::vm::types::Value; - -use stacks_common::address::AddressHashMode; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum}; -use stacks_common::util::log; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::vrf::*; - -use crate::chainstate::burn::ConsensusHashExtensions; -use crate::chainstate::stacks::address::StacksAddressExtensions; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, MARFValue}; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksBlockId, VRFSeed, + query_rows, sql_pragma, tx_begin_immediate, tx_busy_handler, u64_to_sql, DBConn, DBTx, + Error as db_error, FromColumn, FromRow, IndexDBConn, IndexDBTx, }; const BLOCK_HEIGHT_MAX: u64 = ((1 as u64) << 63) - 1; @@ -5815,35 +5803,31 @@ impl ChainstateDB for SortitionDB { #[cfg(test)] pub mod tests { - use crate::chainstate::stacks::index::TrieHashExtension; - use crate::core::StacksEpochExtension; use std::sync::mpsc::sync_channel; use std::thread; - use crate::burnchains::bitcoin::address::BitcoinAddress; - use crate::burnchains::bitcoin::keys::BitcoinPublicKey; - use crate::burnchains::bitcoin::BitcoinNetworkType; - use crate::burnchains::*; - use crate::chainstate::burn::operations::{ - leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS, BlockstackOperationType, - LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, - }; - use crate::chainstate::burn::ConsensusHash; - use crate::chainstate::stacks::StacksPublicKey; - use crate::core::*; - use crate::util_lib::db::Error as db_error; use stacks_common::address::AddressHashMode; + use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, VRFSeed}; use stacks_common::util::get_epoch_time_secs; use stacks_common::util::hash::{hex_bytes, Hash160}; use stacks_common::util::vrf::*; - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::types::chainstate::{BlockHeaderHash, VRFSeed}; - - use crate::burnchains::affirmation::AffirmationMap; - use crate::burnchains::tests::affirmation::{make_reward_cycle, make_simple_key_register}; - use super::*; + use crate::burnchains::affirmation::AffirmationMap; + use crate::burnchains::bitcoin::address::BitcoinAddress; + use crate::burnchains::bitcoin::keys::BitcoinPublicKey; + use crate::burnchains::bitcoin::BitcoinNetworkType; + use crate::burnchains::tests::affirmation::{make_reward_cycle, make_simple_key_register}; + use crate::burnchains::*; + use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; + use crate::chainstate::burn::operations::{ + BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, + }; + use crate::chainstate::burn::ConsensusHash; + use crate::chainstate::stacks::index::TrieHashExtension; + use crate::chainstate::stacks::StacksPublicKey; + use crate::core::{StacksEpochExtension, *}; + use crate::util_lib::db::Error as db_error; #[test] fn test_instantiate() { diff --git a/stackslib/src/chainstate/burn/distribution.rs b/stackslib/src/chainstate/burn/distribution.rs index 223b88374..8e76950d3 100644 --- a/stackslib/src/chainstate/burn/distribution.rs +++ b/stackslib/src/chainstate/burn/distribution.rs @@ -18,25 +18,22 @@ use std::cmp; use std::collections::{BTreeMap, HashMap}; use std::convert::TryInto; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; -use crate::burnchains::{BurnchainRecipient, BurnchainSigner, BurnchainTransaction}; +use stacks_common::address::AddressHashMode; +use stacks_common::util::hash::Hash160; +use stacks_common::util::log; +use stacks_common::util::uint::{BitArray, Uint256, Uint512}; +use stacks_common::util::vrf::VRFPublicKey; + +use crate::burnchains::{ + Address, Burnchain, BurnchainRecipient, BurnchainSigner, BurnchainTransaction, PublicKey, Txid, +}; +use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit; use crate::chainstate::burn::operations::{ - leader_block_commit::MissedBlockCommit, BlockstackOperationType, LeaderBlockCommitOp, - LeaderKeyRegisterOp, UserBurnSupportOp, + BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, }; use crate::chainstate::stacks::StacksPublicKey; use crate::core::MINING_COMMITMENT_WINDOW; use crate::monitoring; -use stacks_common::address::AddressHashMode; -use stacks_common::util::hash::Hash160; -use stacks_common::util::log; -use stacks_common::util::uint::BitArray; -use stacks_common::util::uint::Uint256; -use stacks_common::util::uint::Uint512; -use stacks_common::util::vrf::VRFPublicKey; #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct BurnSamplePoint { @@ -405,16 +402,26 @@ impl BurnSamplePoint { #[cfg(test)] mod tests { + use std::marker::PhantomData; + + use stacks_common::address::AddressHashMode; + use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, VRFSeed, + }; + use stacks_common::util::hash::{hex_bytes, Hash160}; + use stacks_common::util::log; + use stacks_common::util::uint::{BitArray, Uint256, Uint512}; + use stacks_common::util::vrf::*; + + use super::BurnSamplePoint; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; use crate::burnchains::bitcoin::BitcoinNetworkType; - use crate::burnchains::Address; - use crate::burnchains::Burnchain; - use crate::burnchains::BurnchainSigner; - use crate::burnchains::PublicKey; - use crate::burnchains::Txid; + use crate::burnchains::{Address, Burnchain, BurnchainSigner, PublicKey, Txid}; + use crate::chainstate::burn::operations::leader_block_commit::{ + MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS, + }; use crate::chainstate::burn::operations::{ - leader_block_commit::{MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS}, BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, }; use crate::chainstate::burn::ConsensusHash; @@ -422,21 +429,6 @@ mod tests { use crate::chainstate::stacks::index::TrieHashExtension; use crate::chainstate::stacks::StacksPublicKey; use crate::core::MINING_COMMITMENT_WINDOW; - use stacks_common::address::AddressHashMode; - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::util::hash::hex_bytes; - use stacks_common::util::hash::Hash160; - use stacks_common::util::log; - use stacks_common::util::uint::BitArray; - use stacks_common::util::uint::Uint256; - use stacks_common::util::uint::Uint512; - use stacks_common::util::vrf::*; - use std::marker::PhantomData; - - use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; - use stacks_common::types::chainstate::{SortitionId, VRFSeed}; - - use super::BurnSamplePoint; struct BurnDistFixture { consumed_leader_keys: Vec, diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs index cad79db79..0ab14b982 100644 --- a/stackslib/src/chainstate/burn/mod.rs +++ b/stackslib/src/chainstate/burn/mod.rs @@ -19,33 +19,24 @@ use std::fmt; use std::io::Write; use rand::seq::index::sample; -use rand::Rng; -use rand::SeedableRng; +use rand::{Rng, SeedableRng}; use rand_chacha::ChaCha20Rng; use ripemd::Ripemd160; -use rusqlite::Connection; -use rusqlite::Transaction; +use rusqlite::{Connection, Transaction}; use sha2::Sha256; - -use crate::burnchains::Address; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; -use crate::chainstate::burn::db::sortdb::SortitionHandleTx; -use crate::core::SYSTEM_FORK_SET_VERSION; -use crate::util_lib::db::Error as db_error; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::util::hash::Hash32; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::hash::{to_hex, Hash160}; +pub use stacks_common::types::chainstate::ConsensusHash; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, TrieHash, VRFSeed, +}; +use stacks_common::util::hash::{to_hex, Hash160, Hash32, Sha512Trunc256Sum}; use stacks_common::util::log; use stacks_common::util::uint::Uint256; use stacks_common::util::vrf::VRFProof; -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, VRFSeed, -}; - -pub use stacks_common::types::chainstate::ConsensusHash; +use crate::burnchains::{Address, PublicKey, Txid}; +use crate::chainstate::burn::db::sortdb::SortitionHandleTx; +use crate::core::SYSTEM_FORK_SET_VERSION; +use crate::util_lib::db::Error as db_error; /// This module contains the code for processing the burn chain state database pub mod db; @@ -387,19 +378,17 @@ impl ConsensusHashExtensions for ConsensusHash { #[cfg(test)] mod tests { + use rusqlite::Connection; + use stacks_common::types::chainstate::BurnchainHeaderHash; + use stacks_common::util::hash::{hex_bytes, Hash160}; + use stacks_common::util::{get_epoch_time_secs, log}; + + use super::*; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::stacks::index::TrieHashExtension; use crate::util_lib::db::Error as db_error; - use rusqlite::Connection; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::{hex_bytes, Hash160}; - use stacks_common::util::log; - - use stacks_common::types::chainstate::BurnchainHeaderHash; - - use super::*; #[test] fn get_prev_consensus_hashes() { diff --git a/stackslib/src/chainstate/burn/operations/delegate_stx.rs b/stackslib/src/chainstate/burn/operations/delegate_stx.rs index 7915c5c11..9f6a47a8f 100644 --- a/stackslib/src/chainstate/burn/operations/delegate_stx.rs +++ b/stackslib/src/chainstate/burn/operations/delegate_stx.rs @@ -1,15 +1,15 @@ -use crate::burnchains::BurnchainTransaction; -use crate::burnchains::{BurnchainBlockHeader, Txid}; -use crate::chainstate::burn::operations::Error as op_error; +use std::io::{Read, Write}; + +use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress}; + +use crate::burnchains::{BurnchainBlockHeader, BurnchainTransaction, Txid}; use crate::chainstate::burn::operations::{ parse_u128_from_be, parse_u32_from_be, parse_u64_from_be, BlockstackOperationType, - DelegateStxOp, PreStxOp, + DelegateStxOp, Error as op_error, PreStxOp, }; use crate::chainstate::burn::Opcodes; use crate::chainstate::stacks::address::PoxAddress; -use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress}; -use std::io::{Read, Write}; struct ParsedData { delegated_ustx: u128, @@ -260,24 +260,21 @@ impl StacksMessageCodec for DelegateStxOp { } mod tests { + use stacks_common::address::AddressHashMode; + use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress}; + use stacks_common::util::hash::*; + use crate::burnchains::bitcoin::address::{ BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType, }; - use crate::burnchains::bitcoin::BitcoinTxInputStructured; use crate::burnchains::bitcoin::{ - BitcoinInputType, BitcoinNetworkType, BitcoinTxInput, BitcoinTxOutput, + BitcoinInputType, BitcoinNetworkType, BitcoinTransaction, BitcoinTxInput, + BitcoinTxInputStructured, BitcoinTxOutput, }; - use crate::burnchains::BurnchainTransaction; - use crate::burnchains::{bitcoin::BitcoinTransaction, Txid}; - use crate::chainstate::burn::operations::DelegateStxOp; - use crate::chainstate::burn::operations::Error as op_error; + use crate::burnchains::{BurnchainTransaction, Txid}; + use crate::chainstate::burn::operations::{DelegateStxOp, Error as op_error}; use crate::chainstate::burn::Opcodes; - use crate::chainstate::stacks::address::PoxAddress; - use crate::chainstate::stacks::address::StacksAddressExtensions; - use stacks_common::address::AddressHashMode; - use stacks_common::types::chainstate::BurnchainHeaderHash; - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::util::hash::*; + use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; // Parse a DelegateStx op in which the height is set to None. #[test] diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs index b7f32fd00..df84034b5 100644 --- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs +++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs @@ -16,43 +16,35 @@ use std::io::{Read, Write}; -use crate::burnchains::bitcoin::BitcoinNetworkType; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::PoxConstants; -use crate::burnchains::Txid; -use crate::burnchains::{BurnchainRecipient, BurnchainSigner}; -use crate::burnchains::{BurnchainTransaction, PublicKey}; -use crate::chainstate::burn::db::sortdb::SortitionHandle; -use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; -use crate::chainstate::burn::operations::Error as op_error; -use crate::chainstate::burn::operations::{ - parse_u16_from_be, parse_u32_from_be, BlockstackOperationType, LeaderBlockCommitOp, - LeaderKeyRegisterOp, UserBurnSupportOp, -}; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::Opcodes; -use crate::chainstate::burn::SortitionId; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; -use crate::core::STACKS_EPOCH_2_2_MARKER; -use crate::core::STACKS_EPOCH_2_3_MARKER; -use crate::core::STACKS_EPOCH_2_4_MARKER; -use crate::core::{StacksEpoch, StacksEpochId}; -use crate::core::{STACKS_EPOCH_2_05_MARKER, STACKS_EPOCH_2_1_MARKER}; -use crate::net::Error as net_error; use stacks_common::address::AddressHashMode; use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::TrieHash; use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, StacksAddress, VRFSeed, + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, TrieHash, VRFSeed, }; use stacks_common::util::hash::to_hex; use stacks_common::util::log; use stacks_common::util::vrf::{VRFPrivateKey, VRFPublicKey, VRF}; +use crate::burnchains::bitcoin::BitcoinNetworkType; +use crate::burnchains::{ + Address, Burnchain, BurnchainBlockHeader, BurnchainRecipient, BurnchainSigner, + BurnchainTransaction, PoxConstants, PublicKey, Txid, +}; +use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle, SortitionHandleTx}; +use crate::chainstate::burn::operations::{ + parse_u16_from_be, parse_u32_from_be, BlockstackOperationType, Error as op_error, + LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, +}; +use crate::chainstate::burn::{ConsensusHash, Opcodes, SortitionId}; +use crate::chainstate::stacks::address::PoxAddress; +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; +use crate::core::{ + StacksEpoch, StacksEpochId, STACKS_EPOCH_2_05_MARKER, STACKS_EPOCH_2_1_MARKER, + STACKS_EPOCH_2_2_MARKER, STACKS_EPOCH_2_3_MARKER, STACKS_EPOCH_2_4_MARKER, +}; +use crate::net::Error as net_error; + // return type from parse_data below struct ParsedData { block_header_hash: BlockHeaderHash, @@ -1029,6 +1021,17 @@ impl LeaderBlockCommitOp { #[cfg(test)] mod tests { + use clarity::vm::costs::ExecutionCost; + use rand::{thread_rng, RngCore}; + use stacks_common::address::AddressHashMode; + use stacks_common::deps_common::bitcoin::blockdata::transaction::{Transaction, TxOut}; + use stacks_common::deps_common::bitcoin::network::serialize::{deserialize, serialize_hex}; + use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, StacksAddress, VRFSeed}; + use stacks_common::util::get_epoch_time_secs; + use stacks_common::util::hash::*; + use stacks_common::util::vrf::VRFPublicKey; + + use super::*; use crate::burnchains::bitcoin::address::*; use crate::burnchains::bitcoin::blocks::BitcoinBlockParser; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; @@ -1038,33 +1041,14 @@ mod tests { use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::db::*; use crate::chainstate::burn::operations::*; - use crate::chainstate::burn::ConsensusHash; - use crate::chainstate::burn::*; + use crate::chainstate::burn::{ConsensusHash, *}; use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::index::TrieHashExtension; use crate::chainstate::stacks::StacksPublicKey; use crate::core::{ - StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, - PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1, STACKS_EPOCH_MAX, + StacksEpoch, StacksEpochExtension, StacksEpochId, PEER_VERSION_EPOCH_1_0, + PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1, STACKS_EPOCH_MAX, }; - use stacks_common::address::AddressHashMode; - use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; - use stacks_common::deps_common::bitcoin::blockdata::transaction::TxOut; - use stacks_common::deps_common::bitcoin::network::serialize::{deserialize, serialize_hex}; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::*; - use stacks_common::util::vrf::VRFPublicKey; - - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, VRFSeed}; - - use super::*; - - use clarity::vm::costs::ExecutionCost; - use rand::thread_rng; - use rand::RngCore; - - use crate::core::StacksEpochExtension; struct OpFixture { txstr: String, diff --git a/stackslib/src/chainstate/burn/operations/leader_key_register.rs b/stackslib/src/chainstate/burn/operations/leader_key_register.rs index 7f86391f2..1a0add9a0 100644 --- a/stackslib/src/chainstate/burn/operations/leader_key_register.rs +++ b/stackslib/src/chainstate/burn/operations/leader_key_register.rs @@ -16,34 +16,27 @@ use std::io::{Read, Write}; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::BurnchainTransaction; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; -use crate::chainstate::burn::db::sortdb::SortitionHandleTx; -use crate::chainstate::burn::operations::Error as op_error; -use crate::chainstate::burn::operations::{ - BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, -}; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::Opcodes; -use crate::chainstate::stacks::StacksPrivateKey; -use crate::chainstate::stacks::StacksPublicKey; -use crate::net::Error as net_error; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; use stacks_common::address::AddressHashMode; use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, TrieHash, +}; use stacks_common::util::hash::DoubleSha256; use stacks_common::util::log; use stacks_common::util::vrf::{VRFPrivateKey, VRFPublicKey, VRF}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; +use crate::burnchains::{ + Address, Burnchain, BurnchainBlockHeader, BurnchainTransaction, PublicKey, Txid, +}; +use crate::chainstate::burn::db::sortdb::SortitionHandleTx; +use crate::chainstate::burn::operations::{ + BlockstackOperationType, Error as op_error, LeaderBlockCommitOp, LeaderKeyRegisterOp, + UserBurnSupportOp, +}; +use crate::chainstate::burn::{ConsensusHash, Opcodes}; +use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; +use crate::net::Error as net_error; +use crate::util_lib::db::{DBConn, DBTx}; pub struct ParsedData { pub consensus_hash: ConsensusHash, @@ -233,6 +226,13 @@ impl LeaderKeyRegisterOp { #[cfg(test)] pub mod tests { + use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; + use stacks_common::deps_common::bitcoin::network::serialize::deserialize; + use stacks_common::types::chainstate::SortitionId; + use stacks_common::util::hash::{hex_bytes, to_hex}; + use stacks_common::util::{get_epoch_time_secs, log}; + + use super::*; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::blocks::BitcoinBlockParser; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; @@ -246,15 +246,6 @@ pub mod tests { use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::index::TrieHashExtension; use crate::core::StacksEpochId; - use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; - use stacks_common::deps_common::bitcoin::network::serialize::deserialize; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::{hex_bytes, to_hex}; - use stacks_common::util::log; - - use stacks_common::types::chainstate::SortitionId; - - use super::*; pub struct OpFixture { pub txstr: String, diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs index 27fa0a43f..0e930b6b0 100644 --- a/stackslib/src/chainstate/burn/operations/mod.rs +++ b/stackslib/src/chainstate/burn/operations/mod.rs @@ -14,40 +14,27 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::convert::From; -use std::convert::TryInto; -use std::error; -use std::fmt; -use std::fs; -use std::io; +use std::convert::{From, TryInto}; +use std::{error, fmt, fs, io}; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::Error as BurnchainError; -use crate::burnchains::Txid; -use crate::burnchains::{Address, PublicKey}; -use crate::burnchains::{BurnchainRecipient, BurnchainSigner, BurnchainTransaction}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, TrieHash, VRFSeed, +}; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::secp256k1::MessageSignature; +use stacks_common::util::vrf::VRFPublicKey; + +use crate::burnchains::{ + Address, Burnchain, BurnchainBlockHeader, BurnchainRecipient, BurnchainSigner, + BurnchainTransaction, Error as BurnchainError, PublicKey, Txid, +}; use crate::chainstate::burn::db::sortdb::SortitionHandleTx; use crate::chainstate::burn::operations::leader_block_commit::{ MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS, }; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::VRFSeed; - -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::Opcodes; +use crate::chainstate::burn::{ConsensusHash, Opcodes}; use crate::chainstate::stacks::address::PoxAddress; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; -use crate::util_lib::db::Error as db_error; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::vrf::VRFPublicKey; - -use stacks_common::types::chainstate::BurnchainHeaderHash; +use crate::util_lib::db::{DBConn, DBTx, Error as db_error}; pub mod delegate_stx; pub mod leader_block_commit; @@ -541,11 +528,6 @@ pub fn parse_u16_from_be(bytes: &[u8]) -> Option { } mod test { - use crate::burnchains::Txid; - use crate::chainstate::burn::operations::{ - BlockstackOperationType, DelegateStxOp, PreStxOp, StackStxOp, TransferStxOp, - }; - use crate::chainstate::stacks::address::PoxAddress; use stacks_common::address::C32_ADDRESS_VERSION_MAINNET_SINGLESIG; use stacks_common::types::chainstate::{ BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, VRFSeed, @@ -553,6 +535,12 @@ mod test { use stacks_common::types::Address; use stacks_common::util::hash::Hash160; + use crate::burnchains::Txid; + use crate::chainstate::burn::operations::{ + BlockstackOperationType, DelegateStxOp, PreStxOp, StackStxOp, TransferStxOp, + }; + use crate::chainstate::stacks::address::PoxAddress; + #[test] fn test_serialization_transfer_stx_op() { let sender_addr = "ST2QKZ4FKHAH1NQKYKYAYZPY440FEPK7GZ1R5HBP2"; diff --git a/stackslib/src/chainstate/burn/operations/stack_stx.rs b/stackslib/src/chainstate/burn/operations/stack_stx.rs index 33afe58c5..786c3ad15 100644 --- a/stackslib/src/chainstate/burn/operations/stack_stx.rs +++ b/stackslib/src/chainstate/burn/operations/stack_stx.rs @@ -16,34 +16,28 @@ use std::io::{Read, Write}; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::PoxConstants; -use crate::burnchains::Txid; -use crate::burnchains::{BurnchainTransaction, PublicKey}; -use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; -use crate::chainstate::burn::operations::Error as op_error; -use crate::chainstate::burn::operations::{ - parse_u128_from_be, BlockstackOperationType, PreStxOp, StackStxOp, -}; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::Opcodes; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; -use crate::core::StacksEpochId; -use crate::core::POX_MAX_NUM_CYCLES; -use crate::net::Error as net_error; use stacks_common::address::AddressHashMode; use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::TrieHash; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, TrieHash, VRFSeed, +}; use stacks_common::util::hash::to_hex; use stacks_common::util::log; use stacks_common::util::vrf::{VRFPrivateKey, VRFPublicKey, VRF}; -use stacks_common::types::chainstate::VRFSeed; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksAddress}; +use crate::burnchains::{ + Address, Burnchain, BurnchainBlockHeader, BurnchainTransaction, PoxConstants, PublicKey, Txid, +}; +use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; +use crate::chainstate::burn::operations::{ + parse_u128_from_be, BlockstackOperationType, Error as op_error, PreStxOp, StackStxOp, +}; +use crate::chainstate::burn::{ConsensusHash, Opcodes}; +use crate::chainstate::stacks::address::PoxAddress; +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; +use crate::core::{StacksEpochId, POX_MAX_NUM_CYCLES}; +use crate::net::Error as net_error; // return type from parse_data below struct ParsedData { @@ -366,6 +360,15 @@ impl StackStxOp { #[cfg(test)] mod tests { + use stacks_common::address::AddressHashMode; + use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; + use stacks_common::deps_common::bitcoin::network::serialize::{deserialize, serialize_hex}; + use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, VRFSeed}; + use stacks_common::util::get_epoch_time_secs; + use stacks_common::util::hash::*; + use stacks_common::util::vrf::VRFPublicKey; + + use super::*; use crate::burnchains::bitcoin::address::*; use crate::burnchains::bitcoin::blocks::BitcoinBlockParser; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; @@ -374,23 +377,10 @@ mod tests { use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::db::*; use crate::chainstate::burn::operations::*; - use crate::chainstate::burn::ConsensusHash; - use crate::chainstate::burn::*; - use crate::chainstate::stacks::address::PoxAddress; - use crate::chainstate::stacks::address::StacksAddressExtensions; + use crate::chainstate::burn::{ConsensusHash, *}; + use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; use crate::chainstate::stacks::StacksPublicKey; use crate::core::StacksEpochId; - use stacks_common::address::AddressHashMode; - use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; - use stacks_common::deps_common::bitcoin::network::serialize::{deserialize, serialize_hex}; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::*; - use stacks_common::util::vrf::VRFPublicKey; - - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::types::chainstate::{BlockHeaderHash, VRFSeed}; - - use super::*; struct OpFixture { txstr: String, diff --git a/stackslib/src/chainstate/burn/operations/transfer_stx.rs b/stackslib/src/chainstate/burn/operations/transfer_stx.rs index 43eda1c1f..9d1d562d9 100644 --- a/stackslib/src/chainstate/burn/operations/transfer_stx.rs +++ b/stackslib/src/chainstate/burn/operations/transfer_stx.rs @@ -16,32 +16,28 @@ use std::io::{Read, Write}; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::BurnchainRecipient; -use crate::burnchains::Txid; -use crate::burnchains::{BurnchainTransaction, PublicKey}; -use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; -use crate::chainstate::burn::operations::Error as op_error; -use crate::chainstate::burn::operations::{ - parse_u128_from_be, BlockstackOperationType, TransferStxOp, -}; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::Opcodes; -use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; -use crate::core::POX_MAX_NUM_CYCLES; -use crate::net::Error as net_error; use stacks_common::address::AddressHashMode; use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::TrieHash; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, TrieHash, VRFSeed, +}; use stacks_common::util::hash::to_hex; use stacks_common::util::log; use stacks_common::util::vrf::{VRFPrivateKey, VRFPublicKey, VRF}; -use stacks_common::types::chainstate::VRFSeed; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksAddress}; +use crate::burnchains::{ + Address, Burnchain, BurnchainBlockHeader, BurnchainRecipient, BurnchainTransaction, PublicKey, + Txid, +}; +use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; +use crate::chainstate::burn::operations::{ + parse_u128_from_be, BlockstackOperationType, Error as op_error, TransferStxOp, +}; +use crate::chainstate::burn::{ConsensusHash, Opcodes}; +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; +use crate::core::POX_MAX_NUM_CYCLES; +use crate::net::Error as net_error; // return type from parse_data below struct ParsedData { @@ -245,6 +241,15 @@ impl TransferStxOp { #[cfg(test)] mod tests { + use stacks_common::address::AddressHashMode; + use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; + use stacks_common::deps_common::bitcoin::network::serialize::{deserialize, serialize_hex}; + use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, VRFSeed}; + use stacks_common::util::get_epoch_time_secs; + use stacks_common::util::hash::*; + use stacks_common::util::vrf::VRFPublicKey; + + use super::*; use crate::burnchains::bitcoin::address::*; use crate::burnchains::bitcoin::blocks::BitcoinBlockParser; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; @@ -253,21 +258,9 @@ mod tests { use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::db::*; use crate::chainstate::burn::operations::*; - use crate::chainstate::burn::ConsensusHash; - use crate::chainstate::burn::*; + use crate::chainstate::burn::{ConsensusHash, *}; use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::StacksPublicKey; - use stacks_common::address::AddressHashMode; - use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; - use stacks_common::deps_common::bitcoin::network::serialize::{deserialize, serialize_hex}; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::*; - use stacks_common::util::vrf::VRFPublicKey; - - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::types::chainstate::{BlockHeaderHash, VRFSeed}; - - use super::*; #[test] fn test_parse_transfer_stx() { diff --git a/stackslib/src/chainstate/burn/operations/user_burn_support.rs b/stackslib/src/chainstate/burn/operations/user_burn_support.rs index d522a4657..cd17b39a2 100644 --- a/stackslib/src/chainstate/burn/operations/user_burn_support.rs +++ b/stackslib/src/chainstate/burn/operations/user_burn_support.rs @@ -17,31 +17,23 @@ use std::io::{Read, Write}; use std::marker::PhantomData; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::BurnchainTransaction; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; -use crate::chainstate::burn::db::sortdb::SortitionHandleTx; -use crate::chainstate::burn::operations::Error as op_error; -use crate::chainstate::burn::operations::{ - parse_u16_from_be, parse_u32_from_be, BlockstackOperationType, LeaderBlockCommitOp, - LeaderKeyRegisterOp, UserBurnSupportOp, -}; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::Opcodes; -use crate::net::Error as net_error; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::TrieHash; +use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, TrieHash}; use stacks_common::util::hash::Hash160; use stacks_common::util::log; use stacks_common::util::vrf::{VRFPublicKey, VRF}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; +use crate::burnchains::{ + Address, Burnchain, BurnchainBlockHeader, BurnchainTransaction, PublicKey, Txid, +}; +use crate::chainstate::burn::db::sortdb::SortitionHandleTx; +use crate::chainstate::burn::operations::{ + parse_u16_from_be, parse_u32_from_be, BlockstackOperationType, Error as op_error, + LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, +}; +use crate::chainstate::burn::{ConsensusHash, Opcodes}; +use crate::net::Error as net_error; +use crate::util_lib::db::{DBConn, DBTx}; // return type for parse_data (below) struct ParsedData { @@ -301,6 +293,13 @@ impl UserBurnSupportOp { #[cfg(test)] mod tests { + use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; + use stacks_common::deps_common::bitcoin::network::serialize::deserialize; + use stacks_common::types::chainstate::{SortitionId, StacksAddress}; + use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; + use stacks_common::util::{get_epoch_time_secs, log}; + + use super::*; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::blocks::BitcoinBlockParser; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; @@ -314,16 +313,6 @@ mod tests { use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::index::TrieHashExtension; use crate::core::StacksEpochId; - use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction; - use stacks_common::deps_common::bitcoin::network::serialize::deserialize; - use stacks_common::types::chainstate::StacksAddress; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; - use stacks_common::util::log; - - use stacks_common::types::chainstate::SortitionId; - - use super::*; struct OpFixture { txstr: String, diff --git a/stackslib/src/chainstate/burn/sortition.rs b/stackslib/src/chainstate/burn/sortition.rs index c2d21a7a4..d1cb3a225 100644 --- a/stackslib/src/chainstate/burn/sortition.rs +++ b/stackslib/src/chainstate/burn/sortition.rs @@ -17,36 +17,29 @@ use std::collections::BTreeMap; use rusqlite::Connection; +use stacks_common::types::chainstate::{ + BlockHeaderHash, PoxId, SortitionId, StacksBlockId, TrieHash, VRFSeed, +}; +use stacks_common::util::hash::Hash160; +use stacks_common::util::log; +use stacks_common::util::uint::{BitArray, Uint256, Uint512}; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainBlock; -use crate::burnchains::BurnchainBlockHeader; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; +use crate::burnchains::{ + Address, Burnchain, BurnchainBlock, BurnchainBlockHeader, PublicKey, Txid, +}; use crate::chainstate::burn::db::sortdb::SortitionHandleTx; use crate::chainstate::burn::distribution::BurnSamplePoint; use crate::chainstate::burn::operations::{ BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp, }; -use crate::chainstate::burn::BlockSnapshot; -use crate::chainstate::burn::{BurnchainHeaderHash, ConsensusHash, OpsHash, SortitionHash}; +use crate::chainstate::burn::{ + BlockSnapshot, BurnchainHeaderHash, ConsensusHash, ConsensusHashExtensions, OpsHash, + SortitionHash, +}; use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId, TrieHashExtension}; use crate::core::*; use crate::util_lib::db::Error as db_error; -use stacks_common::util::hash::Hash160; -use stacks_common::util::log; -use stacks_common::util::uint::BitArray; -use stacks_common::util::uint::Uint256; -use stacks_common::util::uint::Uint512; - -use crate::chainstate::burn::ConsensusHashExtensions; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::chainstate::stacks::index::TrieHashExtension; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, PoxId, SortitionId, VRFSeed}; impl BlockSnapshot { /// Creates an "empty" (i.e. zeroed out) BlockSnapshot, to make a basis for creating @@ -443,22 +436,18 @@ impl BlockSnapshot { #[cfg(test)] mod test { + use stacks_common::address::*; + use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, VRFSeed}; + use stacks_common::util::get_epoch_time_secs; + use stacks_common::util::hash::hex_bytes; + use stacks_common::util::vrf::{VRFPrivateKey, VRFPublicKey}; + + use super::*; use crate::burnchains::tests::*; use crate::burnchains::*; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::operations::*; use crate::chainstate::stacks::*; - use stacks_common::address::*; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::hex_bytes; - use stacks_common::util::vrf::VRFPrivateKey; - use stacks_common::util::vrf::VRFPublicKey; - - use stacks_common::types::chainstate::BlockHeaderHash; - use stacks_common::types::chainstate::BurnchainHeaderHash; - use stacks_common::types::chainstate::VRFSeed; - - use super::*; fn test_make_snapshot( sort_tx: &mut SortitionHandleTx, diff --git a/stackslib/src/chainstate/coordinator/comm.rs b/stackslib/src/chainstate/coordinator/comm.rs index e73c2105e..d89afef1e 100644 --- a/stackslib/src/chainstate/coordinator/comm.rs +++ b/stackslib/src/chainstate/coordinator/comm.rs @@ -14,10 +14,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::sync::{ - atomic::{AtomicU64, Ordering}, - Arc, Condvar, LockResult, Mutex, MutexGuard, RwLock, TryLockResult, -}; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{Arc, Condvar, LockResult, Mutex, MutexGuard, RwLock, TryLockResult}; use std::time::{Duration, Instant}; use std::{process, thread}; diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs index 821a79b0a..d758a1682 100644 --- a/stackslib/src/chainstate/coordinator/mod.rs +++ b/stackslib/src/chainstate/coordinator/mod.rs @@ -14,76 +14,70 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; use std::collections::{BTreeMap, HashMap, HashSet, VecDeque}; use std::convert::{TryFrom, TryInto}; -use std::fs; use std::path::PathBuf; use std::sync::mpsc::SyncSender; -use std::sync::Arc; -use std::sync::Mutex; +use std::sync::{Arc, Mutex}; use std::time::Duration; +use std::{cmp, fs}; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::database::BurnStateDB; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::Value; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksBlockId, +}; +use stacks_common::util::get_epoch_time_secs; + +pub use self::comm::CoordinatorCommunication; +use super::stacks::boot::RewardSet; +use crate::burnchains::affirmation::{AffirmationMap, AffirmationMapEntry}; +use crate::burnchains::bitcoin::indexer::BitcoinIndexer; +use crate::burnchains::db::{ + BlockCommitMetadata, BurnchainBlockData, BurnchainDB, BurnchainDBTransaction, + BurnchainHeaderReader, +}; use crate::burnchains::{ - affirmation::{AffirmationMap, AffirmationMapEntry}, - bitcoin::indexer::BitcoinIndexer, - db::{ - BlockCommitMetadata, BurnchainBlockData, BurnchainDB, BurnchainDBTransaction, - BurnchainHeaderReader, - }, Address, Burnchain, BurnchainBlockHeader, Error as BurnchainError, PoxConstants, Txid, }; -use crate::chainstate::burn::{ - db::sortdb::{SortitionDB, SortitionDBConn, SortitionDBTx, SortitionHandleTx}, - operations::leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS}, - operations::BlockstackOperationType, - operations::LeaderBlockCommitOp, - BlockSnapshot, ConsensusHash, +use crate::chainstate::burn::db::sortdb::{ + SortitionDB, SortitionDBConn, SortitionDBTx, SortitionHandleTx, }; +use crate::chainstate::burn::operations::leader_block_commit::{ + RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS, +}; +use crate::chainstate::burn::operations::{BlockstackOperationType, LeaderBlockCommitOp}; +use crate::chainstate::burn::{BlockSnapshot, ConsensusHash}; use crate::chainstate::coordinator::comm::{ ArcCounterCoordinatorNotices, CoordinatorEvents, CoordinatorNotices, CoordinatorReceivers, }; use crate::chainstate::stacks::address::PoxAddress; use crate::chainstate::stacks::boot::POX_3_NAME; +use crate::chainstate::stacks::db::accounts::MinerReward; +use crate::chainstate::stacks::db::{ + ChainStateBootData, ClarityTx, MinerRewardInfo, StacksChainState, StacksEpochReceipt, + StacksHeaderInfo, +}; +use crate::chainstate::stacks::events::{ + StacksTransactionEvent, StacksTransactionReceipt, TransactionOrigin, +}; +use crate::chainstate::stacks::index::marf::MARFOpenOpts; use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus}; use crate::chainstate::stacks::{ - db::{ - accounts::MinerReward, ChainStateBootData, ClarityTx, MinerRewardInfo, StacksChainState, - StacksEpochReceipt, StacksHeaderInfo, - }, - events::{StacksTransactionEvent, StacksTransactionReceipt, TransactionOrigin}, - miner::{signal_mining_blocked, signal_mining_ready, MinerStatus}, Error as ChainstateError, StacksBlock, StacksBlockHeader, TransactionPayload, }; -use crate::core::{StacksEpoch, StacksEpochId}; +use crate::core::{ + StacksEpoch, StacksEpochId, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, +}; +use crate::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator}; use crate::monitoring::{ increment_contract_calls_processed, increment_stx_blocks_processed_counter, }; use crate::net::atlas::{AtlasConfig, AtlasDB, AttachmentInstance}; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; -use crate::util_lib::db::Error as DBError; -use clarity::vm::{ - costs::ExecutionCost, - types::{PrincipalData, QualifiedContractIdentifier}, - Value, -}; - -use crate::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator}; -use clarity::vm::database::BurnStateDB; -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksBlockId, -}; - -use crate::chainstate::stacks::index::marf::MARFOpenOpts; - -pub use self::comm::CoordinatorCommunication; - -use super::stacks::boot::RewardSet; -use stacks_common::util::get_epoch_time_secs; - -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; +use crate::util_lib::db::{DBConn, DBTx, Error as DBError}; pub mod comm; #[cfg(test)] diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs index cd3ba0714..42fbffa50 100644 --- a/stackslib/src/chainstate/coordinator/tests.rs +++ b/stackslib/src/chainstate/coordinator/tests.rs @@ -15,23 +15,38 @@ // along with this program. If not, see . use std::cmp; -use std::collections::BTreeMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::sync::{ - atomic::{AtomicBool, AtomicU64, Ordering}, - mpsc::sync_channel, - Arc, RwLock, -}; +use std::collections::{BTreeMap, HashSet, VecDeque}; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::mpsc::sync_channel; +use std::sync::{Arc, RwLock}; +use clarity::vm::clarity::TransactionConnection; +use clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; +use clarity::vm::database::BurnStateDB; +use clarity::vm::errors::Error as InterpreterError; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::{ClarityVersion, Value}; +use rand::RngCore; use rusqlite::Connection; +use stacks_common::address::AddressHashMode; +use stacks_common::consts::CHAIN_ID_TESTNET; +use stacks_common::deps_common::bitcoin::blockdata::block::{BlockHeader, LoneBlockHeader}; +use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; +use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, StacksBlockId, + TrieHash, VRFSeed, +}; +use stacks_common::util::hash::{to_hex, Hash160}; +use stacks_common::util::vrf::*; +use stacks_common::{address, types, util}; use crate::burnchains::affirmation::*; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::indexer::BitcoinIndexer; +use crate::burnchains::db::*; use crate::burnchains::tests::db::*; -use crate::burnchains::{db::*, *}; -use crate::chainstate; +use crate::burnchains::*; use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::burn::distribution::BurnSamplePoint; use crate::chainstate::burn::operations::leader_block_commit::*; @@ -39,48 +54,18 @@ use crate::chainstate::burn::operations::*; use crate::chainstate::burn::*; use crate::chainstate::coordinator::{Error as CoordError, *}; use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::boot::POX_1_NAME; -use crate::chainstate::stacks::boot::POX_2_NAME; -use crate::chainstate::stacks::boot::{PoxStartCycleInfo, POX_3_NAME}; -use crate::chainstate::stacks::db::{ - accounts::MinerReward, ClarityTx, StacksChainState, StacksHeaderInfo, +use crate::chainstate::stacks::boot::{ + PoxStartCycleInfo, COSTS_2_NAME, POX_1_NAME, POX_2_NAME, POX_3_NAME, }; +use crate::chainstate::stacks::db::accounts::MinerReward; +use crate::chainstate::stacks::db::{ClarityTx, StacksChainState, StacksHeaderInfo}; use crate::chainstate::stacks::*; use crate::clarity_vm::clarity::ClarityConnection; -use crate::core; use crate::core::*; use crate::monitoring::increment_stx_blocks_processed_counter; -use crate::util_lib::boot::boot_code_addr; +use crate::util_lib::boot::{boot_code_addr, boot_code_id}; use crate::util_lib::strings::StacksString; -use clarity::vm::errors::Error as InterpreterError; -use clarity::vm::{ - costs::{ExecutionCost, LimitedCostTracker}, - types::PrincipalData, - types::QualifiedContractIdentifier, - Value, -}; -use stacks_common::address; -use stacks_common::consts::CHAIN_ID_TESTNET; -use stacks_common::util::hash::{to_hex, Hash160}; -use stacks_common::util::vrf::*; - -use crate::chainstate::stacks::boot::COSTS_2_NAME; -use crate::util_lib::boot::boot_code_id; -use clarity::vm::clarity::TransactionConnection; -use clarity::vm::database::BurnStateDB; -use clarity::vm::ClarityVersion; -use rand::RngCore; -use stacks_common::address::AddressHashMode; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, VRFSeed, -}; -use stacks_common::{types, util}; - -use stacks_common::deps_common::bitcoin::blockdata::block::{BlockHeader, LoneBlockHeader}; -use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; -use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; +use crate::{chainstate, core}; lazy_static! { pub static ref BURN_BLOCK_HEADERS: Arc = Arc::new(AtomicU64::new(1)); diff --git a/stackslib/src/chainstate/mod.rs b/stackslib/src/chainstate/mod.rs index 8566160f8..349a34ee3 100644 --- a/stackslib/src/chainstate/mod.rs +++ b/stackslib/src/chainstate/mod.rs @@ -15,7 +15,6 @@ // along with this program. If not, see . use crate::util_lib::db; - use crate::util_lib::db::Error as db_error; pub trait ChainstateDB { diff --git a/stackslib/src/chainstate/stacks/address.rs b/stackslib/src/chainstate/stacks/address.rs index 565f15267..d87d164da 100644 --- a/stackslib/src/chainstate/stacks/address.rs +++ b/stackslib/src/chainstate/stacks/address.rs @@ -19,6 +19,16 @@ use std::io::prelude::*; use std::io::{Read, Write}; use std::{fmt, io}; +use clarity::vm::types::{PrincipalData, SequenceData, StandardPrincipalData, TupleData, Value}; +use stacks_common::address::c32::{c32_address, c32_address_decode}; +use stacks_common::address::{b58, public_keys_to_address_hash, AddressHashMode}; +use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::deps_common::bitcoin::blockdata::opcodes::All as BtcOp; +use stacks_common::deps_common::bitcoin::blockdata::script::Builder as BtcScriptBuilder; +use stacks_common::deps_common::bitcoin::blockdata::transaction::TxOut; +use stacks_common::types::chainstate::{StacksAddress, STACKS_ADDRESS_ENCODED_SIZE}; +use stacks_common::util::hash::{to_hex, Hash160, HASH160_ENCODED_SIZE}; + use crate::burnchains::bitcoin::address::{ legacy_address_type_to_version_byte, legacy_version_byte_to_address_type, to_b58_version_byte, to_c32_version_byte, BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType, @@ -26,30 +36,12 @@ use crate::burnchains::bitcoin::address::{ }; use crate::burnchains::bitcoin::BitcoinTxOutput; use crate::burnchains::{Address, PublicKey}; -use crate::chainstate::stacks::StacksPublicKey; use crate::chainstate::stacks::{ - C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, + StacksPublicKey, C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; use crate::net::Error as net_error; -use clarity::vm::types::{PrincipalData, SequenceData, StandardPrincipalData}; -use clarity::vm::types::{TupleData, Value}; -use stacks_common::address::b58; -use stacks_common::address::c32::c32_address; -use stacks_common::address::c32::c32_address_decode; -use stacks_common::address::public_keys_to_address_hash; -use stacks_common::address::AddressHashMode; -use stacks_common::deps_common::bitcoin::blockdata::opcodes::All as BtcOp; -use stacks_common::deps_common::bitcoin::blockdata::script::Builder as BtcScriptBuilder; -use stacks_common::deps_common::bitcoin::blockdata::transaction::TxOut; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::HASH160_ENCODED_SIZE; - use crate::util_lib::boot::boot_code_addr; -use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::STACKS_ADDRESS_ENCODED_SIZE; pub trait StacksAddressExtensions { fn to_b58(self) -> String; @@ -526,15 +518,16 @@ impl StacksAddressExtensions for StacksAddress { #[cfg(test)] mod test { + use clarity::vm::types::BuffData; + use stacks_common::util::hash::*; + use stacks_common::util::secp256k1::Secp256k1PublicKey as PubKey; + use super::*; use crate::burnchains::bitcoin::BitcoinNetworkType; use crate::chainstate::stacks::*; use crate::net::codec::test::check_codec_and_corruption; use crate::net::codec::*; use crate::net::*; - use clarity::vm::types::BuffData; - use stacks_common::util::hash::*; - use stacks_common::util::secp256k1::Secp256k1PublicKey as PubKey; #[test] fn tx_stacks_address_codec() { diff --git a/stackslib/src/chainstate/stacks/auth.rs b/stackslib/src/chainstate/stacks/auth.rs index a489c80d0..d2981683c 100644 --- a/stackslib/src/chainstate/stacks/auth.rs +++ b/stackslib/src/chainstate/stacks/auth.rs @@ -18,42 +18,26 @@ use std::io; use std::io::prelude::*; use std::io::{Read, Write}; -use crate::burnchains::PrivateKey; -use crate::burnchains::PublicKey; -use crate::burnchains::Txid; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::MultisigHashMode; -use crate::chainstate::stacks::MultisigSpendingCondition; -use crate::chainstate::stacks::SinglesigHashMode; -use crate::chainstate::stacks::SinglesigSpendingCondition; -use crate::chainstate::stacks::StacksPrivateKey; -use crate::chainstate::stacks::StacksPublicKey; -use crate::chainstate::stacks::TransactionAuth; -use crate::chainstate::stacks::TransactionAuthField; -use crate::chainstate::stacks::TransactionAuthFieldID; -use crate::chainstate::stacks::TransactionAuthFlags; -use crate::chainstate::stacks::TransactionPublicKeyEncoding; -use crate::chainstate::stacks::TransactionSpendingCondition; +use stacks_common::address::{public_keys_to_address_hash, AddressHashMode}; +use stacks_common::codec::{ + read_next, write_next, Error as codec_error, StacksMessageCodec, MAX_MESSAGE_LEN, +}; +use stacks_common::types::chainstate::StacksAddress; +use stacks_common::types::StacksPublicKeyBuffer; +use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::retry::{BoundReader, RetryReader}; +use stacks_common::util::secp256k1::{MessageSignature, MESSAGE_SIGNATURE_ENCODED_SIZE}; + +use crate::burnchains::{PrivateKey, PublicKey, Txid}; use crate::chainstate::stacks::{ + Error, MultisigHashMode, MultisigSpendingCondition, SinglesigHashMode, + SinglesigSpendingCondition, StacksPrivateKey, StacksPublicKey, TransactionAuth, + TransactionAuthField, TransactionAuthFieldID, TransactionAuthFlags, + TransactionPublicKeyEncoding, TransactionSpendingCondition, C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; -use crate::net::Error as net_error; -use crate::net::STACKS_PUBLIC_KEY_ENCODED_SIZE; -use stacks_common::address::public_keys_to_address_hash; -use stacks_common::address::AddressHashMode; -use stacks_common::codec::MAX_MESSAGE_LEN; -use stacks_common::types::StacksPublicKeyBuffer; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::retry::BoundReader; -use stacks_common::util::retry::RetryReader; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::secp256k1::MESSAGE_SIGNATURE_ENCODED_SIZE; - -use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::StacksAddress; +use crate::net::{Error as net_error, STACKS_PUBLIC_KEY_ENCODED_SIZE}; impl StacksMessageCodec for TransactionAuthField { fn consensus_serialize(&self, fd: &mut W) -> Result<(), codec_error> { @@ -1096,14 +1080,12 @@ impl TransactionAuth { #[cfg(test)] mod test { - use crate::chainstate::stacks::StacksPublicKey as PubKey; - use crate::chainstate::stacks::*; + use super::*; + use crate::chainstate::stacks::{StacksPublicKey as PubKey, *}; use crate::net::codec::test::check_codec_and_corruption; use crate::net::codec::*; use crate::net::*; - use super::*; - #[test] fn tx_stacks_spending_condition_p2pkh() { // p2pkh diff --git a/stackslib/src/chainstate/stacks/block.rs b/stackslib/src/chainstate/stacks/block.rs index fe715e6f2..88a05fde6 100644 --- a/stackslib/src/chainstate/stacks/block.rs +++ b/stackslib/src/chainstate/stacks/block.rs @@ -19,33 +19,25 @@ use std::io; use std::io::prelude::*; use std::io::{Read, Write}; -use sha2::Digest; -use sha2::Sha512_256; - -use crate::burnchains::PrivateKey; -use crate::burnchains::PublicKey; -use crate::chainstate::burn::operations::*; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::burn::*; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; -use crate::core::*; -use crate::net::Error as net_error; -use stacks_common::codec::MAX_MESSAGE_LEN; +use sha2::{Digest, Sha512_256}; +use stacks_common::codec::{ + read_next, write_next, Error as codec_error, StacksMessageCodec, MAX_MESSAGE_LEN, +}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksBlockId, StacksWorkScore, TrieHash, VRFSeed, +}; use stacks_common::types::StacksPublicKeyBuffer; -use stacks_common::util::hash::MerkleTree; -use stacks_common::util::hash::Sha512Trunc256Sum; +use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum}; use stacks_common::util::retry::BoundReader; use stacks_common::util::secp256k1::MessageSignature; use stacks_common::util::vrf::*; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::StacksMicroblockHeader; -use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, StacksWorkScore, VRFSeed}; +use crate::burnchains::{PrivateKey, PublicKey}; +use crate::chainstate::burn::operations::*; +use crate::chainstate::burn::{ConsensusHash, *}; +use crate::chainstate::stacks::{Error, StacksBlockHeader, StacksMicroblockHeader, *}; +use crate::core::*; +use crate::net::Error as net_error; impl StacksMessageCodec for StacksBlockHeader { fn consensus_serialize(&self, fd: &mut W) -> Result<(), codec_error> { @@ -920,28 +912,25 @@ impl StacksMicroblock { #[cfg(test)] mod test { + use std::error::Error; + + use stacks_common::address::*; + use stacks_common::types::chainstate::StacksAddress; + use stacks_common::util::hash::*; + + use super::*; use crate::burnchains::bitcoin::address::BitcoinAddress; use crate::burnchains::bitcoin::blocks::BitcoinBlockParser; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; use crate::burnchains::bitcoin::BitcoinNetworkType; - use crate::burnchains::BurnchainBlockHeader; - use crate::burnchains::BurnchainSigner; - use crate::burnchains::Txid; + use crate::burnchains::{BurnchainBlockHeader, BurnchainSigner, Txid}; use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; use crate::chainstate::stacks::address::StacksAddressExtensions; - use crate::chainstate::stacks::test::make_codec_test_block; - use crate::chainstate::stacks::test::*; + use crate::chainstate::stacks::test::{make_codec_test_block, *}; use crate::chainstate::stacks::*; use crate::net::codec::test::*; use crate::net::codec::*; use crate::net::*; - use stacks_common::address::*; - use stacks_common::util::hash::*; - use std::error::Error; - - use stacks_common::types::chainstate::StacksAddress; - - use super::*; #[test] fn codec_stacks_block_ecvrf_proof() { diff --git a/stackslib/src/chainstate/stacks/boot/contract_tests.rs b/stackslib/src/chainstate/stacks/boot/contract_tests.rs index 0a9766c02..0c36912ec 100644 --- a/stackslib/src/chainstate/stacks/boot/contract_tests.rs +++ b/stackslib/src/chainstate/stacks/boot/contract_tests.rs @@ -1,29 +1,10 @@ use std::collections::{HashMap, VecDeque}; -use std::convert::TryFrom; -use std::convert::TryInto; +use std::convert::{TryFrom, TryInto}; -use crate::burnchains::Burnchain; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::boot::{ - BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, - POX_2_TESTNET_CODE, -}; -use crate::chainstate::stacks::db::{MinerPaymentSchedule, StacksHeaderInfo}; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, TrieMerkleProof}; -use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; -use crate::chainstate::stacks::*; -use crate::clarity_vm::database::marf::MarfedKV; -use crate::core::{ - BITCOIN_REGTEST_FIRST_BLOCK_HASH, BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT, - BITCOIN_REGTEST_FIRST_BLOCK_TIMESTAMP, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, - POX_REWARD_CYCLE_LENGTH, -}; -use crate::util_lib::db::{DBConn, FromRow}; use clarity::vm::analysis::arithmetic_checker::ArithmeticOnlyChecker; use clarity::vm::analysis::mem_type_check; use clarity::vm::ast::ASTRules; +use clarity::vm::clarity::TransactionConnection; use clarity::vm::contexts::OwnedEnvironment; use clarity::vm::contracts::Contract; use clarity::vm::costs::CostOverflowingMath; @@ -40,27 +21,33 @@ use clarity::vm::types::{ OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, TupleData, TupleTypeSignature, TypeSignature, Value, NONE, }; +use clarity::vm::version::ClarityVersion; use stacks_common::address::AddressHashMode; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum}; - -use crate::clarity_vm::clarity::Error as ClarityError; -use crate::core::PEER_VERSION_EPOCH_1_0; -use crate::core::POX_TESTNET_CYCLE_LENGTH; -use crate::util_lib::boot::boot_code_addr; -use crate::util_lib::boot::boot_code_id; -use crate::{ - burnchains::PoxConstants, - clarity_vm::{clarity::ClarityBlockConnection, database::marf::WritableMarfStore}, - core::StacksEpoch, - core::StacksEpochId, -}; use stacks_common::types::chainstate::{ BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, VRFSeed, }; +use stacks_common::util::hash::{to_hex, Sha256Sum, Sha512Trunc256Sum}; -use clarity::vm::clarity::TransactionConnection; -use clarity::vm::version::ClarityVersion; +use crate::burnchains::{Burnchain, PoxConstants}; +use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::address::PoxAddress; +use crate::chainstate::stacks::boot::{ + BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, + POX_2_TESTNET_CODE, +}; +use crate::chainstate::stacks::db::{MinerPaymentSchedule, StacksHeaderInfo}; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId, TrieMerkleProof}; +use crate::chainstate::stacks::{C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *}; +use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError}; +use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore}; +use crate::core::{ + StacksEpoch, StacksEpochId, BITCOIN_REGTEST_FIRST_BLOCK_HASH, + BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT, BITCOIN_REGTEST_FIRST_BLOCK_TIMESTAMP, + FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, PEER_VERSION_EPOCH_1_0, + POX_REWARD_CYCLE_LENGTH, POX_TESTNET_CYCLE_LENGTH, +}; +use crate::util_lib::boot::{boot_code_addr, boot_code_id}; +use crate::util_lib::db::{DBConn, FromRow}; const USTX_PER_HOLDER: u128 = 1_000_000; diff --git a/stackslib/src/chainstate/stacks/boot/docs.rs b/stackslib/src/chainstate/stacks/boot/docs.rs index 7ba1c1135..802146ffe 100644 --- a/stackslib/src/chainstate/stacks/boot/docs.rs +++ b/stackslib/src/chainstate/stacks/boot/docs.rs @@ -1,9 +1,10 @@ use std::collections::{HashMap, HashSet}; use std::iter::FromIterator; -use super::STACKS_BOOT_CODE_MAINNET; use clarity::vm::docs::contracts::{produce_docs_refs, ContractSupportDocs}; +use super::STACKS_BOOT_CODE_MAINNET; + fn make_contract_support_docs() -> HashMap<&'static str, ContractSupportDocs> { let pox_descriptions = vec![ ("disallow-contract-caller", "Revokes authorization from a contract to invoke stacking methods through contract-calls"), diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs index 41436cfb8..2dbeecd56 100644 --- a/stackslib/src/chainstate/stacks/boot/mod.rs +++ b/stackslib/src/chainstate/stacks/boot/mod.rs @@ -16,59 +16,44 @@ use std::boxed::Box; use std::cmp; -use std::convert::TryFrom; -use std::convert::TryInto; +use std::convert::{TryFrom, TryInto}; -use crate::burnchains::bitcoin::address::BitcoinAddress; -use crate::burnchains::Burnchain; -use crate::burnchains::{Address, PoxConstants}; -use crate::chainstate::burn::db::sortdb::SortitionDB; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::index::marf::MarfConnection; -use crate::chainstate::stacks::Error; -use crate::clarity_vm::clarity::ClarityConnection; -use crate::clarity_vm::clarity::ClarityTransactionConnection; -use crate::core::StacksEpochId; -use crate::core::{POX_MAXIMAL_SCALING, POX_THRESHOLD_STEPS_USTX}; -use crate::util_lib::strings::VecDisplay; use clarity::vm::analysis::CheckErrors; use clarity::vm::ast::ASTRules; -use clarity::vm::clarity::TransactionConnection; +use clarity::vm::clarity::{Error as ClarityError, TransactionConnection}; use clarity::vm::contexts::ContractContext; -use clarity::vm::costs::{ - cost_functions::ClarityCostFunction, ClarityCostFunctionReference, CostStateSummary, -}; -use clarity::vm::database::ClarityDatabase; -use clarity::vm::database::{NULL_BURN_STATE_DB, NULL_HEADER_DB}; -use clarity::vm::errors::Error as VmError; -use clarity::vm::errors::InterpreterError; +use clarity::vm::costs::cost_functions::ClarityCostFunction; +use clarity::vm::costs::{ClarityCostFunctionReference, CostStateSummary, LimitedCostTracker}; +use clarity::vm::database::{ClarityDatabase, NULL_BURN_STATE_DB, NULL_HEADER_DB}; +use clarity::vm::errors::{Error as VmError, InterpreterError}; use clarity::vm::events::StacksTransactionEvent; -use clarity::vm::representations::ClarityName; -use clarity::vm::representations::ContractName; +use clarity::vm::representations::{ClarityName, ContractName}; use clarity::vm::types::{ PrincipalData, QualifiedContractIdentifier, SequenceData, StandardPrincipalData, TupleData, TypeSignature, Value, }; -use clarity::vm::Environment; +use clarity::vm::{ClarityVersion, Environment, SymbolicExpression}; use stacks_common::address::AddressHashMode; use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Hash160; - -use crate::chainstate::stacks::address::StacksAddressExtensions; -use crate::clarity_vm::database::HeadersDBConn; -use crate::util_lib::boot; -use clarity::vm::clarity::Error as ClarityError; -use clarity::vm::ClarityVersion; -use clarity::vm::{costs::LimitedCostTracker, SymbolicExpression}; use stacks_common::types; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId}; +use stacks_common::util::hash::{to_hex, Hash160}; -use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH; -use crate::core::CHAIN_ID_MAINNET; +use crate::burnchains::bitcoin::address::BitcoinAddress; +use crate::burnchains::{Address, Burnchain, PoxConstants}; +use crate::chainstate::burn::db::sortdb::SortitionDB; +use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; +use crate::chainstate::stacks::db::StacksChainState; +use crate::chainstate::stacks::index::marf::MarfConnection; +use crate::chainstate::stacks::Error; +use crate::clarity_vm::clarity::{ClarityConnection, ClarityTransactionConnection}; +use crate::clarity_vm::database::HeadersDBConn; +use crate::core::{ + StacksEpochId, BITCOIN_REGTEST_FIRST_BLOCK_HASH, CHAIN_ID_MAINNET, POX_MAXIMAL_SCALING, + POX_THRESHOLD_STEPS_USTX, +}; +use crate::util_lib::boot; +use crate::util_lib::strings::VecDisplay; const BOOT_CODE_POX_BODY: &'static str = std::include_str!("pox.clar"); const BOOT_CODE_POX_TESTNET_CONSTS: &'static str = std::include_str!("pox-testnet.clar"); @@ -1027,8 +1012,13 @@ pub mod test { use std::convert::From; use std::fs; - use crate::burnchains::Address; - use crate::burnchains::PublicKey; + use clarity::vm::contracts::Contract; + use clarity::vm::types::*; + use stacks_common::util::hash::to_hex; + use stacks_common::util::*; + + use super::*; + use crate::burnchains::{Address, PublicKey}; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::db::*; use crate::chainstate::burn::operations::BlockstackOperationType; @@ -1037,21 +1027,13 @@ pub mod test { use crate::chainstate::stacks::db::*; use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::tests::*; - use crate::chainstate::stacks::Error as chainstate_error; - use crate::chainstate::stacks::*; - use crate::core::StacksEpochId; - use crate::core::*; + use crate::chainstate::stacks::{ + Error as chainstate_error, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, + }; + use crate::core::{StacksEpochId, *}; use crate::net::test::*; - use clarity::vm::contracts::Contract; - use clarity::vm::types::*; - use stacks_common::util::hash::to_hex; - use stacks_common::util::*; - - use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; use crate::util_lib::boot::{boot_code_id, boot_code_test_addr}; - use super::*; - pub const TESTNET_STACKING_THRESHOLD_25: u128 = 8000; /// Extract a PoX address from its tuple representation. diff --git a/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs index 34146c6c8..54bdb226e 100644 --- a/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs +++ b/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs @@ -1,27 +1,10 @@ use std::collections::{HashMap, HashSet, VecDeque}; -use std::convert::TryFrom; -use std::convert::TryInto; +use std::convert::{TryFrom, TryInto}; -use crate::chainstate::burn::BlockSnapshot; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32}; -use crate::chainstate::stacks::boot::{ - BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME, - POX_3_NAME, -}; -use crate::chainstate::stacks::db::{ - MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY, -}; -use crate::chainstate::stacks::index::marf::MarfConnection; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::*; -use crate::clarity_vm::database::marf::MarfedKV; -use crate::clarity_vm::database::HeadersDBConn; -use crate::core::*; -use crate::util_lib::db::{DBConn, FromRow}; +use clarity::vm::clarity::ClarityConnection; use clarity::vm::contexts::OwnedEnvironment; use clarity::vm::contracts::Contract; -use clarity::vm::costs::CostOverflowingMath; +use clarity::vm::costs::{CostOverflowingMath, LimitedCostTracker}; use clarity::vm::database::*; use clarity::vm::errors::{ CheckErrors, Error, IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType, @@ -37,32 +20,38 @@ use clarity::vm::types::{ Value, NONE, }; use stacks_common::address::AddressHashMode; -use stacks_common::types::Address; -use stacks_common::util::hash::hex_bytes; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum}; - -use crate::net::test::TestPeer; -use crate::util_lib::boot::boot_code_id; -use crate::{ - burnchains::Burnchain, - chainstate::{ - burn::db::sortdb::SortitionDB, - stacks::{events::TransactionOrigin, tests::make_coinbase}, - }, - clarity_vm::{clarity::ClarityBlockConnection, database::marf::WritableMarfStore}, - net::test::TestEventObserver, -}; use stacks_common::types::chainstate::{ BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed, }; +use stacks_common::types::Address; +use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum}; -use super::{test::*, RawRewardSetEntry}; -use crate::clarity_vm::clarity::Error as ClarityError; - +use super::test::*; +use super::RawRewardSetEntry; +use crate::burnchains::Burnchain; +use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::burn::operations::*; -use clarity::vm::clarity::ClarityConnection; -use clarity::vm::costs::LimitedCostTracker; +use crate::chainstate::burn::{BlockSnapshot, ConsensusHash}; +use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32}; +use crate::chainstate::stacks::boot::{ + BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME, + POX_3_NAME, +}; +use crate::chainstate::stacks::db::{ + MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY, +}; +use crate::chainstate::stacks::events::TransactionOrigin; +use crate::chainstate::stacks::index::marf::MarfConnection; +use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::tests::make_coinbase; +use crate::chainstate::stacks::*; +use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError}; +use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore}; +use crate::clarity_vm::database::HeadersDBConn; +use crate::core::*; +use crate::net::test::{TestEventObserver, TestPeer}; +use crate::util_lib::boot::boot_code_id; +use crate::util_lib::db::{DBConn, FromRow}; const USTX_PER_HOLDER: u128 = 1_000_000; diff --git a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs index 46618e3a9..4baf4b74e 100644 --- a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs +++ b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs @@ -1,33 +1,10 @@ use std::collections::{HashMap, HashSet, VecDeque}; -use std::convert::TryFrom; -use std::convert::TryInto; +use std::convert::{TryFrom, TryInto}; -use crate::burnchains::PoxConstants; -use crate::chainstate::burn::BlockSnapshot; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32}; -use crate::chainstate::stacks::boot::pox_2_tests::{ - check_pox_print_event, check_stacking_state_invariants, generate_pox_clarity_value, - get_partial_stacked, get_reward_cycle_total, get_reward_set_entries_at, get_stacking_state_pox, - get_stacking_state_pox_2, get_stx_account_at, PoxPrintFields, StackingStateCheckData, -}; -use crate::chainstate::stacks::boot::{ - BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME, - POX_3_NAME, -}; -use crate::chainstate::stacks::db::{ - MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY, -}; -use crate::chainstate::stacks::index::marf::MarfConnection; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::*; -use crate::clarity_vm::database::marf::MarfedKV; -use crate::clarity_vm::database::HeadersDBConn; -use crate::core::*; -use crate::util_lib::db::{DBConn, FromRow}; +use clarity::vm::clarity::ClarityConnection; use clarity::vm::contexts::OwnedEnvironment; use clarity::vm::contracts::Contract; -use clarity::vm::costs::CostOverflowingMath; +use clarity::vm::costs::{CostOverflowingMath, LimitedCostTracker}; use clarity::vm::database::*; use clarity::vm::errors::{ CheckErrors, Error, IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType, @@ -43,32 +20,43 @@ use clarity::vm::types::{ Value, NONE, }; use stacks_common::address::AddressHashMode; -use stacks_common::types::Address; -use stacks_common::util::hash::hex_bytes; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum}; - -use crate::net::test::TestPeer; -use crate::util_lib::boot::boot_code_id; -use crate::{ - burnchains::Burnchain, - chainstate::{ - burn::db::sortdb::SortitionDB, - stacks::{events::TransactionOrigin, tests::make_coinbase}, - }, - clarity_vm::{clarity::ClarityBlockConnection, database::marf::WritableMarfStore}, - net::test::TestEventObserver, -}; use stacks_common::types::chainstate::{ BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed, }; +use stacks_common::types::Address; +use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum}; -use super::{test::*, RawRewardSetEntry}; -use crate::clarity_vm::clarity::Error as ClarityError; - +use super::test::*; +use super::RawRewardSetEntry; +use crate::burnchains::{Burnchain, PoxConstants}; +use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::burn::operations::*; -use clarity::vm::clarity::ClarityConnection; -use clarity::vm::costs::LimitedCostTracker; +use crate::chainstate::burn::{BlockSnapshot, ConsensusHash}; +use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32}; +use crate::chainstate::stacks::boot::pox_2_tests::{ + check_pox_print_event, check_stacking_state_invariants, generate_pox_clarity_value, + get_partial_stacked, get_reward_cycle_total, get_reward_set_entries_at, get_stacking_state_pox, + get_stacking_state_pox_2, get_stx_account_at, PoxPrintFields, StackingStateCheckData, +}; +use crate::chainstate::stacks::boot::{ + BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME, + POX_3_NAME, +}; +use crate::chainstate::stacks::db::{ + MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY, +}; +use crate::chainstate::stacks::events::TransactionOrigin; +use crate::chainstate::stacks::index::marf::MarfConnection; +use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::tests::make_coinbase; +use crate::chainstate::stacks::*; +use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError}; +use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore}; +use crate::clarity_vm::database::HeadersDBConn; +use crate::core::*; +use crate::net::test::{TestEventObserver, TestPeer}; +use crate::util_lib::boot::boot_code_id; +use crate::util_lib::db::{DBConn, FromRow}; const USTX_PER_HOLDER: u128 = 1_000_000; diff --git a/stackslib/src/chainstate/stacks/db/accounts.rs b/stackslib/src/chainstate/stacks/db/accounts.rs index 81aa5b18e..4e499c4a0 100644 --- a/stackslib/src/chainstate/stacks/db/accounts.rs +++ b/stackslib/src/chainstate/stacks/db/accounts.rs @@ -16,25 +16,21 @@ use std::collections::HashMap; +use clarity::vm::database::clarity_store::*; +use clarity::vm::database::*; +use clarity::vm::types::*; use rusqlite::types::ToSql; use rusqlite::Row; +use stacks_common::types::chainstate::{StacksAddress, StacksBlockId}; use crate::burnchains::Address; use crate::chainstate::stacks::db::blocks::*; use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; +use crate::chainstate::stacks::{Error, *}; use crate::clarity::vm::types::StacksAddressExtensions; use crate::clarity_vm::clarity::{ClarityConnection, ClarityTransactionConnection}; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::*; -use clarity::vm::database::clarity_store::*; -use clarity::vm::database::*; -use clarity::vm::types::*; - -use stacks_common::types::chainstate::{StacksAddress, StacksBlockId}; - use crate::core::StacksEpochId; +use crate::util_lib::db::{Error as db_error, *}; /// A record of a coin reward for a miner. There will be at most two of these for a miner: one for /// the coinbase + block-txs + confirmed-mblock-txs, and one for the produced-mblock-txs. The @@ -1067,20 +1063,18 @@ impl StacksChainState { #[cfg(test)] mod test { + use clarity::vm::costs::ExecutionCost; + use clarity::vm::types::StacksAddressExtensions; + use stacks_common::types::chainstate::BurnchainHeaderHash; + use stacks_common::util::hash::*; + + use super::*; use crate::burnchains::*; use crate::chainstate::burn::*; use crate::chainstate::stacks::db::test::*; use crate::chainstate::stacks::index::*; - use crate::chainstate::stacks::Error; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::{Error, *}; use crate::core::StacksEpochId; - use clarity::vm::costs::ExecutionCost; - use stacks_common::util::hash::*; - - use clarity::vm::types::StacksAddressExtensions; - use stacks_common::types::chainstate::BurnchainHeaderHash; - - use super::*; fn make_dummy_miner_payment_schedule( addr: &StacksAddress, diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs index b6560efc1..e362cbbd8 100644 --- a/stackslib/src/chainstate/stacks/db/blocks.rs +++ b/stackslib/src/chainstate/stacks/db/blocks.rs @@ -14,62 +14,16 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; use std::collections::{HashMap, HashSet}; use std::convert::From; -use std::fmt; -use std::fs; -use std::io; use std::io::prelude::*; use std::io::{Read, Seek, SeekFrom, Write}; use std::path::{Path, PathBuf}; +use std::{cmp, fmt, fs, io}; -use clarity::vm::ast::ASTRules; -use rand::thread_rng; -use rand::Rng; -use rand::RngCore; -use rusqlite::Connection; -use rusqlite::DatabaseName; -use rusqlite::{Error as sqlite_error, OptionalExtension}; -use serde::Serialize; - -use crate::burnchains::affirmation::AffirmationMap; -use crate::burnchains::db::BurnchainDB; -use crate::burnchains::db::BurnchainHeaderReader; -use crate::chainstate::burn::db::sortdb::*; -use crate::chainstate::burn::operations::*; -use crate::chainstate::burn::BlockSnapshot; -use crate::chainstate::stacks::address::PoxAddress; -use crate::chainstate::stacks::db::accounts::MinerReward; -use crate::chainstate::stacks::db::transactions::TransactionNonceMismatch; -use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; -use crate::chainstate::stacks::{ - C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, - C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, -}; -use crate::clarity_vm::clarity::{ClarityBlockConnection, ClarityConnection, ClarityInstance}; -use crate::clarity_vm::database::SortitionDBRef; -use crate::core::mempool::MemPoolDB; -use crate::core::mempool::MAXIMUM_MEMPOOL_TX_CHAINING; -use crate::core::*; -use crate::cost_estimates::EstimatorError; -use crate::net::relay::Relayer; -use crate::net::stream::{BlockStreamData, HeaderStreamData, MicroblockStreamData, Streamer}; -use crate::net::BlocksInvData; -use crate::net::Error as net_error; -use crate::net::ExtendedStacksHeader; -use crate::util_lib::db::u64_to_sql; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{ - query_count, query_int, query_row, query_row_columns, query_row_panic, query_rows, - tx_busy_handler, DBConn, FromColumn, FromRow, -}; -use crate::util_lib::strings::StacksString; pub use clarity::vm::analysis::errors::{CheckError, CheckErrors}; use clarity::vm::analysis::run_analysis; +use clarity::vm::ast::ASTRules; use clarity::vm::clarity::TransactionConnection; use clarity::vm::contexts::AssetMap; use clarity::vm::contracts::Contract; @@ -80,22 +34,48 @@ use clarity::vm::types::{ StacksAddressExtensions as ClarityStacksAddressExtensions, StandardPrincipalData, TupleData, TypeSignature, Value, }; -use stacks_common::codec::MAX_MESSAGE_LEN; -use stacks_common::codec::{read_next, write_next}; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; +use rand::{thread_rng, Rng, RngCore}; +use rusqlite::{Connection, DatabaseName, Error as sqlite_error, OptionalExtension}; +use serde::Serialize; +use stacks_common::codec::{read_next, write_next, MAX_MESSAGE_LEN}; +use stacks_common::types::chainstate::{ + BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, +}; use stacks_common::util::hash::to_hex; use stacks_common::util::retry::BoundReader; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs}; +use crate::burnchains::affirmation::AffirmationMap; +use crate::burnchains::db::{BurnchainDB, BurnchainHeaderReader}; +use crate::chainstate::burn::db::sortdb::*; +use crate::chainstate::burn::operations::*; +use crate::chainstate::burn::BlockSnapshot; use crate::chainstate::coordinator::BlockEventDispatcher; -use crate::chainstate::stacks::address::StacksAddressExtensions; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::StacksMicroblockHeader; +use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions}; +use crate::chainstate::stacks::db::accounts::MinerReward; +use crate::chainstate::stacks::db::transactions::TransactionNonceMismatch; +use crate::chainstate::stacks::db::*; +use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::{ + Error, StacksBlockHeader, StacksMicroblockHeader, C32_ADDRESS_VERSION_MAINNET_MULTISIG, + C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, + C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, +}; +use crate::clarity_vm::clarity::{ClarityBlockConnection, ClarityConnection, ClarityInstance}; +use crate::clarity_vm::database::SortitionDBRef; +use crate::core::mempool::{MemPoolDB, MAXIMUM_MEMPOOL_TX_CHAINING}; +use crate::core::*; +use crate::cost_estimates::EstimatorError; use crate::monitoring::{set_last_block_transaction_count, set_last_execution_cost_observed}; +use crate::net::relay::Relayer; +use crate::net::stream::{BlockStreamData, HeaderStreamData, MicroblockStreamData, Streamer}; +use crate::net::{BlocksInvData, Error as net_error, ExtendedStacksHeader}; use crate::util_lib::boot::boot_code_id; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::SortitionId; -use stacks_common::types::chainstate::{StacksAddress, StacksBlockId}; +use crate::util_lib::db::{ + query_count, query_int, query_row, query_row_columns, query_row_panic, query_rows, + tx_busy_handler, u64_to_sql, DBConn, Error as db_error, FromColumn, FromRow, +}; +use crate::util_lib::strings::StacksString; #[derive(Debug, Clone, PartialEq)] pub struct StagingMicroblock { @@ -7143,9 +7123,15 @@ impl StacksChainState { pub mod test { use std::fs; - use rand::thread_rng; - use rand::Rng; + use clarity::vm::ast::ASTRules; + use clarity::vm::types::StacksAddressExtensions; + use rand::{thread_rng, Rng}; + use serde_json; + use stacks_common::types::chainstate::{BlockHeaderHash, StacksWorkScore}; + use stacks_common::util::hash::*; + use stacks_common::util::retry::*; + use super::*; use crate::burnchains::*; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::*; @@ -7155,26 +7141,13 @@ pub mod test { use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::test::*; use crate::chainstate::stacks::tests::*; - use crate::chainstate::stacks::Error as chainstate_error; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::{Error as chainstate_error, *}; use crate::core::mempool::*; - use crate::net::test::*; - use crate::net::ExtendedStacksHeader; - use crate::util_lib::db::Error as db_error; - use crate::util_lib::db::*; - use stacks_common::util::hash::*; - use stacks_common::util::retry::*; - use crate::cost_estimates::metrics::UnitMetric; use crate::cost_estimates::UnitEstimator; - use stacks_common::types::chainstate::{BlockHeaderHash, StacksWorkScore}; - - use super::*; - - use clarity::vm::ast::ASTRules; - use clarity::vm::types::StacksAddressExtensions; - - use serde_json; + use crate::net::test::*; + use crate::net::ExtendedStacksHeader; + use crate::util_lib::db::{Error as db_error, *}; pub fn make_empty_coinbase_block(mblock_key: &StacksPrivateKey) -> StacksBlock { let privk = StacksPrivateKey::from_hex( diff --git a/stackslib/src/chainstate/stacks/db/contracts.rs b/stackslib/src/chainstate/stacks/db/contracts.rs index 6b46fa447..3fd13b378 100644 --- a/stackslib/src/chainstate/stacks/db/contracts.rs +++ b/stackslib/src/chainstate/stacks/db/contracts.rs @@ -15,43 +15,28 @@ // along with this program. If not, see . use std::collections::{HashMap, HashSet}; -use std::fmt; -use std::fs; -use std::io; use std::io::prelude::*; - -use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; - use std::path::{Path, PathBuf}; +use std::{fmt, fs, io}; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{query_count, query_rows, DBConn}; - -use crate::util_lib::strings::StacksString; - +pub use clarity::vm::analysis::errors::CheckErrors; +use clarity::vm::analysis::run_analysis; +use clarity::vm::contexts::{AssetMap, OwnedEnvironment}; +use clarity::vm::contracts::Contract; +use clarity::vm::database::ClarityDatabase; +use clarity::vm::errors::Error as clarity_vm_error; +use clarity::vm::types::{ + AssetIdentifier, PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, Value, +}; use stacks_common::util::hash::to_hex; use crate::chainstate::burn::db::sortdb::*; - -use crate::net::Error as net_error; - -use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData}; - -use clarity::vm::contexts::{AssetMap, OwnedEnvironment}; - -use clarity::vm::analysis::run_analysis; -use clarity::vm::types::{AssetIdentifier, Value}; - -pub use clarity::vm::analysis::errors::CheckErrors; -use clarity::vm::errors::Error as clarity_vm_error; - -use clarity::vm::database::ClarityDatabase; - -use clarity::vm::contracts::Contract; - +use crate::chainstate::stacks::db::*; +use crate::chainstate::stacks::{Error, *}; use crate::clarity_vm::clarity::ClarityConnection; +use crate::net::Error as net_error; +use crate::util_lib::db::{query_count, query_rows, DBConn, Error as db_error}; +use crate::util_lib::strings::StacksString; impl StacksChainState { pub fn get_contract( diff --git a/stackslib/src/chainstate/stacks/db/headers.rs b/stackslib/src/chainstate/stacks/db/headers.rs index 4ab791a1d..0b5c06c15 100644 --- a/stackslib/src/chainstate/stacks/db/headers.rs +++ b/stackslib/src/chainstate/stacks/db/headers.rs @@ -15,28 +15,23 @@ // along with this program. If not, see . use std::collections::HashMap; -use std::fmt; -use std::fs; -use std::io; use std::io::prelude::*; use std::path::{Path, PathBuf}; +use std::{fmt, fs, io}; -use rusqlite::{types::ToSql, OptionalExtension, Row}; +use clarity::vm::costs::ExecutionCost; +use rusqlite::types::ToSql; +use rusqlite::{OptionalExtension, Row}; +use stacks_common::types::chainstate::{StacksBlockId, StacksWorkScore}; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; -use crate::util_lib::db::Error as db_error; +use crate::chainstate::stacks::{Error, *}; +use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; use crate::util_lib::db::{ query_count, query_row, query_row_columns, query_row_panic, query_rows, u64_to_sql, DBConn, - FromColumn, FromRow, + Error as db_error, FromColumn, FromRow, }; -use clarity::vm::costs::ExecutionCost; - -use stacks_common::types::chainstate::{StacksBlockId, StacksWorkScore}; impl FromRow for StacksBlockHeader { fn from_row<'a>(row: &'a Row) -> Result { diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs index 22ee6fc56..e96ef18dd 100644 --- a/stackslib/src/chainstate/stacks/db/mod.rs +++ b/stackslib/src/chainstate/stacks/db/mod.rs @@ -14,30 +14,38 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::collections::{btree_map::Entry, BTreeMap, HashSet}; -use std::fmt; -use std::fs; -use std::io; +use std::collections::btree_map::Entry; +use std::collections::{BTreeMap, HashSet}; use std::io::prelude::*; use std::ops::{Deref, DerefMut}; use std::path::{Path, PathBuf}; +use std::{fmt, fs, io}; +use clarity::vm::analysis::analysis_db::AnalysisDatabase; +use clarity::vm::analysis::run_analysis; use clarity::vm::ast::ASTRules; +use clarity::vm::clarity::TransactionConnection; +use clarity::vm::contexts::OwnedEnvironment; +use clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; +use clarity::vm::database::{ + BurnStateDB, ClarityDatabase, HeadersDB, STXBalance, SqliteConnection, NULL_BURN_STATE_DB, +}; +use clarity::vm::events::*; +use clarity::vm::representations::{ClarityName, ContractName}; +use clarity::vm::types::TupleData; +use clarity::vm::Value; use rusqlite::types::ToSql; -use rusqlite::Connection; -use rusqlite::OpenFlags; -use rusqlite::OptionalExtension; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::NO_PARAMS; +use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS}; +use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, TrieHash}; +use stacks_common::util; +use stacks_common::util::hash::to_hex; use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddress}; use crate::burnchains::{Address, Burnchain, BurnchainParameters, PoxConstants}; -use crate::chainstate::burn::db::sortdb::BlockHeaderCache; -use crate::chainstate::burn::db::sortdb::*; -use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn}; +use crate::chainstate::burn::db::sortdb::{BlockHeaderCache, SortitionDB, SortitionDBConn, *}; use crate::chainstate::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp}; -use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::burn::{ConsensusHash, ConsensusHashExtensions}; +use crate::chainstate::stacks::address::StacksAddressExtensions; use crate::chainstate::stacks::boot::*; use crate::chainstate::stacks::db::accounts::*; use crate::chainstate::stacks::db::blocks::*; @@ -48,54 +56,27 @@ use crate::chainstate::stacks::index::marf::{ BLOCK_HEIGHT_TO_HASH_MAPPING_KEY, MARF, }; use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MARFValue, MarfTrieId}; use crate::chainstate::stacks::{ - C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, - C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, + Error, StacksBlockHeader, StacksMicroblockHeader, C32_ADDRESS_VERSION_MAINNET_MULTISIG, + C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, + C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, }; use crate::clarity_vm::clarity::{ ClarityBlockConnection, ClarityConnection, ClarityInstance, ClarityReadOnlyConnection, - Error as clarity_error, + Error as clarity_error, PreCommitClarityBlock, }; +use crate::clarity_vm::database::marf::MarfedKV; +use crate::clarity_vm::database::HeadersDBConn; use crate::core::*; use crate::monitoring; use crate::net::atlas::BNS_CHARS_REGEX; -use crate::net::Error as net_error; -use crate::net::MemPoolSyncData; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{ - query_count, query_row, tx_begin_immediate, tx_busy_handler, DBConn, DBTx, FromColumn, FromRow, - IndexDBConn, IndexDBTx, -}; -use clarity::vm::analysis::analysis_db::AnalysisDatabase; -use clarity::vm::analysis::run_analysis; -use clarity::vm::clarity::TransactionConnection; -use clarity::vm::contexts::OwnedEnvironment; -use clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; -use clarity::vm::database::{ - BurnStateDB, ClarityDatabase, HeadersDB, STXBalance, SqliteConnection, NULL_BURN_STATE_DB, -}; - -use crate::clarity_vm::clarity::PreCommitClarityBlock; -use clarity::vm::events::*; -use clarity::vm::representations::ClarityName; -use clarity::vm::representations::ContractName; -use clarity::vm::types::TupleData; -use stacks_common::util; -use stacks_common::util::hash::to_hex; - -use crate::chainstate::burn::ConsensusHashExtensions; -use crate::chainstate::stacks::address::StacksAddressExtensions; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, MARFValue}; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::StacksMicroblockHeader; -use crate::clarity_vm::database::marf::MarfedKV; -use crate::clarity_vm::database::HeadersDBConn; +use crate::net::{Error as net_error, MemPoolSyncData}; use crate::util_lib::boot::{boot_code_acc, boot_code_addr, boot_code_id, boot_code_tx_auth}; -use clarity::vm::Value; -use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, TrieHash}; +use crate::util_lib::db::{ + query_count, query_row, tx_begin_immediate, tx_busy_handler, DBConn, DBTx, Error as db_error, + FromColumn, FromRow, IndexDBConn, IndexDBTx, +}; pub mod accounts; pub mod blocks; @@ -2457,14 +2438,13 @@ impl StacksChainState { pub mod test { use std::{env, fs}; - use crate::chainstate::stacks::db::*; - use crate::chainstate::stacks::*; use clarity::vm::test_util::TEST_BURN_STATE_DB; use stx_genesis::GenesisData; - use crate::util_lib::boot::boot_code_test_addr; - use super::*; + use crate::chainstate::stacks::db::*; + use crate::chainstate::stacks::*; + use crate::util_lib::boot::boot_code_test_addr; pub fn instantiate_chainstate( mainnet: bool, diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs index 5dfa3e179..ac11e7489 100644 --- a/stackslib/src/chainstate/stacks/db/transactions.rs +++ b/stackslib/src/chainstate/stacks/db/transactions.rs @@ -15,50 +15,40 @@ // along with this program. If not, see . use std::collections::{HashMap, HashSet}; -use std::fmt; -use std::fs; -use std::io; use std::io::prelude::*; use std::io::{Read, Write}; use std::path::{Path, PathBuf}; +use std::{fmt, fs, io}; + +use clarity::vm::analysis::run_analysis; +use clarity::vm::analysis::types::ContractAnalysis; +use clarity::vm::ast::errors::ParseErrors; +use clarity::vm::ast::ASTRules; +use clarity::vm::clarity::TransactionConnection; +use clarity::vm::contexts::{AssetMap, AssetMapEntry, Environment}; +use clarity::vm::contracts::Contract; +use clarity::vm::costs::cost_functions::ClarityCostFunction; +use clarity::vm::costs::{cost_functions, runtime_cost, CostTracker, ExecutionCost}; +use clarity::vm::database::ClarityDatabase; +use clarity::vm::errors::Error as InterpreterError; +use clarity::vm::representations::{ClarityName, ContractName}; +use clarity::vm::types::{ + AssetIdentifier, BuffData, PrincipalData, QualifiedContractIdentifier, SequenceData, + StacksAddressExtensions as ClarityStacksAddressExt, StandardPrincipalData, TupleData, + TypeSignature, Value, +}; +use stacks_common::util::hash::to_hex; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; +use crate::chainstate::stacks::{Error, StacksMicroblockHeader, *}; use crate::clarity_vm::clarity::{ ClarityBlockConnection, ClarityConnection, ClarityInstance, ClarityTransactionConnection, Error as clarity_error, }; use crate::net::Error as net_error; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{query_count, query_rows, DBConn}; -use clarity::vm::ast::ASTRules; -use stacks_common::util::hash::to_hex; - -use crate::chainstate::stacks::StacksMicroblockHeader; +use crate::util_lib::db::{query_count, query_rows, DBConn, Error as db_error}; use crate::util_lib::strings::{StacksString, VecDisplay}; -use clarity::vm::analysis::run_analysis; -use clarity::vm::analysis::types::ContractAnalysis; -use clarity::vm::clarity::TransactionConnection; -use clarity::vm::contexts::{AssetMap, AssetMapEntry, Environment}; -use clarity::vm::contracts::Contract; -use clarity::vm::costs::cost_functions; -use clarity::vm::costs::cost_functions::ClarityCostFunction; -use clarity::vm::costs::runtime_cost; -use clarity::vm::costs::CostTracker; -use clarity::vm::costs::ExecutionCost; -use clarity::vm::database::ClarityDatabase; -use clarity::vm::errors::Error as InterpreterError; -use clarity::vm::representations::ClarityName; -use clarity::vm::representations::ContractName; -use clarity::vm::types::StacksAddressExtensions as ClarityStacksAddressExt; -use clarity::vm::types::{ - AssetIdentifier, BuffData, PrincipalData, QualifiedContractIdentifier, SequenceData, - StandardPrincipalData, TupleData, TypeSignature, Value, -}; - -use clarity::vm::ast::errors::ParseErrors; impl StacksTransactionReceipt { pub fn from_stx_transfer( @@ -1458,28 +1448,24 @@ impl StacksChainState { #[cfg(test)] pub mod test { + use clarity::vm::clarity::TransactionConnection; + use clarity::vm::contracts::Contract; + use clarity::vm::representations::{ClarityName, ContractName}; + use clarity::vm::test_util::{UnitTestBurnStateDB, TEST_BURN_STATE_DB}; use clarity::vm::tests::TEST_HEADER_DB; + use clarity::vm::types::*; use rand::Rng; + use stacks_common::types::chainstate::SortitionId; + use stacks_common::util::hash::*; + use super::*; use crate::burnchains::Address; use crate::chainstate::stacks::boot::*; use crate::chainstate::stacks::db::test::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::*; - use crate::chainstate::stacks::Error; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::{Error, *}; use crate::chainstate::*; - use clarity::vm::clarity::TransactionConnection; - use clarity::vm::contracts::Contract; - use clarity::vm::representations::ClarityName; - use clarity::vm::representations::ContractName; - use clarity::vm::test_util::UnitTestBurnStateDB; - use clarity::vm::test_util::TEST_BURN_STATE_DB; - use clarity::vm::types::*; - use stacks_common::types::chainstate::SortitionId; - use stacks_common::util::hash::*; - - use super::*; pub const TestBurnStateDB_20: UnitTestBurnStateDB = UnitTestBurnStateDB { epoch_id: StacksEpochId::Epoch20, diff --git a/stackslib/src/chainstate/stacks/db/unconfirmed.rs b/stackslib/src/chainstate/stacks/db/unconfirmed.rs index 9033feb57..c3d11c962 100644 --- a/stackslib/src/chainstate/stacks/db/unconfirmed.rs +++ b/stackslib/src/chainstate/stacks/db/unconfirmed.rs @@ -20,27 +20,22 @@ use std::collections::{HashMap, HashSet}; use std::fs; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::database::{BurnStateDB, HeadersDB, NULL_BURN_STATE_DB, NULL_HEADER_DB}; +use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksBlockId}; + +use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::stacks::db::accounts::*; use crate::chainstate::stacks::db::blocks::*; use crate::chainstate::stacks::db::*; use crate::chainstate::stacks::events::*; use crate::chainstate::stacks::index::marf::MARFOpenOpts; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; +use crate::chainstate::stacks::{Error, *}; use crate::clarity_vm::clarity::{ClarityInstance, Error as clarity_error}; +use crate::clarity_vm::database::marf::MarfedKV; use crate::core::*; use crate::net::Error as net_error; use crate::util_lib::db::Error as db_error; -use clarity::vm::costs::ExecutionCost; -use clarity::vm::database::BurnStateDB; -use clarity::vm::database::HeadersDB; -use clarity::vm::database::NULL_BURN_STATE_DB; -use clarity::vm::database::NULL_HEADER_DB; - -use crate::chainstate::burn::db::sortdb::SortitionDB; -use crate::clarity_vm::database::marf::MarfedKV; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; pub type UnconfirmedTxMap = HashMap; @@ -646,6 +641,9 @@ impl StacksChainState { mod test { use std::fs; + use clarity::vm::types::StacksAddressExtensions; + + use super::*; use crate::burnchains::PublicKey; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::db::*; @@ -656,15 +654,11 @@ mod test { use crate::chainstate::stacks::index::*; use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::tests::make_coinbase; - use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::{C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *}; use crate::core::mempool::*; use crate::core::*; use crate::net::relay::*; use crate::net::test::*; - use clarity::vm::types::StacksAddressExtensions; - - use super::*; #[test] fn test_unconfirmed_refresh_one_microblock_stx_transfer() { diff --git a/stackslib/src/chainstate/stacks/events.rs b/stackslib/src/chainstate/stacks/events.rs index 7afbdad99..6ea4f694a 100644 --- a/stackslib/src/chainstate/stacks/events.rs +++ b/stackslib/src/chainstate/stacks/events.rs @@ -1,8 +1,6 @@ -use crate::burnchains::Txid; -use crate::chainstate::stacks::StacksMicroblockHeader; -use crate::chainstate::stacks::StacksTransaction; use clarity::vm::analysis::ContractAnalysis; use clarity::vm::costs::ExecutionCost; +pub use clarity::vm::events::StacksTransactionEvent; use clarity::vm::types::{ AssetIdentifier, PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, Value, }; @@ -10,8 +8,9 @@ use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::hash::to_hex; +use crate::burnchains::Txid; use crate::chainstate::burn::operations::BlockstackOperationType; -pub use clarity::vm::events::StacksTransactionEvent; +use crate::chainstate::stacks::{StacksMicroblockHeader, StacksTransaction}; #[derive(Debug, Clone, PartialEq)] pub enum TransactionOrigin { diff --git a/stackslib/src/chainstate/stacks/index/bits.rs b/stackslib/src/chainstate/stacks/index/bits.rs index c4ece80ce..88869d417 100644 --- a/stackslib/src/chainstate/stacks/index/bits.rs +++ b/stackslib/src/chainstate/stacks/index/bits.rs @@ -14,30 +14,25 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; /// This file contains low-level methods for reading and manipulating Trie node data. use std::fmt; -use std::io; use std::io::{ErrorKind, Read, Seek, SeekFrom, Write}; +use std::{error, io}; -use sha2::Digest; -use sha2::Sha512_256 as TrieHasher; - -use crate::chainstate::stacks::index::node::{ - clear_backptr, ConsensusSerializable, TrieNode16, TrieNode256, TrieNode4, TrieNode48, - TrieNodeID, TrieNodeType, TriePtr, TRIEPTR_SIZE, +use sha2::{Digest, Sha512_256 as TrieHasher}; +use stacks_common::types::chainstate::{ + TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, }; -use crate::chainstate::stacks::index::node::{TrieNode, TRIEPATH_MAX_LEN}; -use crate::chainstate::stacks::index::storage::{TrieFileStorage, TrieStorageConnection}; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::TrieLeaf; -use crate::chainstate::stacks::index::{BlockMap, MarfTrieId}; use stacks_common::util::hash::to_hex; use stacks_common::util::log; use stacks_common::util::macros::is_trace; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::chainstate::stacks::index::node::{ + clear_backptr, ConsensusSerializable, TrieNode, TrieNode16, TrieNode256, TrieNode4, TrieNode48, + TrieNodeID, TrieNodeType, TriePtr, TRIEPATH_MAX_LEN, TRIEPTR_SIZE, +}; +use crate::chainstate::stacks::index::storage::{TrieFileStorage, TrieStorageConnection}; +use crate::chainstate::stacks::index::{BlockMap, Error, MarfTrieId, TrieLeaf}; /// Get the size of a Trie path (note that a Trie path is 32 bytes long, and can definitely _not_ /// be over 255 bytes). diff --git a/stackslib/src/chainstate/stacks/index/cache.rs b/stackslib/src/chainstate/stacks/index/cache.rs index cc0d4dbf7..3763f15c6 100644 --- a/stackslib/src/chainstate/stacks/index/cache.rs +++ b/stackslib/src/chainstate/stacks/index/cache.rs @@ -17,25 +17,23 @@ use std::char::from_digit; use std::collections::{HashMap, HashSet, VecDeque}; use std::convert::{TryFrom, TryInto}; -use std::env; -use std::fmt; -use std::fs; use std::hash::{Hash, Hasher}; -use std::io; use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write}; use std::iter::FromIterator; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; -use std::os; use std::path::{Path, PathBuf}; use std::time::SystemTime; -use std::{cmp, error}; +use std::{cmp, env, error, fmt, fs, io, os}; +use rusqlite::types::{FromSql, ToSql}; use rusqlite::{ - types::{FromSql, ToSql}, Connection, Error as SqliteError, ErrorCode as SqliteErrorCode, OpenFlags, OptionalExtension, Transaction, NO_PARAMS, }; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, +}; use crate::chainstate::stacks::index::bits::{ get_node_byte_len, get_node_hash, read_block_identifier, read_hash_bytes, read_node_hash_bytes, @@ -45,19 +43,11 @@ use crate::chainstate::stacks::index::node::{ clear_backptr, is_backptr, set_backptr, TrieNode, TrieNode16, TrieNode256, TrieNode4, TrieNode48, TrieNodeID, TrieNodeType, TriePath, TriePtr, }; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::TrieLeaf; -use crate::chainstate::stacks::index::{trie_sql, ClarityMarfTrieId, MarfTrieId}; -use crate::util_lib::db::sql_pragma; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::tx_busy_handler; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::SQLITE_MMAP_SIZE; - -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::chainstate::stacks::index::{trie_sql, ClarityMarfTrieId, Error, MarfTrieId, TrieLeaf}; +use crate::util_lib::db::{ + sql_pragma, sqlite_open, tx_begin_immediate, tx_busy_handler, Error as db_error, + SQLITE_MMAP_SIZE, +}; /// Fully-qualified address of a Trie node. Includes both the block's blob rowid and the pointer within the /// block's blob as to where it is stored. @@ -342,22 +332,18 @@ impl TrieCache { pub mod test { use std::collections::VecDeque; use std::fs; + use std::time::SystemTime; + use rand::{thread_rng, Rng}; + use sha2::Digest; + use stacks_common::util::hash::Sha512Trunc256Sum; + + use super::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::*; - use super::*; - - use rand::thread_rng; - use rand::Rng; - - use sha2::Digest; - use stacks_common::util::hash::Sha512Trunc256Sum; - - use std::time::SystemTime; - /// Deterministic random keys to insert pub fn make_test_insert_data( num_inserts_per_block: u64, diff --git a/stackslib/src/chainstate/stacks/index/file.rs b/stackslib/src/chainstate/stacks/index/file.rs index df84a9dad..99df76016 100644 --- a/stackslib/src/chainstate/stacks/index/file.rs +++ b/stackslib/src/chainstate/stacks/index/file.rs @@ -17,26 +17,24 @@ use std::char::from_digit; use std::collections::{HashMap, HashSet, VecDeque}; use std::convert::{TryFrom, TryInto}; -use std::env; -use std::fmt; -use std::fs; use std::fs::OpenOptions; use std::hash::{Hash, Hasher}; -use std::io; use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write}; use std::iter::FromIterator; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; -use std::os; use std::path::{Path, PathBuf}; use std::time::SystemTime; -use std::{cmp, error}; +use std::{cmp, env, error, fmt, fs, io, os}; +use rusqlite::types::{FromSql, ToSql}; use rusqlite::{ - types::{FromSql, ToSql}, Connection, Error as SqliteError, ErrorCode as SqliteErrorCode, OpenFlags, OptionalExtension, Transaction, NO_PARAMS, }; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, +}; use crate::chainstate::stacks::index::bits::{ get_node_byte_len, get_node_hash, read_block_identifier, read_hash_bytes, read_node_hash_bytes, @@ -47,23 +45,12 @@ use crate::chainstate::stacks::index::node::{ clear_backptr, is_backptr, set_backptr, TrieNode, TrieNode16, TrieNode256, TrieNode4, TrieNode48, TrieNodeID, TrieNodeType, TriePath, TriePtr, }; -use crate::chainstate::stacks::index::storage::NodeHashReader; -use crate::chainstate::stacks::index::storage::TrieStorageConnection; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::TrieLeaf; -use crate::chainstate::stacks::index::{trie_sql, ClarityMarfTrieId, MarfTrieId}; - -use crate::util_lib::db::sql_pragma; -use crate::util_lib::db::sql_vacuum; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::tx_busy_handler; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::SQLITE_MMAP_SIZE; - -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::chainstate::stacks::index::storage::{NodeHashReader, TrieStorageConnection}; +use crate::chainstate::stacks::index::{trie_sql, ClarityMarfTrieId, Error, MarfTrieId, TrieLeaf}; +use crate::util_lib::db::{ + sql_pragma, sql_vacuum, sqlite_open, tx_begin_immediate, tx_busy_handler, Error as db_error, + SQLITE_MMAP_SIZE, +}; /// Mapping between block IDs and trie offsets pub type TrieIdOffsets = HashMap; diff --git a/stackslib/src/chainstate/stacks/index/marf.rs b/stackslib/src/chainstate/stacks/index/marf.rs index 7a7cbfd73..1f01d19f3 100644 --- a/stackslib/src/chainstate/stacks/index/marf.rs +++ b/stackslib/src/chainstate/stacks/index/marf.rs @@ -14,16 +14,16 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; -use std::fmt; -use std::fs; -use std::io; use std::io::{Cursor, Read, Seek, SeekFrom, Write}; use std::ops::DerefMut; use std::path::PathBuf; +use std::{error, fmt, fs, io}; use rusqlite::{Connection, Transaction}; use sha2::Digest; +use stacks_common::types::chainstate::{BlockHeaderHash, TrieHash, TRIEHASH_ENCODED_SIZE}; +use stacks_common::util::hash::Sha512Trunc256Sum; +use stacks_common::util::log; use crate::chainstate::stacks::index::bits::{get_leaf_hash, get_node_hash, read_root_hash}; use crate::chainstate::stacks::index::node::{ @@ -34,18 +34,10 @@ use crate::chainstate::stacks::index::storage::{ TrieFileStorage, TrieHashCalculationMode, TrieStorageConnection, TrieStorageTransaction, }; use crate::chainstate::stacks::index::trie::Trie; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::MARFValue; -use crate::chainstate::stacks::index::MarfTrieId; +use crate::chainstate::stacks::index::{ + ClarityMarfTrieId, Error, MARFValue, MarfTrieId, TrieHashExtension, TrieLeaf, TrieMerkleProof, +}; use crate::util_lib::db::Error as db_error; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::log; - -use crate::chainstate::stacks::index::TrieHashExtension; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, TrieLeaf, TrieMerkleProof}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::TRIEHASH_ENCODED_SIZE; pub const BLOCK_HASH_TO_HEIGHT_MAPPING_KEY: &str = "__MARF_BLOCK_HASH_TO_HEIGHT"; pub const BLOCK_HEIGHT_TO_HASH_MAPPING_KEY: &str = "__MARF_BLOCK_HEIGHT_TO_HASH"; diff --git a/stackslib/src/chainstate/stacks/index/mod.rs b/stackslib/src/chainstate/stacks/index/mod.rs index 734f2bc87..a712ee01a 100644 --- a/stackslib/src/chainstate/stacks/index/mod.rs +++ b/stackslib/src/chainstate/stacks/index/mod.rs @@ -14,25 +14,19 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; -use std::fmt; use std::hash::Hash; -use std::io; use std::io::{Seek, SeekFrom}; -use std::ptr; +use std::{error, fmt, io, ptr}; -use sha2::Digest; -use sha2::Sha512_256 as TrieHasher; - -use crate::util_lib::db::Error as db_error; +use sha2::{Digest, Sha512_256 as TrieHasher}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId, TrieHash, + TRIEHASH_ENCODED_SIZE, +}; use stacks_common::util::hash::to_hex; use stacks_common::util::log; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::SortitionId; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::util_lib::db::Error as db_error; pub mod bits; pub mod cache; diff --git a/stackslib/src/chainstate/stacks/index/node.rs b/stackslib/src/chainstate/stacks/index/node.rs index 712bee82f..ece594394 100644 --- a/stackslib/src/chainstate/stacks/index/node.rs +++ b/stackslib/src/chainstate/stacks/index/node.rs @@ -16,31 +16,26 @@ use std::char::from_digit; use std::collections::{HashMap, HashSet, VecDeque}; -use std::error; -use std::fmt; -use std::io; use std::io::{Cursor, Read, Seek, SeekFrom, Write}; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; +use std::{error, fmt, io}; use sha2::Digest; +use stacks_common::codec::{read_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, +}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::slice_partialeq; use crate::chainstate::stacks::index::bits::{ get_path_byte_len, get_ptrs_byte_len, path_from_bytes, ptrs_from_bytes, write_path_to_bytes, }; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::{BlockMap, MarfTrieId, TrieHasher}; -use stacks_common::util::hash::to_hex; -use stacks_common::util::slice_partialeq; - -use crate::chainstate::stacks::index::TrieHashExtension; use crate::chainstate::stacks::index::{ - ClarityMarfTrieId, MARFValue, TrieLeaf, MARF_VALUE_ENCODED_SIZE, + BlockMap, ClarityMarfTrieId, Error, MARFValue, MarfTrieId, TrieHashExtension, TrieHasher, + TrieLeaf, MARF_VALUE_ENCODED_SIZE, }; -use stacks_common::codec::{read_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; #[derive(Debug, Clone, PartialEq)] pub enum CursorError { diff --git a/stackslib/src/chainstate/stacks/index/proofs.rs b/stackslib/src/chainstate/stacks/index/proofs.rs index ee5f8fc1f..9348a8b4f 100644 --- a/stackslib/src/chainstate/stacks/index/proofs.rs +++ b/stackslib/src/chainstate/stacks/index/proofs.rs @@ -16,17 +16,19 @@ use std::char::from_digit; use std::collections::{HashMap, HashSet, VecDeque}; -use std::error; -use std::fmt; -use std::fs; -use std::io; use std::io::{Cursor, Read, Seek, SeekFrom, Write}; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; use std::path::{Path, PathBuf}; +use std::{error, fmt, fs, io}; -use sha2::Digest; -use sha2::Sha512_256 as TrieHasher; +use sha2::{Digest, Sha512_256 as TrieHasher}; +use stacks_common::codec::{read_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, +}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::slice_partialeq; use crate::chainstate::stacks::index::bits::{ get_leaf_hash, get_node_hash, read_root_hash, write_path_to_bytes, @@ -39,21 +41,10 @@ use crate::chainstate::stacks::index::node::{ }; use crate::chainstate::stacks::index::storage::{TrieFileStorage, TrieStorageConnection}; use crate::chainstate::stacks::index::trie::Trie; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::{BlockMap, MarfTrieId}; -use stacks_common::util::hash::to_hex; -use stacks_common::util::slice_partialeq; - -use crate::chainstate::stacks::index::TrieHashExtension; use crate::chainstate::stacks::index::{ - ClarityMarfTrieId, MARFValue, ProofTrieNode, ProofTriePtr, TrieLeaf, TrieMerkleProof, - TrieMerkleProofType, + BlockMap, ClarityMarfTrieId, Error, MARFValue, MarfTrieId, ProofTrieNode, ProofTriePtr, + TrieHashExtension, TrieLeaf, TrieMerkleProof, TrieMerkleProofType, }; -use stacks_common::codec::{read_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; - -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; impl ConsensusSerializable<()> for ProofTrieNode { fn write_consensus_bytes( diff --git a/stackslib/src/chainstate/stacks/index/storage.rs b/stackslib/src/chainstate/stacks/index/storage.rs index c6ad3b96d..c686e2404 100644 --- a/stackslib/src/chainstate/stacks/index/storage.rs +++ b/stackslib/src/chainstate/stacks/index/storage.rs @@ -17,34 +17,33 @@ use std::char::from_digit; use std::collections::{HashMap, HashSet, VecDeque}; use std::convert::{TryFrom, TryInto}; -use std::env; -use std::fmt; -use std::fs; use std::hash::{Hash, Hasher}; -use std::io; use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write}; use std::iter::FromIterator; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; -use std::os; use std::path::{Path, PathBuf}; use std::time::SystemTime; -use std::{cmp, error}; +use std::{cmp, env, error, fmt, fs, io, os}; +use rusqlite::types::{FromSql, ToSql}; use rusqlite::{ - types::{FromSql, ToSql}, Connection, Error as SqliteError, ErrorCode as SqliteErrorCode, OpenFlags, OptionalExtension, Transaction, NO_PARAMS, }; use sha2::Digest; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, +}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::log; use crate::chainstate::stacks::index::bits::{ get_node_byte_len, get_node_hash, read_block_identifier, read_hash_bytes, read_node_hash_bytes, read_nodetype, read_root_hash, write_nodetype_bytes, }; use crate::chainstate::stacks::index::cache::*; -use crate::chainstate::stacks::index::file::TrieFile; -use crate::chainstate::stacks::index::file::TrieFileNodeHashReader; +use crate::chainstate::stacks::index::file::{TrieFile, TrieFileNodeHashReader}; use crate::chainstate::stacks::index::marf::MARFOpenOpts; use crate::chainstate::stacks::index::node::{ clear_backptr, is_backptr, set_backptr, TrieNode, TrieNode16, TrieNode256, TrieNode4, @@ -52,25 +51,14 @@ use crate::chainstate::stacks::index::node::{ }; use crate::chainstate::stacks::index::profile::TrieBenchmark; use crate::chainstate::stacks::index::trie::Trie; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::TrieHasher; -use crate::chainstate::stacks::index::{trie_sql, BlockMap, MarfTrieId}; -use crate::util_lib::db::sql_pragma; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::tx_busy_handler; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::SQLITE_MARF_PAGE_SIZE; -use crate::util_lib::db::SQLITE_MMAP_SIZE; - -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; - -use crate::chainstate::stacks::index::TrieHashExtension; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, TrieLeaf}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::chainstate::stacks::index::{ + trie_sql, BlockMap, ClarityMarfTrieId, Error, MarfTrieId, TrieHashExtension, TrieHasher, + TrieLeaf, +}; +use crate::util_lib::db::{ + sql_pragma, sqlite_open, tx_begin_immediate, tx_busy_handler, Error as db_error, + SQLITE_MARF_PAGE_SIZE, SQLITE_MMAP_SIZE, +}; /// A trait for reading the hash of a node into a given Write impl, given the pointer to a node in /// a trie. diff --git a/stackslib/src/chainstate/stacks/index/test/cache.rs b/stackslib/src/chainstate/stacks/index/test/cache.rs index 224de0ea9..5a0bc41d0 100644 --- a/stackslib/src/chainstate/stacks/index/test/cache.rs +++ b/stackslib/src/chainstate/stacks/index/test/cache.rs @@ -14,23 +14,19 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::collections::VecDeque; +use std::time::SystemTime; +use std::{cmp, fs}; + +use rand::{thread_rng, Rng}; +use sha2::Digest; +use stacks_common::util::hash::Sha512Trunc256Sum; + +use super::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::*; -use std::cmp; -use std::collections::VecDeque; -use std::fs; - -use super::*; - -use rand::thread_rng; -use rand::Rng; - -use sha2::Digest; -use stacks_common::util::hash::Sha512Trunc256Sum; - -use std::time::SystemTime; /// Deterministic random keys to insert pub fn make_test_insert_data( diff --git a/stackslib/src/chainstate/stacks/index/test/file.rs b/stackslib/src/chainstate/stacks/index/test/file.rs index 7f76c63a4..499198aca 100644 --- a/stackslib/src/chainstate/stacks/index/test/file.rs +++ b/stackslib/src/chainstate/stacks/index/test/file.rs @@ -14,6 +14,11 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use std::fs; + +use rusqlite::{Connection, OpenFlags}; + +use super::*; use crate::chainstate::stacks::index::cache::test::make_test_insert_data; use crate::chainstate::stacks::index::cache::*; use crate::chainstate::stacks::index::file::*; @@ -21,11 +26,6 @@ use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::*; use crate::util_lib::db::*; -use rusqlite::Connection; -use rusqlite::OpenFlags; -use std::fs; - -use super::*; fn db_path(test_name: &str) -> String { let path = format!("/tmp/{}.sqlite", test_name); diff --git a/stackslib/src/chainstate/stacks/index/test/marf.rs b/stackslib/src/chainstate/stacks/index/test/marf.rs index cc1262367..b66fc4dd8 100644 --- a/stackslib/src/chainstate/stacks/index/test/marf.rs +++ b/stackslib/src/chainstate/stacks/index/test/marf.rs @@ -20,6 +20,11 @@ use std::fs; use std::io::Cursor; +use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::util::get_epoch_time_ms; +use stacks_common::util::hash::to_hex; + +use super::*; use crate::chainstate::stacks::index::bits::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; @@ -27,17 +32,9 @@ use crate::chainstate::stacks::index::proofs::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::test::*; use crate::chainstate::stacks::index::trie::*; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::MARFValue; -use crate::chainstate::stacks::index::TrieHashExtension; -use crate::chainstate::stacks::index::TrieLeaf; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::hash::to_hex; - -use stacks_common::types::chainstate::StacksBlockId; - -use super::*; +use crate::chainstate::stacks::index::{ + ClarityMarfTrieId, Error, MARFValue, TrieHashExtension, TrieLeaf, +}; #[test] fn marf_insert_different_leaf_same_block_100() { diff --git a/stackslib/src/chainstate/stacks/index/test/mod.rs b/stackslib/src/chainstate/stacks/index/test/mod.rs index 609380ae1..2c3b04698 100644 --- a/stackslib/src/chainstate/stacks/index/test/mod.rs +++ b/stackslib/src/chainstate/stacks/index/test/mod.rs @@ -17,29 +17,24 @@ #![allow(unused_variables)] #![allow(unused_assignments)] -use std::fs; - use std::collections::HashMap; +use std::fs; use std::io::{Cursor, Seek, SeekFrom}; +use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::util::get_epoch_time_ms; +use stacks_common::util::hash::to_hex; + use crate::chainstate::stacks::index::bits::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; use crate::chainstate::stacks::index::proofs::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::trie::*; -use crate::chainstate::stacks::index::MARFValue; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::index::TrieHashExtension; -use crate::chainstate::stacks::index::TrieLeaf; -use crate::chainstate::stacks::index::TrieMerkleProof; - -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::hash::to_hex; - -use crate::chainstate::stacks::BlockHeaderHash; -use crate::chainstate::stacks::TrieHash; -use stacks_common::types::chainstate::StacksBlockId; +use crate::chainstate::stacks::index::{ + MARFValue, MarfTrieId, TrieHashExtension, TrieLeaf, TrieMerkleProof, +}; +use crate::chainstate::stacks::{BlockHeaderHash, TrieHash}; pub mod cache; pub mod file; diff --git a/stackslib/src/chainstate/stacks/index/test/node.rs b/stackslib/src/chainstate/stacks/index/test/node.rs index 240db172b..a98491595 100644 --- a/stackslib/src/chainstate/stacks/index/test/node.rs +++ b/stackslib/src/chainstate/stacks/index/test/node.rs @@ -19,6 +19,7 @@ use std::io::Cursor; +use super::*; use crate::chainstate::stacks::index::bits::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; @@ -28,8 +29,6 @@ use crate::chainstate::stacks::index::test::*; use crate::chainstate::stacks::index::trie::*; use crate::chainstate::stacks::index::*; -use super::*; - #[test] fn trieptr_to_bytes() { let mut t = TriePtr::new(0x11, 0x22, 0x33445566); diff --git a/stackslib/src/chainstate/stacks/index/test/proofs.rs b/stackslib/src/chainstate/stacks/index/test/proofs.rs index 0693c4201..9642bfcdc 100644 --- a/stackslib/src/chainstate/stacks/index/test/proofs.rs +++ b/stackslib/src/chainstate/stacks/index/test/proofs.rs @@ -14,12 +14,11 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use super::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::test::*; use crate::chainstate::stacks::index::*; -use super::*; - #[test] fn verifier_catches_stale_proof() { use std::env; diff --git a/stackslib/src/chainstate/stacks/index/test/storage.rs b/stackslib/src/chainstate/stacks/index/test/storage.rs index dfcc53843..a996bc718 100644 --- a/stackslib/src/chainstate/stacks/index/test/storage.rs +++ b/stackslib/src/chainstate/stacks/index/test/storage.rs @@ -17,15 +17,13 @@ use std::collections::VecDeque; use std::fs; +use rand::{thread_rng, Rng}; + +use super::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; use crate::chainstate::stacks::index::*; -use rand::thread_rng; -use rand::Rng; - -use super::*; - fn ptrs_cmp(p1: &[TriePtr], p2: &[TriePtr]) -> bool { if p1.len() != p2.len() { return false; diff --git a/stackslib/src/chainstate/stacks/index/test/trie.rs b/stackslib/src/chainstate/stacks/index/test/trie.rs index 9d9efaa71..ca2c0ced6 100644 --- a/stackslib/src/chainstate/stacks/index/test/trie.rs +++ b/stackslib/src/chainstate/stacks/index/test/trie.rs @@ -19,6 +19,7 @@ use std::io::Cursor; +use super::*; use crate::chainstate::stacks::index::bits::*; use crate::chainstate::stacks::index::marf::*; use crate::chainstate::stacks::index::node::*; @@ -26,10 +27,7 @@ use crate::chainstate::stacks::index::proofs::*; use crate::chainstate::stacks::index::storage::*; use crate::chainstate::stacks::index::test::*; use crate::chainstate::stacks::index::trie::*; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::chainstate::stacks::index::*; - -use super::*; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, *}; fn walk_to_insertion_point( f: &mut TrieStorageConnection, diff --git a/stackslib/src/chainstate/stacks/index/trie.rs b/stackslib/src/chainstate/stacks/index/trie.rs index fcd5d9c10..6c7cc7a08 100644 --- a/stackslib/src/chainstate/stacks/index/trie.rs +++ b/stackslib/src/chainstate/stacks/index/trie.rs @@ -14,14 +14,19 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::error; /// This module defines the methods for reading and inserting into a Trie use std::fmt; -use std::io; use std::io::{Cursor, Read, Seek, SeekFrom, Write}; use std::marker::PhantomData; +use std::{error, io}; use sha2::Digest; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, +}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::log; +use stacks_common::util::macros::is_trace; use crate::chainstate::stacks::index::bits::{ get_leaf_hash, get_node_hash, get_nodetype_hash_bytes, @@ -34,18 +39,9 @@ use crate::chainstate::stacks::index::node::{ use crate::chainstate::stacks::index::storage::{ TrieFileStorage, TrieHashCalculationMode, TrieStorageConnection, }; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::{MarfTrieId, TrieHasher}; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::macros::is_trace; - -use crate::chainstate::stacks::index::TrieHashExtension; -use crate::chainstate::stacks::index::TrieLeaf; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::TRIEHASH_ENCODED_SIZE; +use crate::chainstate::stacks::index::{ + Error, MarfTrieId, TrieHashExtension, TrieHasher, TrieLeaf, +}; /// We don't actually instantiate a Trie, but we still need to pass a type parameter for the /// storage implementation. diff --git a/stackslib/src/chainstate/stacks/index/trie_sql.rs b/stackslib/src/chainstate/stacks/index/trie_sql.rs index 21a4d3e27..787a3b125 100644 --- a/stackslib/src/chainstate/stacks/index/trie_sql.rs +++ b/stackslib/src/chainstate/stacks/index/trie_sql.rs @@ -20,50 +20,37 @@ use std::char::from_digit; use std::collections::{HashMap, HashSet, VecDeque}; use std::convert::{TryFrom, TryInto}; -use std::error; -use std::fmt; -use std::fs; -use std::io; use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write}; use std::iter::FromIterator; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; -use std::os; use std::path::{Path, PathBuf}; +use std::{error, fmt, fs, io, os}; use regex::Regex; -use rusqlite::{ - blob::Blob, - types::{FromSql, ToSql}, - Connection, Error as SqliteError, OptionalExtension, Transaction, NO_PARAMS, +use rusqlite::blob::Blob; +use rusqlite::types::{FromSql, ToSql}; +use rusqlite::{Connection, Error as SqliteError, OptionalExtension, Transaction, NO_PARAMS}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, TrieHash, BLOCK_HEADER_HASH_ENCODED_SIZE, TRIEHASH_ENCODED_SIZE, }; +use stacks_common::util::log; use crate::chainstate::stacks::index::bits::{ get_node_byte_len, get_node_hash, read_block_identifier, read_hash_bytes, read_node_hash_bytes as bits_read_node_hash_bytes, read_nodetype, read_nodetype_nohash, write_nodetype_bytes, }; - use crate::chainstate::stacks::index::file::TrieFile; use crate::chainstate::stacks::index::node::{ clear_backptr, is_backptr, set_backptr, TrieNode, TrieNode16, TrieNode256, TrieNode4, TrieNode48, TrieNodeID, TrieNodeType, TriePath, TriePtr, }; use crate::chainstate::stacks::index::storage::{TrieFileStorage, TrieStorageConnection}; -use crate::chainstate::stacks::index::Error; -use crate::chainstate::stacks::index::{trie_sql, BlockMap, MarfTrieId}; -use crate::util_lib::db::query_count; -use crate::util_lib::db::query_row; -use crate::util_lib::db::query_rows; -use crate::util_lib::db::sql_pragma; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::u64_to_sql; -use stacks_common::util::log; - -use crate::chainstate::stacks::index::TrieLeaf; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BLOCK_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::{TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::chainstate::stacks::index::{trie_sql, BlockMap, Error, MarfTrieId, TrieLeaf}; +use crate::util_lib::db::{ + query_count, query_row, query_rows, sql_pragma, tx_begin_immediate, u64_to_sql, +}; static SQL_MARF_DATA_TABLE: &str = " CREATE TABLE IF NOT EXISTS marf_data ( diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs index 1969559db..de58760ce 100644 --- a/stackslib/src/chainstate/stacks/miner.rs +++ b/stackslib/src/chainstate/stacks/miner.rs @@ -14,68 +14,56 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; -use std::collections::HashMap; -use std::collections::HashSet; +use std::collections::{HashMap, HashSet}; use std::convert::From; -use std::fs; -use std::mem; -use std::sync::atomic::AtomicBool; -use std::sync::atomic::Ordering; -use std::sync::Arc; -use std::sync::Mutex; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex}; use std::thread::ThreadId; +use std::{cmp, fs, mem}; -use crate::burnchains::PrivateKey; -use crate::burnchains::PublicKey; +use clarity::vm::analysis::{CheckError, CheckErrors}; +use clarity::vm::ast::errors::ParseErrors; +use clarity::vm::ast::ASTRules; +use clarity::vm::clarity::TransactionConnection; +use clarity::vm::database::BurnStateDB; +use clarity::vm::errors::Error as InterpreterError; +use clarity::vm::types::TypeSignature; +use serde::Deserialize; +use stacks_common::codec::{read_next, write_next, StacksMessageCodec}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksWorkScore, TrieHash, +}; +use stacks_common::types::StacksPublicKeyBuffer; +use stacks_common::util::get_epoch_time_ms; +use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum}; +use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey}; +use stacks_common::util::vrf::*; + +use crate::burnchains::{PrivateKey, PublicKey}; use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleTx}; use crate::chainstate::burn::operations::*; use crate::chainstate::burn::*; +use crate::chainstate::stacks::address::StacksAddressExtensions; +use crate::chainstate::stacks::db::blocks::{MemPoolRejection, SetupBlockResult}; use crate::chainstate::stacks::db::transactions::{ handle_clarity_runtime_error, ClarityRuntimeTxError, }; use crate::chainstate::stacks::db::unconfirmed::UnconfirmedState; use crate::chainstate::stacks::db::{ - blocks::MemPoolRejection, ChainstateTx, ClarityTx, MinerRewardInfo, StacksChainState, - MINER_REWARD_MATURITY, + ChainstateTx, ClarityTx, MinerRewardInfo, StacksChainState, MINER_REWARD_MATURITY, }; use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt}; -use crate::chainstate::stacks::Error; -use crate::chainstate::stacks::*; +use crate::chainstate::stacks::{Error, StacksBlockHeader, StacksMicroblockHeader, *}; use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance}; use crate::core::mempool::*; use crate::core::*; use crate::cost_estimates::metrics::CostMetric; use crate::cost_estimates::CostEstimator; -use crate::net::relay::Relayer; -use crate::net::Error as net_error; -use clarity::vm::database::BurnStateDB; -use serde::Deserialize; -use stacks_common::types::StacksPublicKeyBuffer; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::hash::MerkleTree; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey}; -use stacks_common::util::vrf::*; - -use crate::chainstate::stacks::address::StacksAddressExtensions; -use crate::chainstate::stacks::db::blocks::SetupBlockResult; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::StacksMicroblockHeader; use crate::monitoring::{ set_last_mined_block_transaction_count, set_last_mined_execution_cost_observed, }; -use clarity::vm::analysis::{CheckError, CheckErrors}; -use clarity::vm::ast::errors::ParseErrors; -use clarity::vm::ast::ASTRules; -use clarity::vm::clarity::TransactionConnection; -use clarity::vm::errors::Error as InterpreterError; -use clarity::vm::types::TypeSignature; -use stacks_common::codec::{read_next, write_next, StacksMessageCodec}; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksWorkScore}; +use crate::net::relay::Relayer; +use crate::net::Error as net_error; /// System status for mining. /// The miner can be Ready, in which case a miner is allowed to run diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs index 18a238ae6..c8e5aba78 100644 --- a/stackslib/src/chainstate/stacks/mod.rs +++ b/stackslib/src/chainstate/stacks/mod.rs @@ -14,55 +14,46 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::convert::From; -use std::convert::TryFrom; -use std::error; -use std::fmt; -use std::io; +use std::convert::{From, TryFrom}; use std::io::prelude::*; use std::io::{Read, Write}; -use std::ops::Deref; -use std::ops::DerefMut; +use std::ops::{Deref, DerefMut}; +use std::{error, fmt, io}; -use rusqlite::Error as RusqliteError; -use sha2::{Digest, Sha512_256}; - -use crate::burnchains::Txid; -use crate::chainstate::burn::operations::LeaderBlockCommitOp; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::db::accounts::MinerReward; -use crate::chainstate::stacks::db::blocks::MemPoolRejection; -use crate::chainstate::stacks::db::MinerRewardInfo; -use crate::chainstate::stacks::db::StacksHeaderInfo; -use crate::chainstate::stacks::index::Error as marf_error; -use crate::clarity_vm::clarity::Error as clarity_error; -use crate::net::Error as net_error; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::strings::StacksString; use clarity::vm::contexts::GlobalContext; -use clarity::vm::costs::CostErrors; -use clarity::vm::costs::ExecutionCost; +use clarity::vm::costs::{CostErrors, ExecutionCost}; use clarity::vm::errors::Error as clarity_interpreter_error; use clarity::vm::representations::{ClarityName, ContractName}; use clarity::vm::types::{ PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, Value, }; use clarity::vm::ClarityVersion; +use rusqlite::Error as RusqliteError; +use sha2::{Digest, Sha512_256}; use stacks_common::address::AddressHashMode; -use stacks_common::codec::MAX_MESSAGE_LEN; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::hash::HASH160_ENCODED_SIZE; +use stacks_common::codec::{ + read_next, write_next, Error as codec_error, StacksMessageCodec, MAX_MESSAGE_LEN, +}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksWorkScore, TrieHash, + TRIEHASH_ENCODED_SIZE, +}; +use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE}; use stacks_common::util::secp256k1; use stacks_common::util::secp256k1::MessageSignature; use stacks_common::util::vrf::VRFProof; -use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksWorkScore, -}; -use stacks_common::types::chainstate::{StacksBlockId, TrieHash, TRIEHASH_ENCODED_SIZE}; +use crate::burnchains::Txid; +use crate::chainstate::burn::operations::LeaderBlockCommitOp; +use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::db::accounts::MinerReward; +use crate::chainstate::stacks::db::blocks::MemPoolRejection; +use crate::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo}; +use crate::chainstate::stacks::index::Error as marf_error; +use crate::clarity_vm::clarity::Error as clarity_error; +use crate::net::Error as net_error; +use crate::util_lib::db::{DBConn, Error as db_error}; +use crate::util_lib::strings::StacksString; pub mod address; pub mod auth; @@ -77,12 +68,11 @@ pub mod transaction; #[cfg(test)] pub mod tests; -pub use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey}; - pub use stacks_common::address::{ C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; +pub use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey}; pub const STACKS_BLOCK_VERSION: u8 = 6; pub const STACKS_BLOCK_VERSION_AST_PRECHECK_SIZE: u8 = 1; @@ -907,18 +897,17 @@ pub const MAX_MICROBLOCK_SIZE: u32 = 65536; #[cfg(test)] pub mod test { - use crate::chainstate::stacks::StacksPublicKey as PubKey; - use crate::chainstate::stacks::*; - use crate::core::*; - use crate::net::codec::test::check_codec_and_corruption; - use crate::net::codec::*; - use crate::net::*; use clarity::vm::representations::{ClarityName, ContractName}; use clarity::vm::ClarityVersion; use stacks_common::util::hash::*; use stacks_common::util::log; use super::*; + use crate::chainstate::stacks::{StacksPublicKey as PubKey, *}; + use crate::core::*; + use crate::net::codec::test::check_codec_and_corruption; + use crate::net::codec::*; + use crate::net::*; /// Make a representative of each kind of transaction we support pub fn codec_all_transactions( diff --git a/stackslib/src/chainstate/stacks/tests/accounting.rs b/stackslib/src/chainstate/stacks/tests/accounting.rs index 86873174c..1bd328d81 100644 --- a/stackslib/src/chainstate/stacks/tests/accounting.rs +++ b/stackslib/src/chainstate/stacks/tests/accounting.rs @@ -18,16 +18,20 @@ /// various conditions, such as ensuring that the right principals get paid and ensuring that fees /// are appropriately distributed. use std::cell::RefCell; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::fs; -use std::io; +use std::collections::{HashMap, HashSet, VecDeque}; use std::path::{Path, PathBuf}; +use std::{fs, io}; +use clarity::vm::clarity::ClarityConnection; +use clarity::vm::costs::LimitedCostTracker; +use clarity::vm::types::*; use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::address::*; +use stacks_common::types::chainstate::SortitionId; +use stacks_common::util::hash::MerkleTree; +use stacks_common::util::sleep_ms; +use stacks_common::util::vrf::VRFProof; use crate::burnchains::tests::*; use crate::burnchains::*; @@ -40,30 +44,17 @@ use crate::chainstate::coordinator::Error as CoordinatorError; use crate::chainstate::stacks::db::blocks::test::store_staging_block; use crate::chainstate::stacks::db::test::*; use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error as ChainstateError; -use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; -use crate::chainstate::stacks::*; -use crate::net::test::*; -use crate::util_lib::db::Error as db_error; -use clarity::vm::types::*; -use stacks_common::address::*; -use stacks_common::util::sleep_ms; -use stacks_common::util::vrf::VRFProof; - -use crate::cost_estimates::metrics::UnitMetric; -use crate::cost_estimates::UnitEstimator; -use crate::util_lib::boot::boot_code_addr; -use stacks_common::types::chainstate::SortitionId; - -use clarity::vm::costs::LimitedCostTracker; - use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::tests::*; +use crate::chainstate::stacks::{ + Error as ChainstateError, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, +}; use crate::core::*; - -use stacks_common::util::hash::MerkleTree; - -use clarity::vm::clarity::ClarityConnection; +use crate::cost_estimates::metrics::UnitMetric; +use crate::cost_estimates::UnitEstimator; +use crate::net::test::*; +use crate::util_lib::boot::boot_code_addr; +use crate::util_lib::db::Error as db_error; // test that the bad (pre 2.1) microblock fee payment still works. we have to support it for // eternity :( diff --git a/stackslib/src/chainstate/stacks/tests/block_construction.rs b/stackslib/src/chainstate/stacks/tests/block_construction.rs index 459f91b80..24de63a67 100644 --- a/stackslib/src/chainstate/stacks/tests/block_construction.rs +++ b/stackslib/src/chainstate/stacks/tests/block_construction.rs @@ -21,17 +21,23 @@ /// concerned with building out and testing block histories from manually-constructed blocks, /// ignoring mempool-level concerns entirely. use std::cell::RefCell; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::fs; -use std::io; +use std::collections::{HashMap, HashSet, VecDeque}; use std::path::{Path, PathBuf}; +use std::{fs, io}; +use clarity::vm::clarity::ClarityConnection; +use clarity::vm::costs::LimitedCostTracker; use clarity::vm::database::ClarityDatabase; +use clarity::vm::test_util::TEST_BURN_STATE_DB; +use clarity::vm::types::*; use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::address::*; +use stacks_common::types::chainstate::SortitionId; +use stacks_common::util::hash::MerkleTree; +use stacks_common::util::secp256k1::Secp256k1PrivateKey; +use stacks_common::util::vrf::VRFProof; +use stacks_common::util::{get_epoch_time_ms, sleep_ms}; use crate::burnchains::tests::*; use crate::burnchains::*; @@ -45,37 +51,20 @@ use crate::chainstate::stacks::db::blocks::test::store_staging_block; use crate::chainstate::stacks::db::test::*; use crate::chainstate::stacks::db::*; use crate::chainstate::stacks::events::StacksTransactionReceipt; -use crate::chainstate::stacks::test::codec_all_transactions; -use crate::chainstate::stacks::Error as ChainstateError; -use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; -use crate::chainstate::stacks::*; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::net::test::*; -use crate::util_lib::db::Error as db_error; -use clarity::vm::types::*; -use stacks_common::address::*; -use stacks_common::util::sleep_ms; -use stacks_common::util::vrf::VRFProof; - -use crate::cost_estimates::metrics::UnitMetric; -use crate::cost_estimates::UnitEstimator; -use crate::util_lib::boot::boot_code_addr; -use stacks_common::types::chainstate::SortitionId; - -use clarity::vm::costs::LimitedCostTracker; - use crate::chainstate::stacks::miner::*; +use crate::chainstate::stacks::test::codec_all_transactions; use crate::chainstate::stacks::tests::*; +use crate::chainstate::stacks::{ + Error as ChainstateError, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, +}; use crate::core::mempool::MemPoolWalkSettings; use crate::core::tests::make_block; -use crate::core::*; - -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::hash::MerkleTree; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; - -use clarity::vm::clarity::ClarityConnection; -use clarity::vm::test_util::TEST_BURN_STATE_DB; +use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, *}; +use crate::cost_estimates::metrics::UnitMetric; +use crate::cost_estimates::UnitEstimator; +use crate::net::test::*; +use crate::util_lib::boot::boot_code_addr; +use crate::util_lib::db::Error as db_error; #[test] fn test_build_anchored_blocks_empty() { diff --git a/stackslib/src/chainstate/stacks/tests/chain_histories.rs b/stackslib/src/chainstate/stacks/tests/chain_histories.rs index 43a7d5049..1ed4bbc42 100644 --- a/stackslib/src/chainstate/stacks/tests/chain_histories.rs +++ b/stackslib/src/chainstate/stacks/tests/chain_histories.rs @@ -21,16 +21,21 @@ /// module focuses on building and testing chain histories; unlike `block_construction`, this module does not /// test anything about block construction from mempool state. use std::cell::RefCell; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::fs; -use std::io; +use std::collections::{HashMap, HashSet, VecDeque}; use std::path::{Path, PathBuf}; +use std::{fs, io}; +use clarity::vm::ast::ASTRules; +use clarity::vm::clarity::ClarityConnection; +use clarity::vm::costs::LimitedCostTracker; +use clarity::vm::types::*; use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::address::*; +use stacks_common::types::chainstate::SortitionId; +use stacks_common::util::hash::MerkleTree; +use stacks_common::util::sleep_ms; +use stacks_common::util::vrf::VRFProof; use crate::burnchains::db::BurnchainDB; use crate::burnchains::tests::*; @@ -44,31 +49,17 @@ use crate::chainstate::coordinator::Error as CoordinatorError; use crate::chainstate::stacks::db::blocks::test::store_staging_block; use crate::chainstate::stacks::db::test::*; use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error as ChainstateError; -use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; -use crate::chainstate::stacks::*; -use crate::net::test::*; -use crate::util_lib::db::Error as db_error; -use clarity::vm::types::*; -use stacks_common::address::*; -use stacks_common::util::sleep_ms; -use stacks_common::util::vrf::VRFProof; - -use crate::cost_estimates::metrics::UnitMetric; -use crate::cost_estimates::UnitEstimator; -use crate::util_lib::boot::boot_code_addr; -use stacks_common::types::chainstate::SortitionId; - -use clarity::vm::ast::ASTRules; -use clarity::vm::costs::LimitedCostTracker; - use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::tests::*; +use crate::chainstate::stacks::{ + Error as ChainstateError, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, +}; use crate::core::*; - -use stacks_common::util::hash::MerkleTree; - -use clarity::vm::clarity::ClarityConnection; +use crate::cost_estimates::metrics::UnitMetric; +use crate::cost_estimates::UnitEstimator; +use crate::net::test::*; +use crate::util_lib::boot::boot_code_addr; +use crate::util_lib::db::Error as db_error; fn connect_burnchain_db(burnchain: &Burnchain) -> BurnchainDB { let burnchain_db = diff --git a/stackslib/src/chainstate/stacks/tests/mod.rs b/stackslib/src/chainstate/stacks/tests/mod.rs index 00c0bcc5e..78f7b3cea 100644 --- a/stackslib/src/chainstate/stacks/tests/mod.rs +++ b/stackslib/src/chainstate/stacks/tests/mod.rs @@ -15,16 +15,20 @@ // along with this program. If not, see . use std::cell::RefCell; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::fs; -use std::io; +use std::collections::{HashMap, HashSet, VecDeque}; use std::path::{Path, PathBuf}; +use std::{fs, io}; +use clarity::vm::clarity::ClarityConnection; +use clarity::vm::costs::LimitedCostTracker; +use clarity::vm::types::*; use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::address::*; +use stacks_common::consts::FIRST_BURNCHAIN_CONSENSUS_HASH; +use stacks_common::types::chainstate::SortitionId; +use stacks_common::util::sleep_ms; +use stacks_common::util::vrf::{VRFProof, VRFPublicKey}; use crate::burnchains::tests::*; use crate::burnchains::*; @@ -37,29 +41,15 @@ use crate::chainstate::coordinator::Error as CoordinatorError; use crate::chainstate::stacks::db::blocks::test::store_staging_block; use crate::chainstate::stacks::db::test::*; use crate::chainstate::stacks::db::*; -use crate::chainstate::stacks::Error as ChainstateError; -use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; -use crate::chainstate::stacks::*; -use crate::net::test::*; -use crate::util_lib::db::Error as db_error; -use clarity::vm::types::*; -use stacks_common::address::*; -use stacks_common::util::sleep_ms; -use stacks_common::util::vrf::VRFProof; - +use crate::chainstate::stacks::miner::*; +use crate::chainstate::stacks::{ + Error as ChainstateError, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, +}; use crate::cost_estimates::metrics::UnitMetric; use crate::cost_estimates::UnitEstimator; +use crate::net::test::*; use crate::util_lib::boot::boot_code_addr; -use stacks_common::types::chainstate::SortitionId; - -use clarity::vm::costs::LimitedCostTracker; - -use crate::chainstate::stacks::miner::*; - -use stacks_common::consts::FIRST_BURNCHAIN_CONSENSUS_HASH; -use stacks_common::util::vrf::VRFPublicKey; - -use clarity::vm::clarity::ClarityConnection; +use crate::util_lib::db::Error as db_error; pub mod accounting; pub mod block_construction; diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs index 2c673e27f..de65a62a1 100644 --- a/stackslib/src/chainstate/stacks/transaction.rs +++ b/stackslib/src/chainstate/stacks/transaction.rs @@ -19,24 +19,21 @@ use std::io; use std::io::prelude::*; use std::io::{Read, Write}; -use crate::burnchains::Txid; -use crate::chainstate::stacks::*; -use crate::core::*; -use crate::net::Error as net_error; use clarity::vm::representations::{ClarityName, ContractName}; use clarity::vm::types::serialization::SerializationError as clarity_serialization_error; use clarity::vm::types::{QualifiedContractIdentifier, StandardPrincipalData}; -use clarity::vm::{SymbolicExpression, SymbolicExpressionType, Value}; +use clarity::vm::{ClarityVersion, SymbolicExpression, SymbolicExpressionType, Value}; +use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::types::chainstate::StacksAddress; use stacks_common::types::StacksPublicKeyBuffer; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Sha512Trunc256Sum; +use stacks_common::util::hash::{to_hex, Sha512Trunc256Sum}; use stacks_common::util::retry::BoundReader; use stacks_common::util::secp256k1::MessageSignature; -use crate::chainstate::stacks::StacksMicroblockHeader; -use clarity::vm::ClarityVersion; -use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; -use stacks_common::types::chainstate::StacksAddress; +use crate::burnchains::Txid; +use crate::chainstate::stacks::{StacksMicroblockHeader, *}; +use crate::core::*; +use crate::net::Error as net_error; impl StacksMessageCodec for TransactionContractCall { fn consensus_serialize(&self, fd: &mut W) -> Result<(), codec_error> { @@ -1071,23 +1068,21 @@ impl StacksTransactionSigner { mod test { use std::error::Error; - use crate::chainstate::stacks::test::codec_all_transactions; - use crate::chainstate::stacks::StacksPublicKey as PubKey; - use crate::chainstate::stacks::*; - use crate::chainstate::stacks::{ - C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, - }; - use crate::net::codec::test::check_codec_and_corruption; - use crate::net::codec::*; - use crate::net::*; use clarity::vm::representations::{ClarityName, ContractName}; use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; use stacks_common::util::hash::*; use stacks_common::util::log; - use stacks_common::util::retry::BoundReader; - use stacks_common::util::retry::LogReader; + use stacks_common::util::retry::{BoundReader, LogReader}; use super::*; + use crate::chainstate::stacks::test::codec_all_transactions; + use crate::chainstate::stacks::{ + StacksPublicKey as PubKey, C32_ADDRESS_VERSION_MAINNET_MULTISIG, + C32_ADDRESS_VERSION_MAINNET_SINGLESIG, *, + }; + use crate::net::codec::test::check_codec_and_corruption; + use crate::net::codec::*; + use crate::net::*; fn corrupt_auth_field( corrupt_auth_fields: &TransactionAuth, diff --git a/stackslib/src/clarity_cli.rs b/stackslib/src/clarity_cli.rs index 43677baf1..9c384a231 100644 --- a/stackslib/src/clarity_cli.rs +++ b/stackslib/src/clarity_cli.rs @@ -14,93 +14,59 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::convert::TryInto; -use std::env; +use std::convert::{TryFrom, TryInto}; use std::ffi::OsStr; -use std::fs; -use std::io; use std::io::{Read, Write}; use std::iter::Iterator; use std::path::PathBuf; -use std::process; +use std::str::FromStr; +use std::{env, fs, io, process}; use clarity::vm::coverage::CoverageReporter; use rand::Rng; use rusqlite::types::ToSql; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::{Connection, OpenFlags, NO_PARAMS}; - -use crate::chainstate::stacks::index::{storage::TrieFileStorage, MarfTrieId}; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::FromColumn; +use rusqlite::{Connection, OpenFlags, Row, Transaction, NO_PARAMS}; +use serde::Serialize; +use serde_json::json; use stacks_common::address::c32::c32_address; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::hash::{bytes_to_hex, Hash160, Sha512Trunc256Sum}; - -use crate::clarity::{ - vm::analysis, - vm::analysis::contract_interface_builder::build_contract_interface, - vm::analysis::{errors::CheckError, errors::CheckResult, AnalysisDatabase, ContractAnalysis}, - vm::ast, - vm::ast::build_ast_with_rules, - vm::ast::ASTRules, - vm::contexts::GlobalContext, - vm::contexts::{AssetMap, OwnedEnvironment}, - vm::costs::ExecutionCost, - vm::costs::LimitedCostTracker, - vm::database::{ - BurnStateDB, ClarityDatabase, HeadersDB, STXBalance, SqliteConnection, NULL_BURN_STATE_DB, - }, - vm::errors::{Error, InterpreterResult, RuntimeErrorType}, - vm::eval_all, - vm::types::{OptionalData, PrincipalData, QualifiedContractIdentifier}, - vm::ClarityVersion, - vm::ContractContext, - vm::ContractName, - vm::{SymbolicExpression, SymbolicExpressionType, Value}, +use stacks_common::codec::StacksMessageCodec; +use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, VRFSeed, *, }; -use stacks_common::util::log; - -use crate::burnchains::PoxConstants; -use crate::burnchains::Txid; -use stacks_common::types::chainstate::*; +use stacks_common::util::hash::{bytes_to_hex, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::{get_epoch_time_ms, log}; +use crate::burnchains::{Address, PoxConstants, Txid}; use crate::chainstate::stacks::boot::{ BOOT_CODE_BNS, BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3, BOOT_CODE_COST_VOTING_MAINNET, BOOT_CODE_COST_VOTING_TESTNET, BOOT_CODE_GENESIS, BOOT_CODE_LOCKUP, BOOT_CODE_POX_MAINNET, BOOT_CODE_POX_TESTNET, POX_2_MAINNET_CODE, POX_2_TESTNET_CODE, }; - -use crate::util_lib::boot::{boot_code_addr, boot_code_id}; - -use crate::burnchains::Address; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::core::BLOCK_LIMIT_MAINNET_205; -use crate::core::HELIUM_BLOCK_LIMIT_20; - -use crate::util_lib::strings::StacksString; -use serde::Serialize; -use serde_json::json; - -use stacks_common::codec::StacksMessageCodec; - -use std::convert::TryFrom; - -use crate::clarity_vm::database::marf::MarfedKV; -use crate::clarity_vm::database::marf::WritableMarfStore; +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId}; +use crate::clarity::vm::analysis::contract_interface_builder::build_contract_interface; +use crate::clarity::vm::analysis::errors::{CheckError, CheckResult}; +use crate::clarity::vm::analysis::{AnalysisDatabase, ContractAnalysis}; +use crate::clarity::vm::ast::{build_ast_with_rules, ASTRules}; +use crate::clarity::vm::contexts::{AssetMap, GlobalContext, OwnedEnvironment}; +use crate::clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; +use crate::clarity::vm::database::{ + BurnStateDB, ClarityDatabase, HeadersDB, STXBalance, SqliteConnection, NULL_BURN_STATE_DB, +}; +use crate::clarity::vm::errors::{Error, InterpreterResult, RuntimeErrorType}; +use crate::clarity::vm::types::{OptionalData, PrincipalData, QualifiedContractIdentifier}; +use crate::clarity::vm::{ + analysis, ast, eval_all, ClarityVersion, ContractContext, ContractName, SymbolicExpression, + SymbolicExpressionType, Value, +}; +use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore}; use crate::clarity_vm::database::MemoryBackingStore; -use crate::core::StacksEpochId; -use stacks_common::consts::CHAIN_ID_MAINNET; -use stacks_common::consts::CHAIN_ID_TESTNET; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::VRFSeed; -use std::str::FromStr; +use crate::core::{StacksEpochId, BLOCK_LIMIT_MAINNET_205, HELIUM_BLOCK_LIMIT_20}; +use crate::util_lib::boot::{boot_code_addr, boot_code_id}; +use crate::util_lib::db::{sqlite_open, FromColumn}; +use crate::util_lib::strings::StacksString; lazy_static! { pub static ref STACKS_BOOT_CODE_MAINNET_2_1: [(&'static str, &'static str); 9] = [ diff --git a/stackslib/src/clarity_cli_main.rs b/stackslib/src/clarity_cli_main.rs index f983263cf..839006a47 100644 --- a/stackslib/src/clarity_cli_main.rs +++ b/stackslib/src/clarity_cli_main.rs @@ -23,10 +23,10 @@ extern crate blockstack_lib; extern crate serde_json; +use std::{env, process}; + use blockstack_lib::clarity_cli as clarity; use stacks_common::util::log; -use std::env; -use std::process; fn main() { let argv: Vec = env::args().collect(); diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs index f1cd91132..fce78929f 100644 --- a/stackslib/src/clarity_vm/clarity.rs +++ b/stackslib/src/clarity_vm/clarity.rs @@ -15,50 +15,14 @@ // along with this program. If not, see . use std::convert::TryFrom; -use std::error; -use std::fmt; -use std::thread; +use std::{error, fmt, thread}; -use crate::chainstate::stacks::boot::BOOT_CODE_COSTS_2_TESTNET; -use crate::chainstate::stacks::boot::POX_2_MAINNET_CODE; -use crate::chainstate::stacks::boot::POX_2_TESTNET_CODE; -use crate::chainstate::stacks::boot::POX_3_MAINNET_CODE; -use crate::chainstate::stacks::boot::POX_3_TESTNET_CODE; -use crate::chainstate::stacks::boot::{ - BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_3, - BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, COSTS_2_NAME, - COSTS_3_NAME, POX_2_NAME, POX_3_NAME, -}; -use crate::chainstate::stacks::db::StacksAccount; -use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt}; -use crate::chainstate::stacks::index::marf::MARF; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::chainstate::stacks::Error as ChainstateError; -use crate::chainstate::stacks::StacksMicroblockHeader; -use crate::chainstate::stacks::TransactionAuth; -use crate::chainstate::stacks::TransactionPayload; -use crate::chainstate::stacks::TransactionPublicKeyEncoding; -use crate::chainstate::stacks::TransactionSmartContract; -use crate::chainstate::stacks::TransactionSpendingCondition; -use crate::chainstate::stacks::TransactionVersion; -use crate::chainstate::stacks::{SinglesigHashMode, SinglesigSpendingCondition, StacksTransaction}; -use crate::core::StacksEpoch; -use crate::core::{FIRST_STACKS_BLOCK_ID, GENESIS_EPOCH}; -use crate::util_lib::boot::{boot_code_acc, boot_code_addr, boot_code_id, boot_code_tx_auth}; -use crate::util_lib::strings::StacksString; -use crate::{ - burnchains::Burnchain, - burnchains::PoxConstants, - clarity_vm::database::marf::{MarfedKV, WritableMarfStore}, -}; -use crate::{clarity_vm::database::marf::ReadOnlyMarfStore, core::StacksEpochId}; -use clarity::vm::analysis; -use clarity::vm::analysis::AnalysisDatabase; -use clarity::vm::analysis::{errors::CheckError, errors::CheckErrors, ContractAnalysis}; -use clarity::vm::ast; -use clarity::vm::ast::{errors::ParseError, errors::ParseErrors, ASTRules, ContractAST}; +use clarity::vm::analysis::errors::{CheckError, CheckErrors}; +use clarity::vm::analysis::{AnalysisDatabase, ContractAnalysis}; +use clarity::vm::ast::errors::{ParseError, ParseErrors}; +use clarity::vm::ast::{ASTRules, ContractAST}; +use clarity::vm::clarity::TransactionConnection; +pub use clarity::vm::clarity::{ClarityConnection, Error}; use clarity::vm::contexts::{AssetMap, Environment, OwnedEnvironment}; use clarity::vm::costs::{CostTracker, ExecutionCost, LimitedCostTracker}; use clarity::vm::database::{ @@ -71,22 +35,36 @@ use clarity::vm::types::{ AssetIdentifier, BuffData, OptionalData, PrincipalData, QualifiedContractIdentifier, TupleData, TypeSignature, Value, }; -use clarity::vm::ClarityVersion; -use clarity::vm::ContractName; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::SortitionId; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::TrieHash; - -use crate::util_lib::db::Error as DatabaseError; -pub use clarity::vm::clarity::ClarityConnection; -pub use clarity::vm::clarity::Error; -use clarity::vm::clarity::TransactionConnection; - +use clarity::vm::{analysis, ast, ClarityVersion, ContractName}; use stacks_common::consts::CHAIN_ID_TESTNET; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId, TrieHash, +}; use stacks_common::util::secp256k1::MessageSignature; +use crate::burnchains::{Burnchain, PoxConstants}; +use crate::chainstate::stacks::boot::{ + BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3, + BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, COSTS_2_NAME, + COSTS_3_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE, + POX_3_NAME, POX_3_TESTNET_CODE, +}; +use crate::chainstate::stacks::db::{StacksAccount, StacksChainState}; +use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt}; +use crate::chainstate::stacks::index::marf::MARF; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId}; +use crate::chainstate::stacks::{ + Error as ChainstateError, SinglesigHashMode, SinglesigSpendingCondition, + StacksMicroblockHeader, StacksTransaction, TransactionAuth, TransactionPayload, + TransactionPublicKeyEncoding, TransactionSmartContract, TransactionSpendingCondition, + TransactionVersion, +}; +use crate::clarity_vm::database::marf::{MarfedKV, ReadOnlyMarfStore, WritableMarfStore}; +use crate::core::{StacksEpoch, StacksEpochId, FIRST_STACKS_BLOCK_ID, GENESIS_EPOCH}; +use crate::util_lib::boot::{boot_code_acc, boot_code_addr, boot_code_id, boot_code_tx_auth}; +use crate::util_lib::db::Error as DatabaseError; +use crate::util_lib::strings::StacksString; + /// /// A high-level interface for interacting with the Clarity VM. /// @@ -1590,22 +1568,18 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> { mod tests { use std::fs; - use rusqlite::NO_PARAMS; - use clarity::vm::analysis::errors::CheckErrors; use clarity::vm::database::{ClarityBackingStore, STXBalance}; - use clarity::vm::types::{StandardPrincipalData, Value}; - - use crate::core::{PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05}; use clarity::vm::test_util::{TEST_BURN_STATE_DB, TEST_HEADER_DB}; - - use crate::chainstate::stacks::index::ClarityMarfTrieId; - use crate::clarity_vm::database::marf::MarfedKV; - + use clarity::vm::types::{StandardPrincipalData, Value}; + use rusqlite::NO_PARAMS; + use stacks_common::consts::CHAIN_ID_TESTNET; use stacks_common::types::chainstate::ConsensusHash; use super::*; - use stacks_common::consts::CHAIN_ID_TESTNET; + use crate::chainstate::stacks::index::ClarityMarfTrieId; + use crate::clarity_vm::database::marf::MarfedKV; + use crate::core::{PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05}; #[test] pub fn bad_syntax_test() { @@ -2262,11 +2236,12 @@ mod tests { #[test] pub fn test_post_condition_failure_contract_publish() { + use stacks_common::util::hash::Hash160; + use stacks_common::util::secp256k1::MessageSignature; + use crate::chainstate::stacks::db::*; use crate::chainstate::stacks::*; use crate::util_lib::strings::StacksString; - use stacks_common::util::hash::Hash160; - use stacks_common::util::secp256k1::MessageSignature; let marf = MarfedKV::temporary(); let mut clarity_instance = ClarityInstance::new(false, CHAIN_ID_TESTNET, marf); diff --git a/stackslib/src/clarity_vm/database/marf.rs b/stackslib/src/clarity_vm/database/marf.rs index fae04b349..c4c869d11 100644 --- a/stackslib/src/clarity_vm/database/marf.rs +++ b/stackslib/src/clarity_vm/database/marf.rs @@ -1,29 +1,26 @@ use std::path::PathBuf; use std::str::FromStr; -use rusqlite::Connection; - -use crate::chainstate::stacks::index::marf::{MARFOpenOpts, MarfConnection, MarfTransaction, MARF}; -use crate::chainstate::stacks::index::{Error, MarfTrieId}; -use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; -use crate::util_lib::db::IndexDBConn; use clarity::vm::analysis::AnalysisDatabase; use clarity::vm::database::{ - BurnStateDB, ClarityBackingStore, ClarityDatabase, HeadersDB, SqliteConnection, + BurnStateDB, ClarityBackingStore, ClarityDatabase, HeadersDB, SpecialCaseHandler, + SqliteConnection, }; use clarity::vm::errors::{ IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType, }; use clarity::vm::types::QualifiedContractIdentifier; - -use crate::chainstate::stacks::index::{ClarityMarfTrieId, MARFValue, TrieMerkleProof}; -use clarity::vm::database::SpecialCaseHandler; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::{StacksBlockId, TrieHash}; - -use crate::clarity_vm::special::handle_contract_call_special_cases; -use crate::util_lib::db::Error as DatabaseError; +use rusqlite::Connection; use stacks_common::codec::StacksMessageCodec; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, TrieHash}; + +use crate::chainstate::stacks::index::marf::{MARFOpenOpts, MarfConnection, MarfTransaction, MARF}; +use crate::chainstate::stacks::index::{ + ClarityMarfTrieId, Error, MARFValue, MarfTrieId, TrieMerkleProof, +}; +use crate::clarity_vm::special::handle_contract_call_special_cases; +use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; +use crate::util_lib::db::{Error as DatabaseError, IndexDBConn}; /// The MarfedKV struct is used to wrap a MARF data structure and side-storage /// for use as a K/V store for ClarityDB or the AnalysisDB. @@ -111,9 +108,10 @@ impl MarfedKV { // used by benchmarks pub fn temporary() -> MarfedKV { + use std::env; + use rand::Rng; use stacks_common::util::hash::to_hex; - use std::env; let mut path = PathBuf::from_str("/tmp/stacks-node-tests/unit-tests-marf").unwrap(); let random_bytes = rand::thread_rng().gen::<[u8; 32]>(); diff --git a/stackslib/src/clarity_vm/database/mod.rs b/stackslib/src/clarity_vm/database/mod.rs index 01351f5c7..4e19f5ef2 100644 --- a/stackslib/src/clarity_vm/database/mod.rs +++ b/stackslib/src/clarity_vm/database/mod.rs @@ -1,5 +1,19 @@ -use clarity::vm::types::PrincipalData; +use std::ops::{Deref, DerefMut}; + +use clarity::vm::analysis::AnalysisDatabase; +use clarity::vm::database::{ + BurnStateDB, ClarityBackingStore, ClarityDatabase, HeadersDB, SpecialCaseHandler, + SqliteConnection, NULL_BURN_STATE_DB, NULL_HEADER_DB, +}; +use clarity::vm::errors::{InterpreterResult, RuntimeErrorType}; +use clarity::vm::types::{PrincipalData, TupleData}; use rusqlite::{Connection, OptionalExtension, Row, ToSql}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksAddress, StacksBlockId, + VRFSeed, +}; +use stacks_common::types::Address; +use stacks_common::util::vrf::VRFProof; use crate::chainstate::burn::db::sortdb::{ get_ancestor_sort_id, get_ancestor_sort_id_tx, SortitionDB, SortitionDBConn, SortitionHandle, @@ -7,35 +21,15 @@ use crate::chainstate::burn::db::sortdb::{ }; use crate::chainstate::stacks::boot::PoxStartCycleInfo; use crate::chainstate::stacks::db::accounts::MinerReward; -use crate::chainstate::stacks::db::{MinerPaymentSchedule, StacksChainState, StacksHeaderInfo}; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::util_lib::db::FromColumn; -use crate::util_lib::db::{DBConn, FromRow}; -use clarity::vm::analysis::AnalysisDatabase; -use clarity::vm::database::{ - BurnStateDB, ClarityBackingStore, ClarityDatabase, HeadersDB, SqliteConnection, - NULL_BURN_STATE_DB, NULL_HEADER_DB, +use crate::chainstate::stacks::db::{ + ChainstateTx, MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, }; -use clarity::vm::errors::{InterpreterResult, RuntimeErrorType}; - -use crate::chainstate::stacks::db::ChainstateTx; use crate::chainstate::stacks::index::marf::{MarfConnection, MARF}; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, TrieMerkleProof}; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId, TrieMerkleProof}; use crate::chainstate::stacks::Error as ChainstateError; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId}; -use stacks_common::types::chainstate::{StacksAddress, VRFSeed}; -use stacks_common::util::vrf::VRFProof; - -use crate::core::StacksEpoch; -use crate::core::StacksEpochId; -use std::ops::{Deref, DerefMut}; - use crate::clarity_vm::special::handle_contract_call_special_cases; -use clarity::vm::database::SpecialCaseHandler; -use clarity::vm::types::TupleData; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::Address; +use crate::core::{StacksEpoch, StacksEpochId}; +use crate::util_lib::db::{DBConn, FromColumn, FromRow}; pub mod marf; diff --git a/stackslib/src/clarity_vm/tests/analysis_costs.rs b/stackslib/src/clarity_vm/tests/analysis_costs.rs index 1c98089b8..87e175929 100644 --- a/stackslib/src/clarity_vm/tests/analysis_costs.rs +++ b/stackslib/src/clarity_vm/tests/analysis_costs.rs @@ -14,14 +14,11 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::clarity_vm::clarity::ClarityInstance; -use crate::clarity_vm::tests::costs::get_simple_test; -use crate::clarity_vm::tests::simple_tests::with_marfed_environment; use clarity::vm::ast::ASTRules; use clarity::vm::clarity::TransactionConnection; -use clarity::vm::contexts::Environment; -use clarity::vm::contexts::{AssetMap, AssetMapEntry, GlobalContext, OwnedEnvironment}; +use clarity::vm::contexts::{ + AssetMap, AssetMapEntry, Environment, GlobalContext, OwnedEnvironment, +}; use clarity::vm::contracts::Contract; use clarity::vm::costs::ExecutionCost; use clarity::vm::database::{ClarityDatabase, NULL_BURN_STATE_DB, NULL_HEADER_DB}; @@ -29,20 +26,23 @@ use clarity::vm::errors::{CheckErrors, Error, RuntimeErrorType}; use clarity::vm::functions::NativeFunctions; use clarity::vm::representations::SymbolicExpression; use clarity::vm::test_util::{TEST_BURN_STATE_DB, TEST_HEADER_DB}; -use clarity::vm::tests::{execute, symbols_from_values, UnitTestBurnStateDB}; +use clarity::vm::tests::{ + execute, symbols_from_values, test_only_mainnet_to_chain_id, UnitTestBurnStateDB, +}; use clarity::vm::types::{ AssetIdentifier, PrincipalData, QualifiedContractIdentifier, ResponseData, Value, }; -use clarity::vm::{execute as vm_execute, ContractName}; -use stacks_common::util::hash::hex_bytes; - -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::clarity_vm::clarity::ClarityConnection; -use crate::clarity_vm::database::marf::MarfedKV; -use clarity::vm::tests::test_only_mainnet_to_chain_id; -use clarity::vm::ClarityVersion; +use clarity::vm::{execute as vm_execute, ClarityVersion, ContractName}; use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; use stacks_common::types::StacksEpochId; +use stacks_common::util::hash::hex_bytes; + +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::index::ClarityMarfTrieId; +use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance}; +use crate::clarity_vm::database::marf::MarfedKV; +use crate::clarity_vm::tests::costs::get_simple_test; +use crate::clarity_vm::tests::simple_tests::with_marfed_environment; fn setup_tracked_cost_test( use_mainnet: bool, diff --git a/stackslib/src/clarity_vm/tests/ast.rs b/stackslib/src/clarity_vm/tests/ast.rs index bc1cff12a..2074fa763 100644 --- a/stackslib/src/clarity_vm/tests/ast.rs +++ b/stackslib/src/clarity_vm/tests/ast.rs @@ -1,19 +1,19 @@ -use crate::clarity_vm::{clarity::ClarityInstance, database::marf::MarfedKV}; use clarity::vm::ast::build_ast; use clarity::vm::test_util::{TEST_BURN_STATE_DB, TEST_HEADER_DB}; -use clarity::vm::types::QualifiedContractIdentifier; -use stacks_common::types::chainstate::StacksBlockId; - -use crate::chainstate::stacks::index::ClarityMarfTrieId; use clarity::vm::tests::test_clarity_versions; +use clarity::vm::types::QualifiedContractIdentifier; use clarity::vm::version::ClarityVersion; -use stacks_common::consts::CHAIN_ID_TESTNET; -use stacks_common::types::StacksEpochId; - #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; +use stacks_common::consts::CHAIN_ID_TESTNET; +use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::StacksEpochId; + +use crate::chainstate::stacks::index::ClarityMarfTrieId; +use crate::clarity_vm::clarity::ClarityInstance; +use crate::clarity_vm::database::marf::MarfedKV; fn dependency_edge_counting_runtime( iters: usize, diff --git a/stackslib/src/clarity_vm/tests/contracts.rs b/stackslib/src/clarity_vm/tests/contracts.rs index e62c4a686..b9916dac1 100644 --- a/stackslib/src/clarity_vm/tests/contracts.rs +++ b/stackslib/src/clarity_vm/tests/contracts.rs @@ -14,51 +14,40 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::StacksBlockId; - -#[cfg(any(test, feature = "testing"))] -use rstest::rstest; -#[cfg(any(test, feature = "testing"))] -use rstest_reuse::{self, *}; - -use crate::chainstate::burn::BlockSnapshot; -use crate::clarity_vm::clarity::ClarityBlockConnection; -use clarity::vm::ast; use clarity::vm::ast::errors::ParseErrors; use clarity::vm::ast::ASTRules; use clarity::vm::clarity::Error as ClarityError; use clarity::vm::contexts::{Environment, GlobalContext, OwnedEnvironment}; use clarity::vm::contracts::Contract; use clarity::vm::costs::ExecutionCost; -use clarity::vm::database::ClarityDatabase; +use clarity::vm::database::{ClarityDatabase, MemoryBackingStore}; use clarity::vm::errors::{CheckErrors, Error, RuntimeErrorType}; -use clarity::vm::execute as vm_execute; use clarity::vm::representations::SymbolicExpression; use clarity::vm::tests::{ execute, is_committed, is_err_code_i128 as is_err_code, symbols_from_values, BurnStateDB, TEST_BURN_STATE_DB, TEST_HEADER_DB, }; +use clarity::vm::types::SequenceData::Buffer; use clarity::vm::types::{ - OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, - TypeSignature, Value, + BuffData, OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, + StandardPrincipalData, TypeSignature, Value, +}; +use clarity::vm::Value::Sequence; +use clarity::vm::{ast, execute as vm_execute, ClarityVersion}; +#[cfg(any(test, feature = "testing"))] +use rstest::rstest; +#[cfg(any(test, feature = "testing"))] +use rstest_reuse::{self, *}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksAddress, StacksBlockId, }; -use clarity::vm::ClarityVersion; -use stacks_common::types::chainstate::{ConsensusHash, SortitionId}; use stacks_common::types::StacksEpoch; use stacks_common::util::hash::hex_bytes; -use clarity::vm::types::BuffData; -use clarity::vm::types::SequenceData::Buffer; -use clarity::vm::Value::Sequence; - -use clarity::vm::database::MemoryBackingStore; - +use crate::chainstate::burn::BlockSnapshot; use crate::chainstate::stacks::boot::contract_tests::{test_sim_height_to_hash, ClarityTestSim}; -use crate::clarity::vm::clarity::ClarityConnection; -use crate::clarity::vm::clarity::TransactionConnection; +use crate::clarity::vm::clarity::{ClarityConnection, TransactionConnection}; +use crate::clarity_vm::clarity::ClarityBlockConnection; #[test] // Here, we set up a basic test to see if we can recover a path from the ClarityTestSim. diff --git a/stackslib/src/clarity_vm/tests/costs.rs b/stackslib/src/clarity_vm/tests/costs.rs index 1c387e01b..e07e06451 100644 --- a/stackslib/src/clarity_vm/tests/costs.rs +++ b/stackslib/src/clarity_vm/tests/costs.rs @@ -14,20 +14,17 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::clarity_vm::clarity::ClarityInstance; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; -use crate::util_lib::boot::boot_code_id; +use std::collections::HashMap; + use clarity::vm::ast::ASTRules; use clarity::vm::clarity::TransactionConnection; -use clarity::vm::contexts::Environment; -use clarity::vm::contexts::{AssetMap, AssetMapEntry, GlobalContext, OwnedEnvironment}; +use clarity::vm::contexts::{ + AssetMap, AssetMapEntry, Environment, GlobalContext, OwnedEnvironment, +}; use clarity::vm::contracts::Contract; use clarity::vm::costs::cost_functions::ClarityCostFunction; use clarity::vm::costs::{ClarityCostFunctionReference, ExecutionCost, LimitedCostTracker}; -use clarity::vm::database::ClarityDatabase; +use clarity::vm::database::{ClarityDatabase, MemoryBackingStore}; use clarity::vm::errors::{CheckErrors, Error, RuntimeErrorType}; use clarity::vm::events::StacksTransactionEvent; use clarity::vm::functions::NativeFunctions; @@ -36,21 +33,21 @@ use clarity::vm::test_util::{ execute, execute_on_network, symbols_from_values, TEST_BURN_STATE_DB, TEST_BURN_STATE_DB_21, TEST_HEADER_DB, }; +use clarity::vm::tests::test_only_mainnet_to_chain_id; use clarity::vm::types::{ AssetIdentifier, OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, Value, }; -use clarity::vm::ClarityVersion; -use clarity::vm::ContractName; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; +use clarity::vm::{ClarityVersion, ContractName}; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; use stacks_common::types::StacksEpochId; use stacks_common::util::hash::hex_bytes; -use std::collections::HashMap; - +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::index::ClarityMarfTrieId; +use crate::clarity_vm::clarity::ClarityInstance; use crate::clarity_vm::database::marf::MarfedKV; -use clarity::vm::database::MemoryBackingStore; -use clarity::vm::tests::test_only_mainnet_to_chain_id; +use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; +use crate::util_lib::boot::boot_code_id; lazy_static! { static ref COST_VOTING_MAINNET_CONTRACT: QualifiedContractIdentifier = diff --git a/stackslib/src/clarity_vm/tests/epoch_switch.rs b/stackslib/src/clarity_vm/tests/epoch_switch.rs index e443040ff..c6c630333 100644 --- a/stackslib/src/clarity_vm/tests/epoch_switch.rs +++ b/stackslib/src/clarity_vm/tests/epoch_switch.rs @@ -14,36 +14,32 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use rusqlite::{Connection, OptionalExtension}; - -use crate::chainstate::burn::db::sortdb::{ - SortitionDB, SortitionDBConn, SortitionHandleConn, SortitionHandleTx, -}; -use crate::chainstate::stacks::db::{MinerPaymentSchedule, StacksHeaderInfo}; -use crate::chainstate::stacks::index::MarfTrieId; -use crate::util_lib::db::{DBConn, FromRow}; use clarity::vm::analysis::AnalysisDatabase; +use clarity::vm::costs::ExecutionCost; use clarity::vm::database::{ BurnStateDB, ClarityBackingStore, ClarityDatabase, HeadersDB, SqliteConnection, NULL_BURN_STATE_DB, NULL_HEADER_DB, }; use clarity::vm::errors::{InterpreterResult, RuntimeErrorType}; use clarity::vm::test_util::{TEST_BURN_STATE_DB, TEST_HEADER_DB}; +use rand::{thread_rng, RngCore}; +use rusqlite::{Connection, OptionalExtension}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, VRFSeed, +}; +use stacks_common::util::hash::to_hex; use crate::burnchains::PoxConstants; -use crate::chainstate::stacks::index::{ClarityMarfTrieId, TrieMerkleProof}; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId}; -use stacks_common::types::chainstate::{StacksAddress, VRFSeed}; - -use crate::core::{StacksEpoch, StacksEpochId, STACKS_EPOCH_MAX}; -use crate::core::{PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05}; - -use rand::thread_rng; -use rand::RngCore; - -use clarity::vm::costs::ExecutionCost; -use stacks_common::util::hash::to_hex; +use crate::chainstate::burn::db::sortdb::{ + SortitionDB, SortitionDBConn, SortitionHandleConn, SortitionHandleTx, +}; +use crate::chainstate::stacks::db::{MinerPaymentSchedule, StacksHeaderInfo}; +use crate::chainstate::stacks::index::{ClarityMarfTrieId, MarfTrieId, TrieMerkleProof}; +use crate::core::{ + StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, + PEER_VERSION_EPOCH_2_05, STACKS_EPOCH_MAX, +}; +use crate::util_lib::db::{DBConn, FromRow}; fn test_burnstatedb_epoch( burnstatedb: &dyn BurnStateDB, diff --git a/stackslib/src/clarity_vm/tests/events.rs b/stackslib/src/clarity_vm/tests/events.rs index d5343eb0a..ef3c1f59e 100644 --- a/stackslib/src/clarity_vm/tests/events.rs +++ b/stackslib/src/clarity_vm/tests/events.rs @@ -14,28 +14,24 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::stacks::StacksBlockHeader; -use crate::clarity_vm::clarity::ClarityInstance; -use crate::clarity_vm::database::marf::MarfedKV; - -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; +use clarity::vm::ast::ASTRules; use clarity::vm::contexts::OwnedEnvironment; use clarity::vm::costs::ExecutionCost; +use clarity::vm::database::MemoryBackingStore; use clarity::vm::events::*; -use clarity::vm::tests::execute; -use clarity::vm::tests::{TEST_BURN_STATE_DB, TEST_HEADER_DB}; +use clarity::vm::tests::{ + execute, test_only_mainnet_to_chain_id, TEST_BURN_STATE_DB, TEST_HEADER_DB, +}; use clarity::vm::types::{AssetIdentifier, BuffData, QualifiedContractIdentifier, Value}; - +use clarity::vm::{ClarityVersion, ContractContext}; use stacks_common::types::chainstate::StacksBlockId; use stacks_common::types::StacksEpochId; -use clarity::vm::ast::ASTRules; -use clarity::vm::database::MemoryBackingStore; - -use clarity::vm::tests::test_only_mainnet_to_chain_id; -use clarity::vm::ClarityVersion; -use clarity::vm::ContractContext; +use crate::chainstate::stacks::index::ClarityMarfTrieId; +use crate::chainstate::stacks::StacksBlockHeader; +use crate::clarity_vm::clarity::ClarityInstance; +use crate::clarity_vm::database::marf::MarfedKV; +use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; fn helper_execute(contract: &str, method: &str) -> (Value, Vec) { helper_execute_epoch(contract, method, None, StacksEpochId::Epoch21, false) diff --git a/stackslib/src/clarity_vm/tests/forking.rs b/stackslib/src/clarity_vm/tests/forking.rs index 7545d9998..b56472a56 100644 --- a/stackslib/src/clarity_vm/tests/forking.rs +++ b/stackslib/src/clarity_vm/tests/forking.rs @@ -14,8 +14,6 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::stacks::index::storage::TrieFileStorage; -use crate::chainstate::stacks::index::ClarityMarfTrieId; use clarity::vm::analysis::errors::CheckErrors; use clarity::vm::ast::ASTRules; use clarity::vm::contexts::OwnedEnvironment; @@ -25,16 +23,16 @@ use clarity::vm::representations::SymbolicExpression; use clarity::vm::test_util::{ execute, is_committed, is_err_code, symbols_from_values, TEST_BURN_STATE_DB, TEST_HEADER_DB, }; -use clarity::vm::types::Value; -use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::tests::test_clarity_versions; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, Value}; use clarity::vm::version::ClarityVersion; use clarity::vm::ContractContext; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; use stacks_common::types::StacksEpochId; +use crate::chainstate::stacks::index::storage::TrieFileStorage; +use crate::chainstate::stacks::index::ClarityMarfTrieId; use crate::clarity_vm::database::marf::MarfedKV; -use clarity::vm::tests::test_clarity_versions; const p1_str: &str = "'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"; diff --git a/stackslib/src/clarity_vm/tests/large_contract.rs b/stackslib/src/clarity_vm/tests/large_contract.rs index e31d8db51..9a626e8b0 100644 --- a/stackslib/src/clarity_vm/tests/large_contract.rs +++ b/stackslib/src/clarity_vm/tests/large_contract.rs @@ -14,46 +14,38 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::chainstate::stacks::index::ClarityMarfTrieId; -use crate::clarity_vm::clarity::{ClarityInstance, Error as ClarityError}; -#[cfg(test)] -use rstest::rstest; -#[cfg(test)] -use rstest_reuse::{self, *}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; - use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; use clarity::vm::ast::{self, ASTRules}; +use clarity::vm::clarity::{ClarityConnection, TransactionConnection}; use clarity::vm::contexts::{Environment, GlobalContext, OwnedEnvironment}; use clarity::vm::contracts::Contract; use clarity::vm::costs::ExecutionCost; use clarity::vm::database::ClarityDatabase; -use clarity::vm::errors::Error as InterpreterError; -use clarity::vm::errors::{CheckErrors, Error, RuntimeErrorType}; +use clarity::vm::errors::{CheckErrors, Error as InterpreterError, Error, RuntimeErrorType}; use clarity::vm::representations::SymbolicExpression; use clarity::vm::test_util::*; +use clarity::vm::tests::test_clarity_versions; use clarity::vm::types::{ OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, TypeSignature, Value, }; -use clarity::vm::ContractContext; -use clarity::vm::MAX_CALL_STACK_DEPTH; +use clarity::vm::version::ClarityVersion; +use clarity::vm::{ContractContext, MAX_CALL_STACK_DEPTH}; +#[cfg(test)] +use rstest::rstest; +#[cfg(test)] +use rstest_reuse::{self, *}; +use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; +use stacks_common::types::StacksEpochId; use stacks_common::util::hash::hex_bytes; +use crate::chainstate::stacks::boot::{BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_3}; +use crate::chainstate::stacks::index::ClarityMarfTrieId; +use crate::clarity_vm::clarity::{ClarityInstance, Error as ClarityError}; use crate::clarity_vm::database::marf::MarfedKV; use crate::clarity_vm::database::MemoryBackingStore; -use clarity::vm::clarity::ClarityConnection; -use clarity::vm::clarity::TransactionConnection; - -use clarity::vm::version::ClarityVersion; - -use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET}; -use stacks_common::types::StacksEpochId; - -use crate::chainstate::stacks::boot::{BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_3}; use crate::util_lib::boot::boot_code_id; -use clarity::vm::tests::test_clarity_versions; fn test_block_headers(n: u8) -> StacksBlockId { StacksBlockId([n as u8; 32]) diff --git a/stackslib/src/clarity_vm/tests/simple_tests.rs b/stackslib/src/clarity_vm/tests/simple_tests.rs index 0365f6965..0367bd844 100644 --- a/stackslib/src/clarity_vm/tests/simple_tests.rs +++ b/stackslib/src/clarity_vm/tests/simple_tests.rs @@ -3,8 +3,7 @@ use clarity::vm::errors::{Error, RuntimeErrorType}; use clarity::vm::test_util::{TEST_BURN_STATE_DB, TEST_HEADER_DB}; use clarity::vm::types::QualifiedContractIdentifier; use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; use stacks_common::types::StacksEpochId; use crate::chainstate::stacks::index::ClarityMarfTrieId; diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs index 9d99238b3..780e8b70f 100644 --- a/stackslib/src/core/mempool.rs +++ b/stackslib/src/core/mempool.rs @@ -19,76 +19,51 @@ use std::collections::{HashMap, HashSet, VecDeque}; use std::fs; use std::hash::Hasher; use std::io::{Read, Write}; -use std::ops::Deref; -use std::ops::DerefMut; +use std::ops::{Deref, DerefMut}; use std::path::{Path, PathBuf}; +use std::time::Instant; +use clarity::vm::types::PrincipalData; use rand::distributions::Uniform; use rand::prelude::Distribution; use rusqlite::types::ToSql; -use rusqlite::Connection; -use rusqlite::Error as SqliteError; -use rusqlite::OpenFlags; -use rusqlite::OptionalExtension; -use rusqlite::Row; -use rusqlite::Rows; -use rusqlite::Transaction; -use rusqlite::NO_PARAMS; - +use rusqlite::{ + Connection, Error as SqliteError, OpenFlags, OptionalExtension, Row, Rows, Transaction, + NO_PARAMS, +}; use siphasher::sip::SipHasher; // this is SipHash-2-4 +use stacks_common::codec::{Error as codec_error, StacksMessageCodec}; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId}; +use stacks_common::util::hash::{to_hex, Sha512Trunc256Sum}; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs}; use crate::burnchains::Txid; use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::db::blocks::MemPoolRejection; +use crate::chainstate::stacks::db::{ClarityTx, StacksChainState}; +use crate::chainstate::stacks::events::StacksTransactionReceipt; +use crate::chainstate::stacks::index::Error as MarfError; +use crate::chainstate::stacks::miner::TransactionEvent; use crate::chainstate::stacks::{ - db::blocks::MemPoolRejection, db::ClarityTx, db::StacksChainState, index::Error as MarfError, - Error as ChainstateError, StacksTransaction, + Error as ChainstateError, StacksBlock, StacksMicroblock, StacksTransaction, TransactionPayload, }; -use crate::chainstate::stacks::{StacksMicroblock, TransactionPayload}; -use crate::core::ExecutionCost; -use crate::core::StacksEpochId; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; +use crate::clarity_vm::clarity::ClarityConnection; +use crate::core::{ + ExecutionCost, StacksEpochId, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, +}; +use crate::cost_estimates::metrics::{CostMetric, UnitMetric}; +use crate::cost_estimates::{CostEstimator, EstimatorError, UnitEstimator}; use crate::monitoring::increment_stx_mempool_gc; use crate::net::stream::TxStreamData; -use crate::util_lib::db::query_int; -use crate::util_lib::db::query_row_columns; -use crate::util_lib::db::query_rows; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::tx_busy_handler; -use crate::util_lib::db::u64_to_sql; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::FromColumn; -use crate::util_lib::db::{query_row, Error}; -use crate::util_lib::db::{sql_pragma, DBConn, DBTx, FromRow}; -use clarity::vm::types::PrincipalData; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Sha512Trunc256Sum; -use std::time::Instant; - use crate::net::MemPoolSyncData; - use crate::util_lib::bloom::{BloomCounter, BloomFilter, BloomNodeHasher}; - -use crate::clarity_vm::clarity::ClarityConnection; - -use crate::chainstate::stacks::events::StacksTransactionReceipt; -use crate::chainstate::stacks::miner::TransactionEvent; -use crate::chainstate::stacks::StacksBlock; -use crate::cost_estimates; -use crate::cost_estimates::metrics::CostMetric; -use crate::cost_estimates::metrics::UnitMetric; -use crate::cost_estimates::CostEstimator; -use crate::cost_estimates::EstimatorError; -use crate::cost_estimates::UnitEstimator; -use crate::monitoring; -use crate::util_lib::db::table_exists; -use stacks_common::codec::Error as codec_error; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId}; +use crate::util_lib::db::{ + query_int, query_row, query_row_columns, query_rows, sql_pragma, sqlite_open, table_exists, + tx_begin_immediate, tx_busy_handler, u64_to_sql, DBConn, DBTx, Error as db_error, Error, + FromColumn, FromRow, +}; +use crate::{cost_estimates, monitoring}; // maximum number of confirmations a transaction can have before it's garbage-collected pub const MEMPOOL_MAX_TRANSACTION_AGE: u64 = 256; diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs index 17cda2217..b09ee9f2c 100644 --- a/stackslib/src/core/mod.rs +++ b/stackslib/src/core/mod.rs @@ -14,27 +14,24 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::burnchains::Burnchain; -use crate::burnchains::Error as burnchain_error; -use crate::chainstate::burn::ConsensusHash; -use clarity::vm::costs::ExecutionCost; -use stacks_common::util::log; use std::collections::HashSet; use std::convert::TryFrom; -pub use self::mempool::MemPoolDB; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; +use clarity::vm::costs::ExecutionCost; +use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksBlockId}; use stacks_common::types::StacksEpoch as GenericStacksEpoch; pub use stacks_common::types::StacksEpochId; +use stacks_common::util::log; + +pub use self::mempool::MemPoolDB; +use crate::burnchains::{Burnchain, Error as burnchain_error}; +use crate::chainstate::burn::ConsensusHash; pub mod mempool; #[cfg(test)] pub mod tests; -use std::cmp::Ord; -use std::cmp::Ordering; -use std::cmp::PartialOrd; +use std::cmp::{Ord, Ordering, PartialOrd}; pub type StacksEpoch = GenericStacksEpoch; diff --git a/stackslib/src/core/tests/mod.rs b/stackslib/src/core/tests/mod.rs index 366c2e545..88da0d86f 100644 --- a/stackslib/src/core/tests/mod.rs +++ b/stackslib/src/core/tests/mod.rs @@ -14,78 +14,60 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; -use std::collections::HashMap; -use std::collections::HashSet; -use std::io; +use std::collections::{HashMap, HashSet}; +use std::{cmp, io}; -use crate::burnchains::Address; -use crate::burnchains::Txid; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::database::HeadersDB; +use clarity::vm::errors::{Error as ClarityError, RuntimeErrorType}; +use clarity::vm::test_util::TEST_BURN_STATE_DB; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StacksAddressExtensions}; +use clarity::vm::{ClarityName, ContractName, Value}; +use rand::prelude::*; +use rand::thread_rng; +use stacks_common::address::AddressHashMode; +use stacks_common::codec::{read_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksWorkScore, TrieHash, + VRFSeed, +}; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, *}; +use stacks_common::util::secp256k1::{MessageSignature, *}; +use stacks_common::util::vrf::VRFProof; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log, sleep_ms}; + +use super::MemPoolDB; +use crate::burnchains::{Address, Txid}; use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::db::test::chainstate_path; -use crate::chainstate::stacks::db::test::instantiate_chainstate; -use crate::chainstate::stacks::db::test::instantiate_chainstate_with_balances; +use crate::chainstate::stacks::db::blocks::MemPoolRejection; +use crate::chainstate::stacks::db::test::{ + chainstate_path, instantiate_chainstate, instantiate_chainstate_with_balances, +}; +use crate::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo}; use crate::chainstate::stacks::events::StacksTransactionReceipt; +use crate::chainstate::stacks::index::{MarfTrieId, TrieHashExtension}; use crate::chainstate::stacks::miner::TransactionResult; use crate::chainstate::stacks::test::codec_all_transactions; use crate::chainstate::stacks::{ - db::blocks::MemPoolRejection, db::StacksChainState, index::MarfTrieId, CoinbasePayload, - Error as ChainstateError, SinglesigHashMode, SinglesigSpendingCondition, StacksPrivateKey, - StacksPublicKey, StacksTransaction, StacksTransactionSigner, TokenTransferMemo, - TransactionAnchorMode, TransactionAuth, TransactionContractCall, TransactionPayload, - TransactionPostConditionMode, TransactionPublicKeyEncoding, TransactionSmartContract, - TransactionSpendingCondition, TransactionVersion, + CoinbasePayload, Error as ChainstateError, SinglesigHashMode, SinglesigSpendingCondition, + StacksBlockHeader, StacksMicroblockHeader, StacksPrivateKey, StacksPublicKey, + StacksTransaction, StacksTransactionSigner, TokenTransferMemo, TransactionAnchorMode, + TransactionAuth, TransactionContractCall, TransactionPayload, TransactionPostConditionMode, + TransactionPublicKeyEncoding, TransactionSmartContract, TransactionSpendingCondition, + TransactionVersion, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, + C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; -use crate::chainstate::stacks::{ - C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, +use crate::core::mempool::{ + db_get_all_nonces, MemPoolWalkSettings, TxTag, BLOOM_COUNTER_DEPTH, BLOOM_COUNTER_ERROR_RATE, + MAX_BLOOM_COUNTER_TXS, }; -use crate::core::mempool::db_get_all_nonces; -use crate::core::mempool::MemPoolWalkSettings; -use crate::core::mempool::TxTag; -use crate::core::mempool::{BLOOM_COUNTER_DEPTH, BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS}; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; +use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH}; use crate::net::stream::StreamCursor; -use crate::net::Error as NetError; -use crate::net::HttpResponseType; -use crate::net::MemPoolSyncData; +use crate::net::{Error as NetError, HttpResponseType, MemPoolSyncData}; use crate::util_lib::bloom::test::setup_bloom_counter; use crate::util_lib::bloom::*; use crate::util_lib::db::{tx_begin_immediate, DBConn, FromRow}; use crate::util_lib::strings::StacksString; -use clarity::vm::{ - database::HeadersDB, - errors::Error as ClarityError, - errors::RuntimeErrorType, - test_util::TEST_BURN_STATE_DB, - types::{PrincipalData, QualifiedContractIdentifier}, - ClarityName, ContractName, Value, -}; -use stacks_common::address::AddressHashMode; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::util::hash::Hash160; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::sleep_ms; -use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs}; -use stacks_common::util::{hash::hex_bytes, hash::to_hex, hash::*, log, secp256k1::*}; - -use crate::chainstate::stacks::db::StacksHeaderInfo; -use crate::chainstate::stacks::index::TrieHashExtension; -use crate::chainstate::stacks::{StacksBlockHeader, StacksMicroblockHeader}; -use clarity::vm::costs::ExecutionCost; -use clarity::vm::types::StacksAddressExtensions; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; -use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, StacksWorkScore, VRFSeed}; -use stacks_common::util::vrf::VRFProof; - -use super::MemPoolDB; - -use rand::prelude::*; -use rand::thread_rng; - -use stacks_common::codec::read_next; -use stacks_common::codec::Error as codec_error; const FOO_CONTRACT: &'static str = "(define-public (foo) (ok 1)) (define-public (bar (x uint)) (ok x))"; diff --git a/stackslib/src/cost_estimates/fee_medians.rs b/stackslib/src/cost_estimates/fee_medians.rs index ac7e03220..7e1a2459b 100644 --- a/stackslib/src/cost_estimates/fee_medians.rs +++ b/stackslib/src/cost_estimates/fee_medians.rs @@ -1,33 +1,27 @@ use std::cmp; use std::cmp::Ordering; use std::convert::TryFrom; -use std::{iter::FromIterator, path::Path}; +use std::iter::FromIterator; +use std::path::Path; -use rusqlite::AndThenRows; -use rusqlite::Transaction as SqlTransaction; +use clarity::vm::costs::ExecutionCost; +use rusqlite::types::{FromSql, FromSqlError}; use rusqlite::{ - types::{FromSql, FromSqlError}, - Connection, Error as SqliteError, OptionalExtension, ToSql, + AndThenRows, Connection, Error as SqliteError, OptionalExtension, ToSql, + Transaction as SqlTransaction, }; use serde_json::Value as JsonValue; +use super::metrics::{CostMetric, PROPORTION_RESOLUTION}; +use super::{EstimatorError, FeeEstimator, FeeRateEstimate}; +use crate::chainstate::stacks::db::StacksEpochReceipt; +use crate::chainstate::stacks::events::TransactionOrigin; use crate::chainstate::stacks::TransactionPayload; +use crate::cost_estimates::StacksTransactionReceipt; use crate::util_lib::db::{ sql_pragma, sqlite_open, table_exists, tx_begin_immediate_sqlite, u64_to_sql, }; -use clarity::vm::costs::ExecutionCost; - -use crate::chainstate::stacks::db::StacksEpochReceipt; -use crate::chainstate::stacks::events::TransactionOrigin; - -use super::metrics::CostMetric; -use super::FeeRateEstimate; -use super::{EstimatorError, FeeEstimator}; - -use super::metrics::PROPORTION_RESOLUTION; -use crate::cost_estimates::StacksTransactionReceipt; - const CREATE_TABLE: &'static str = " CREATE TABLE median_fee_estimator ( measure_key INTEGER PRIMARY KEY AUTOINCREMENT, diff --git a/stackslib/src/cost_estimates/fee_rate_fuzzer.rs b/stackslib/src/cost_estimates/fee_rate_fuzzer.rs index c2534aa2f..852c52454 100644 --- a/stackslib/src/cost_estimates/fee_rate_fuzzer.rs +++ b/stackslib/src/cost_estimates/fee_rate_fuzzer.rs @@ -1,13 +1,10 @@ use clarity::vm::costs::ExecutionCost; - -use super::FeeRateEstimate; -use super::{EstimatorError, FeeEstimator}; -use crate::chainstate::stacks::db::StacksEpochReceipt; use rand::distributions::{Distribution, Uniform}; use rand::rngs::StdRng; -use rand::thread_rng; -use rand::RngCore; -use rand::SeedableRng; +use rand::{thread_rng, RngCore, SeedableRng}; + +use super::{EstimatorError, FeeEstimator, FeeRateEstimate}; +use crate::chainstate::stacks::db::StacksEpochReceipt; /// The FeeRateFuzzer wraps an underlying FeeEstimator. It passes `notify_block` calls to the /// underlying estimator. On `get_rate_estimates` calls, it adds a random fuzz to the result coming diff --git a/stackslib/src/cost_estimates/fee_scalar.rs b/stackslib/src/cost_estimates/fee_scalar.rs index ca252940c..14c447145 100644 --- a/stackslib/src/cost_estimates/fee_scalar.rs +++ b/stackslib/src/cost_estimates/fee_scalar.rs @@ -1,30 +1,23 @@ use std::cmp; use std::convert::TryFrom; -use std::{iter::FromIterator, path::Path}; +use std::iter::FromIterator; +use std::path::Path; -use rusqlite::Transaction as SqlTransaction; +use clarity::vm::costs::ExecutionCost; +use rusqlite::types::{FromSql, FromSqlError}; use rusqlite::{ - types::{FromSql, FromSqlError}, - Connection, Error as SqliteError, OptionalExtension, ToSql, + Connection, Error as SqliteError, OptionalExtension, ToSql, Transaction as SqlTransaction, }; use serde_json::Value as JsonValue; -use crate::chainstate::stacks::TransactionPayload; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate_sqlite; -use crate::util_lib::db::u64_to_sql; - -use clarity::vm::costs::ExecutionCost; - +use super::metrics::CostMetric; +use super::{EstimatorError, FeeEstimator, FeeRateEstimate}; use crate::chainstate::stacks::db::StacksEpochReceipt; use crate::chainstate::stacks::events::TransactionOrigin; - -use crate::util_lib::db::sql_pragma; -use crate::util_lib::db::table_exists; - -use super::metrics::CostMetric; -use super::FeeRateEstimate; -use super::{EstimatorError, FeeEstimator}; +use crate::chainstate::stacks::TransactionPayload; +use crate::util_lib::db::{ + sql_pragma, sqlite_open, table_exists, tx_begin_immediate_sqlite, u64_to_sql, +}; const SINGLETON_ROW_ID: i64 = 1; const CREATE_TABLE: &'static str = " diff --git a/stackslib/src/cost_estimates/mod.rs b/stackslib/src/cost_estimates/mod.rs index 475bbab0d..f50e2db41 100644 --- a/stackslib/src/cost_estimates/mod.rs +++ b/stackslib/src/cost_estimates/mod.rs @@ -1,17 +1,18 @@ use std::cmp; use std::collections::HashMap; +use std::error::Error; +use std::fmt::Display; use std::iter::FromIterator; use std::ops::{Add, Div, Mul, Rem, Sub}; use std::path::Path; -use std::{error::Error, fmt::Display}; -use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOrigin}; -use crate::chainstate::stacks::{StacksBlock, TransactionPayload}; use clarity::vm::costs::ExecutionCost; use rusqlite::Error as SqliteError; use crate::burnchains::Txid; use crate::chainstate::stacks::db::StacksEpochReceipt; +use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOrigin}; +use crate::chainstate::stacks::{StacksBlock, TransactionPayload}; pub mod fee_medians; pub mod fee_rate_fuzzer; @@ -22,11 +23,10 @@ pub mod pessimistic; #[cfg(test)] pub mod tests; -use crate::chainstate::stacks::StacksTransaction; -use crate::core::StacksEpochId; - use self::metrics::CostMetric; pub use self::pessimistic::PessimisticEstimator; +use crate::chainstate::stacks::StacksTransaction; +use crate::core::StacksEpochId; /// This trait is for implementation of *fee rate* estimation: estimators should /// track the actual paid fee rate for transactions in blocks, and use that to diff --git a/stackslib/src/cost_estimates/pessimistic.rs b/stackslib/src/cost_estimates/pessimistic.rs index fffe05d7a..bd76d9f4a 100644 --- a/stackslib/src/cost_estimates/pessimistic.rs +++ b/stackslib/src/cost_estimates/pessimistic.rs @@ -1,25 +1,22 @@ use std::cmp; use std::convert::TryFrom; -use std::{iter::FromIterator, path::Path}; +use std::iter::FromIterator; +use std::path::Path; -use super::metrics::PROPORTION_RESOLUTION; +use clarity::vm::costs::ExecutionCost; +use rusqlite::types::{FromSql, FromSqlError}; use rusqlite::{ - types::{FromSql, FromSqlError}, Connection, Error as SqliteError, OptionalExtension, ToSql, Transaction as SqliteTransaction, }; use serde_json::Value as JsonValue; -use crate::chainstate::stacks::TransactionPayload; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::u64_to_sql; -use clarity::vm::costs::ExecutionCost; - -use crate::util_lib::db::sql_pragma; -use crate::util_lib::db::table_exists; -use crate::util_lib::db::tx_begin_immediate_sqlite; - +use super::metrics::PROPORTION_RESOLUTION; use super::{CostEstimator, EstimatorError}; +use crate::chainstate::stacks::TransactionPayload; use crate::core::StacksEpochId; +use crate::util_lib::db::{ + sql_pragma, sqlite_open, table_exists, tx_begin_immediate_sqlite, u64_to_sql, +}; /// This struct pessimistically estimates the `ExecutionCost` of transaction payloads. /// diff --git a/stackslib/src/cost_estimates/tests/common.rs b/stackslib/src/cost_estimates/tests/common.rs index 882de6fb6..b290c6d00 100644 --- a/stackslib/src/cost_estimates/tests/common.rs +++ b/stackslib/src/cost_estimates/tests/common.rs @@ -1,12 +1,13 @@ -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::db::{StacksEpochReceipt, StacksHeaderInfo}; -use crate::chainstate::stacks::events::StacksTransactionReceipt; use clarity::vm::costs::ExecutionCost; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksWorkScore}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksWorkScore, TrieHash, +}; use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; use stacks_common::util::vrf::VRFProof; +use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::db::{StacksEpochReceipt, StacksHeaderInfo}; +use crate::chainstate::stacks::events::StacksTransactionReceipt; use crate::chainstate::stacks::{ CoinbasePayload, StacksBlockHeader, StacksTransaction, TokenTransferMemo, TransactionAuth, TransactionContractCall, TransactionPayload, TransactionSpendingCondition, TransactionVersion, diff --git a/stackslib/src/cost_estimates/tests/cost_estimators.rs b/stackslib/src/cost_estimates/tests/cost_estimators.rs index 4016507a5..eccaaba70 100644 --- a/stackslib/src/cost_estimates/tests/cost_estimators.rs +++ b/stackslib/src/cost_estimates/tests/cost_estimators.rs @@ -1,37 +1,32 @@ -use std::{env, path::PathBuf}; -use time::Instant; +use std::env; +use std::path::PathBuf; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::types::{PrincipalData, StandardPrincipalData}; +use clarity::vm::Value; use rand::seq::SliceRandom; use rand::Rng; - -use crate::cost_estimates::metrics::CostMetric; -use crate::cost_estimates::{EstimatorError, FeeEstimator}; -use clarity::vm::costs::ExecutionCost; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksWorkScore, TrieHash, +}; +use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::vrf::VRFProof; +use time::Instant; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::{StacksEpochReceipt, StacksHeaderInfo}; use crate::chainstate::stacks::events::StacksTransactionReceipt; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksWorkScore}; - -use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; -use stacks_common::util::vrf::VRFProof; - -use crate::chainstate::stacks::StacksBlockHeader; use crate::chainstate::stacks::{ - CoinbasePayload, StacksTransaction, TokenTransferMemo, TransactionAuth, + CoinbasePayload, StacksBlockHeader, StacksTransaction, TokenTransferMemo, TransactionAuth, TransactionContractCall, TransactionPayload, TransactionSpendingCondition, TransactionVersion, }; -use crate::core::StacksEpochId; -use crate::core::BLOCK_LIMIT_MAINNET_20; +use crate::core::{StacksEpochId, BLOCK_LIMIT_MAINNET_20}; use crate::cost_estimates::fee_scalar::ScalarFeeRateEstimator; +use crate::cost_estimates::metrics::CostMetric; use crate::cost_estimates::tests::common::*; -use crate::cost_estimates::CostEstimator; -use crate::cost_estimates::FeeRateEstimate; -use crate::cost_estimates::PessimisticEstimator; -use clarity::vm::types::{PrincipalData, StandardPrincipalData}; -use clarity::vm::Value; +use crate::cost_estimates::{ + CostEstimator, EstimatorError, FeeEstimator, FeeRateEstimate, PessimisticEstimator, +}; fn instantiate_test_db() -> PessimisticEstimator { let mut path = env::temp_dir(); diff --git a/stackslib/src/cost_estimates/tests/fee_medians.rs b/stackslib/src/cost_estimates/tests/fee_medians.rs index 429311a47..0b85650f8 100644 --- a/stackslib/src/cost_estimates/tests/fee_medians.rs +++ b/stackslib/src/cost_estimates/tests/fee_medians.rs @@ -1,32 +1,29 @@ use std::env; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::types::{PrincipalData, StandardPrincipalData}; +use clarity::vm::Value; use rand::seq::SliceRandom; use rand::Rng; - -use crate::cost_estimates::metrics::CostMetric; -use crate::cost_estimates::{EstimatorError, FeeEstimator}; -use clarity::vm::costs::ExecutionCost; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksWorkScore, +}; +use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::{StacksEpochReceipt, StacksHeaderInfo}; use crate::chainstate::stacks::events::StacksTransactionReceipt; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksWorkScore}; -use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; - use crate::chainstate::stacks::{ CoinbasePayload, StacksBlockHeader, StacksTransaction, TokenTransferMemo, TransactionAuth, TransactionContractCall, TransactionPayload, TransactionSpendingCondition, TransactionVersion, }; use crate::core::StacksEpochId; -use crate::cost_estimates::fee_medians::fee_rate_estimate_from_sorted_weighted_fees; -use crate::cost_estimates::fee_medians::FeeRateAndWeight; -use crate::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator; -use crate::cost_estimates::metrics::ProportionalDotProduct; +use crate::cost_estimates::fee_medians::{ + fee_rate_estimate_from_sorted_weighted_fees, FeeRateAndWeight, WeightedMedianFeeRateEstimator, +}; +use crate::cost_estimates::metrics::{CostMetric, ProportionalDotProduct}; use crate::cost_estimates::tests::common::*; -use crate::cost_estimates::FeeRateEstimate; -use clarity::vm::types::{PrincipalData, StandardPrincipalData}; -use clarity::vm::Value; -use stacks_common::types::chainstate::StacksAddress; +use crate::cost_estimates::{EstimatorError, FeeEstimator, FeeRateEstimate}; /// Returns true iff `b` is within `0.1%` of `a`. fn is_close_f64(a: f64, b: f64) -> bool { diff --git a/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs b/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs index 4319f3332..1a1d953b2 100644 --- a/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs +++ b/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs @@ -1,24 +1,19 @@ -use crate::cost_estimates::{EstimatorError, FeeEstimator}; use clarity::vm::costs::ExecutionCost; +use rand::rngs::StdRng; +use rand::{thread_rng, RngCore, SeedableRng}; +use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::{StacksEpochReceipt, StacksHeaderInfo}; use crate::chainstate::stacks::events::StacksTransactionReceipt; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; - use crate::chainstate::stacks::{ CoinbasePayload, StacksTransaction, TokenTransferMemo, TransactionAuth, TransactionContractCall, TransactionPayload, TransactionSpendingCondition, TransactionVersion, }; use crate::core::StacksEpochId; use crate::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer; -use crate::cost_estimates::FeeRateEstimate; -use rand::rngs::StdRng; -use rand::thread_rng; -use rand::RngCore; -use rand::SeedableRng; - use crate::cost_estimates::tests::common::make_block_receipt; +use crate::cost_estimates::{EstimatorError, FeeEstimator, FeeRateEstimate}; struct ConstantFeeEstimator {} diff --git a/stackslib/src/cost_estimates/tests/fee_scalar.rs b/stackslib/src/cost_estimates/tests/fee_scalar.rs index ab4251884..68339e59b 100644 --- a/stackslib/src/cost_estimates/tests/fee_scalar.rs +++ b/stackslib/src/cost_estimates/tests/fee_scalar.rs @@ -1,34 +1,30 @@ -use std::{env, path::PathBuf}; -use time::Instant; +use std::env; +use std::path::PathBuf; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::types::{PrincipalData, StandardPrincipalData}; +use clarity::vm::Value; use rand::seq::SliceRandom; use rand::Rng; - -use crate::cost_estimates::metrics::CostMetric; -use crate::cost_estimates::{EstimatorError, FeeEstimator}; -use clarity::vm::costs::ExecutionCost; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksWorkScore, TrieHash, +}; +use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; +use stacks_common::util::vrf::VRFProof; +use time::Instant; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::{StacksEpochReceipt, StacksHeaderInfo}; use crate::chainstate::stacks::events::StacksTransactionReceipt; -use crate::chainstate::stacks::StacksBlockHeader; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksWorkScore}; -use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum}; -use stacks_common::util::vrf::VRFProof; - use crate::chainstate::stacks::{ - CoinbasePayload, StacksTransaction, TokenTransferMemo, TransactionAuth, + CoinbasePayload, StacksBlockHeader, StacksTransaction, TokenTransferMemo, TransactionAuth, TransactionContractCall, TransactionPayload, TransactionSpendingCondition, TransactionVersion, }; use crate::core::StacksEpochId; use crate::cost_estimates::fee_scalar::ScalarFeeRateEstimator; -use crate::cost_estimates::FeeRateEstimate; -use clarity::vm::types::{PrincipalData, StandardPrincipalData}; -use clarity::vm::Value; -use stacks_common::types::chainstate::StacksAddress; - +use crate::cost_estimates::metrics::CostMetric; use crate::cost_estimates::tests::common::make_block_receipt; +use crate::cost_estimates::{EstimatorError, FeeEstimator, FeeRateEstimate}; fn instantiate_test_db(m: CM) -> ScalarFeeRateEstimator { let mut path = env::temp_dir(); diff --git a/stackslib/src/cost_estimates/tests/metrics.rs b/stackslib/src/cost_estimates/tests/metrics.rs index 3cb0d0f76..c4e3d58f1 100644 --- a/stackslib/src/cost_estimates/tests/metrics.rs +++ b/stackslib/src/cost_estimates/tests/metrics.rs @@ -1,7 +1,8 @@ +use clarity::vm::costs::ExecutionCost; + use crate::chainstate::stacks::MAX_BLOCK_LEN; use crate::core::BLOCK_LIMIT_MAINNET_20; use crate::cost_estimates::metrics::{CostMetric, ProportionalDotProduct}; -use clarity::vm::costs::ExecutionCost; #[test] // Test that when dimensions of the execution cost are near "zero", diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs index 8ba3a186f..e532c9b06 100644 --- a/stackslib/src/main.rs +++ b/stackslib/src/main.rs @@ -32,76 +32,58 @@ extern crate serde_json; #[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)] extern crate slog; -use std::io; +use std::collections::{HashMap, HashSet}; +use std::convert::TryFrom; +use std::fs::{File, OpenOptions}; use std::io::prelude::*; -use std::process; -use std::thread; -use std::{collections::HashMap, env}; -use std::{convert::TryFrom, fs}; +use std::io::BufReader; +use std::{env, fs, io, process, thread}; -use blockstack_lib::burnchains::BLOCKSTACK_MAGIC_MAINNET; -use blockstack_lib::clarity_cli; -use blockstack_lib::cost_estimates::UnitEstimator; -use rusqlite::types::ToSql; -use rusqlite::Connection; -use rusqlite::OpenFlags; - -use blockstack_lib::burnchains::bitcoin::indexer::BitcoinIndexer; -use blockstack_lib::burnchains::bitcoin::indexer::{BitcoinIndexerConfig, BitcoinIndexerRuntime}; -use blockstack_lib::burnchains::bitcoin::spv; -use blockstack_lib::burnchains::bitcoin::BitcoinNetworkType; -use blockstack_lib::burnchains::db::BurnchainDB; -use blockstack_lib::burnchains::Address; -use blockstack_lib::burnchains::Burnchain; -use blockstack_lib::burnchains::Txid; +use blockstack_lib::burnchains::bitcoin::indexer::{ + BitcoinIndexer, BitcoinIndexerConfig, BitcoinIndexerRuntime, +}; +use blockstack_lib::burnchains::bitcoin::{spv, BitcoinNetworkType}; +use blockstack_lib::burnchains::db::{BurnchainBlockData, BurnchainDB}; +use blockstack_lib::burnchains::{ + Address, Burnchain, PoxConstants, Txid, BLOCKSTACK_MAGIC_MAINNET, +}; +use blockstack_lib::chainstate::burn::db::sortdb::SortitionDB; use blockstack_lib::chainstate::burn::ConsensusHash; -use blockstack_lib::chainstate::stacks::db::blocks::DummyEventDispatcher; -use blockstack_lib::chainstate::stacks::db::blocks::StagingBlock; -use blockstack_lib::chainstate::stacks::db::ChainStateBootData; -use blockstack_lib::chainstate::stacks::index::marf::MARFOpenOpts; -use blockstack_lib::chainstate::stacks::index::marf::MarfConnection; -use blockstack_lib::chainstate::stacks::index::marf::MARF; +use blockstack_lib::chainstate::stacks::db::blocks::{DummyEventDispatcher, StagingBlock}; +use blockstack_lib::chainstate::stacks::db::{ + ChainStateBootData, StacksChainState, StacksHeaderInfo, +}; +use blockstack_lib::chainstate::stacks::index::marf::{MARFOpenOpts, MarfConnection, MARF}; use blockstack_lib::chainstate::stacks::index::ClarityMarfTrieId; use blockstack_lib::chainstate::stacks::miner::*; -use blockstack_lib::chainstate::stacks::StacksBlockHeader; -use blockstack_lib::chainstate::stacks::*; +use blockstack_lib::chainstate::stacks::{StacksBlockHeader, *}; use blockstack_lib::clarity::vm::costs::ExecutionCost; use blockstack_lib::clarity::vm::types::StacksAddressExtensions; use blockstack_lib::clarity::vm::ClarityVersion; +use blockstack_lib::clarity_cli; use blockstack_lib::clarity_cli::vm_execute; -use blockstack_lib::core::*; +use blockstack_lib::core::{MemPoolDB, *}; use blockstack_lib::cost_estimates::metrics::UnitMetric; +use blockstack_lib::cost_estimates::UnitEstimator; +use blockstack_lib::net::db::LocalPeer; +use blockstack_lib::net::p2p::PeerNetwork; use blockstack_lib::net::relay::Relayer; -use blockstack_lib::net::{db::LocalPeer, p2p::PeerNetwork, PeerAddress}; +use blockstack_lib::net::PeerAddress; +use blockstack_lib::util_lib::db::sqlite_open; use blockstack_lib::util_lib::strings::UrlString; -use blockstack_lib::{ - burnchains::{db::BurnchainBlockData, PoxConstants}, - chainstate::{ - burn::db::sortdb::SortitionDB, - stacks::db::{StacksChainState, StacksHeaderInfo}, - }, - core::MemPoolDB, - util_lib::db::sqlite_open, -}; +use libstackerdb::StackerDBChunkData; +use rusqlite::types::ToSql; +use rusqlite::{Connection, OpenFlags}; use serde_json::Value; use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::StacksAddress; use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, PoxId, StacksBlockId, + BlockHeaderHash, BurnchainHeaderHash, PoxId, StacksAddress, StacksBlockId, }; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::hash::{hex_bytes, to_hex}; -use stacks_common::util::log; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; use stacks_common::util::retry::LogReader; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; -use stacks_common::util::sleep_ms; -use stacks_common::util::{hash::Hash160, vrf::VRFProof}; -use std::collections::HashSet; -use std::fs::{File, OpenOptions}; -use std::io::BufReader; - -use libstackerdb::StackerDBChunkData; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; +use stacks_common::util::vrf::VRFProof; +use stacks_common::util::{get_epoch_time_ms, log, sleep_ms}; fn main() { let mut argv: Vec = env::args().collect(); diff --git a/stackslib/src/monitoring/mod.rs b/stackslib/src/monitoring/mod.rs index 3a90b72cd..0e6919781 100644 --- a/stackslib/src/monitoring/mod.rs +++ b/stackslib/src/monitoring/mod.rs @@ -14,26 +14,22 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::{fmt, fs, path::PathBuf}; - -use rusqlite::{OpenFlags, OptionalExtension}; - -use crate::burnchains::BurnchainSigner; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::Error as DatabaseError; -use crate::{ - burnchains::Txid, - core::MemPoolDB, - net::{Error as net_error, HttpRequestType}, - util_lib::db::{tx_busy_handler, DBConn}, -}; -use clarity::vm::costs::ExecutionCost; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::uint::{Uint256, Uint512}; use std::convert::TryInto; use std::error::Error; +use std::path::PathBuf; use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::Mutex; +use std::{fmt, fs}; + +use clarity::vm::costs::ExecutionCost; +use rusqlite::{OpenFlags, OptionalExtension}; +use stacks_common::util::get_epoch_time_secs; +use stacks_common::util::uint::{Uint256, Uint512}; + +use crate::burnchains::{BurnchainSigner, Txid}; +use crate::core::MemPoolDB; +use crate::net::{Error as net_error, HttpRequestType}; +use crate::util_lib::db::{sqlite_open, tx_busy_handler, DBConn, Error as DatabaseError}; #[cfg(feature = "monitoring_prom")] mod prometheus; diff --git a/stackslib/src/net/asn.rs b/stackslib/src/net/asn.rs index 9a7612a29..edcf66d29 100644 --- a/stackslib/src/net/asn.rs +++ b/stackslib/src/net/asn.rs @@ -15,17 +15,13 @@ // along with this program. If not, see . use std::fs::File; -use std::io::BufRead; -use std::io::BufReader; - -use crate::net::Error as net_error; -use crate::net::PeerAddress; - -use regex::Captures; -use regex::Regex; +use std::io::{BufRead, BufReader}; +use regex::{Captures, Regex}; use stacks_common::util::log; +use crate::net::{Error as net_error, PeerAddress}; + // IPv4 prefix to ASN/org map entry #[derive(Debug, Clone, PartialEq)] pub struct ASEntry4 { @@ -227,11 +223,13 @@ impl ASEntry4 { #[cfg(test)] mod test { - use super::*; - use stacks_common::util::log; use std::io; use std::io::BufRead; + use stacks_common::util::log; + + use super::*; + struct asn_fixture { text: String, result: Result, net_error>, diff --git a/stackslib/src/net/atlas/db.rs b/stackslib/src/net/atlas/db.rs index 31cda5b21..fab672c8e 100644 --- a/stackslib/src/net/atlas/db.rs +++ b/stackslib/src/net/atlas/db.rs @@ -33,43 +33,27 @@ //! to its download queue. //! -use rusqlite::types::FromSql; -use rusqlite::types::FromSqlError; -use rusqlite::types::ToSql; -use rusqlite::types::ToSqlOutput; -use rusqlite::types::ValueRef; -use rusqlite::OptionalExtension; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::{Connection, OpenFlags, NO_PARAMS}; - use std::collections::HashSet; -use std::convert::From; -use std::convert::TryFrom; +use std::convert::{From, TryFrom}; use std::fs; -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{ - query_count, query_int, query_row, query_rows, u64_to_sql, FromColumn, FromRow, -}; - +use clarity::vm::types::QualifiedContractIdentifier; +use rusqlite::types::{FromSql, FromSqlError, ToSql, ToSqlOutput, ValueRef}; +use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS}; +use stacks_common::codec::StacksMessageCodec; +use stacks_common::types::chainstate::StacksBlockId; use stacks_common::util; use stacks_common::util::hash::{bin_bytes, hex_bytes, to_bin, to_hex, Hash160}; use stacks_common::util::log; use stacks_common::util::macros::is_big_endian; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use clarity::vm::types::QualifiedContractIdentifier; - -use crate::burnchains::Txid; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; use super::{AtlasConfig, Attachment, AttachmentInstance}; +use crate::burnchains::Txid; +use crate::util_lib::db::{ + query_count, query_int, query_row, query_rows, sqlite_open, tx_begin_immediate, u64_to_sql, + DBConn, Error as db_error, FromColumn, FromRow, +}; pub const ATLASDB_VERSION: &'static str = "2"; diff --git a/stackslib/src/net/atlas/download.rs b/stackslib/src/net/atlas/download.rs index 341c47140..e92638ba2 100644 --- a/stackslib/src/net/atlas/download.rs +++ b/stackslib/src/net/atlas/download.rs @@ -17,38 +17,32 @@ use std::cmp::Ordering; use std::collections::hash_map::Entry; use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque}; -use std::fmt; use std::hash::{Hash, Hasher}; use std::net::{IpAddr, SocketAddr}; +use std::{cmp, fmt}; +use clarity::vm::types::QualifiedContractIdentifier; +use rand::{thread_rng, Rng}; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; +use stacks_common::util::hash::{Hash160, MerkleHashFunc}; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs}; + +use super::{AtlasDB, Attachment, AttachmentInstance, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST}; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::StacksChainState; +use crate::core::mempool::MemPoolDB; use crate::net::atlas::MAX_RETRY_DELAY; use crate::net::connection::ConnectionOptions; use crate::net::dns::*; use crate::net::p2p::PeerNetwork; use crate::net::server::HttpPeer; -use crate::net::Error as net_error; -use crate::net::NeighborKey; -use crate::net::{GetAttachmentResponse, GetAttachmentsInvResponse}; -use crate::net::{HttpRequestMetadata, HttpRequestType, HttpResponseType, PeerHost, Requestable}; +use crate::net::{ + Error as net_error, GetAttachmentResponse, GetAttachmentsInvResponse, HttpRequestMetadata, + HttpRequestType, HttpResponseType, NeighborKey, PeerHost, Requestable, +}; use crate::util_lib::db::Error as DBError; use crate::util_lib::strings; use crate::util_lib::strings::UrlString; -use clarity::vm::types::QualifiedContractIdentifier; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::util::hash::{Hash160, MerkleHashFunc}; -use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs}; - -use stacks_common::types::chainstate::BlockHeaderHash; - -use super::{AtlasDB, Attachment, AttachmentInstance, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST}; - -use rand::thread_rng; -use rand::Rng; -use std::cmp; - -use crate::core::mempool::MemPoolDB; #[derive(Debug)] pub struct AttachmentsDownloader { diff --git a/stackslib/src/net/atlas/mod.rs b/stackslib/src/net/atlas/mod.rs index 49fb387f0..fbb384862 100644 --- a/stackslib/src/net/atlas/mod.rs +++ b/stackslib/src/net/atlas/mod.rs @@ -18,21 +18,18 @@ use std::collections::{HashMap, HashSet}; use std::convert::TryFrom; use std::hash::{Hash, Hasher}; +use clarity::vm::types::{QualifiedContractIdentifier, SequenceData, TupleData, Value}; use regex::Regex; +use stacks_common::codec::StacksMessageCodec; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; +use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc}; +pub use self::db::AtlasDB; +pub use self::download::AttachmentsDownloader; use crate::burnchains::Txid; use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::burn::ConsensusHash; use crate::util_lib::boot::boot_code_id; -use clarity::vm::types::{QualifiedContractIdentifier, SequenceData, TupleData, Value}; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc}; - -use stacks_common::types::chainstate::BlockHeaderHash; - -pub use self::db::AtlasDB; -pub use self::download::AttachmentsDownloader; /// Implements AtlasDB and associated API. Stores information about attachments and attachment /// instances. diff --git a/stackslib/src/net/atlas/tests.rs b/stackslib/src/net/atlas/tests.rs index efb5a397a..42cf3de12 100644 --- a/stackslib/src/net/atlas/tests.rs +++ b/stackslib/src/net/atlas/tests.rs @@ -16,9 +16,17 @@ use std::collections::{BinaryHeap, HashMap, HashSet}; use std::convert::TryFrom; -use std::thread; -use std::time; +use std::{thread, time}; +use clarity::vm::types::QualifiedContractIdentifier; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; +use stacks_common::util::hash::Hash160; + +use super::download::{ + AttachmentRequest, AttachmentsBatch, AttachmentsBatchStateContext, AttachmentsInventoryRequest, + BatchedRequestsResult, ReliabilityReport, +}; +use super::{AtlasConfig, AtlasDB, Attachment, AttachmentInstance}; use crate::burnchains::Txid; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::StacksChainState; @@ -30,16 +38,6 @@ use crate::net::{ use crate::util_lib::boot::boot_code_id; use crate::util_lib::db::u64_to_sql; use crate::util_lib::strings::UrlString; -use clarity::vm::types::QualifiedContractIdentifier; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::util::hash::Hash160; - -use super::download::{ - AttachmentRequest, AttachmentsBatch, AttachmentsBatchStateContext, AttachmentsInventoryRequest, - BatchedRequestsResult, ReliabilityReport, -}; -use super::{AtlasConfig, AtlasDB, Attachment, AttachmentInstance}; fn new_attachment_from(content: &str) -> Attachment { Attachment { diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs index 3f6a0a74e..1189087af 100644 --- a/stackslib/src/net/chat.rs +++ b/stackslib/src/net/chat.rs @@ -14,64 +14,41 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; +use std::collections::{HashMap, HashSet, VecDeque}; use std::convert::TryFrom; -use std::io::Read; -use std::io::Write; -use std::mem; +use std::io::{Read, Write}; use std::net::SocketAddr; +use std::{cmp, mem}; +use clarity::vm::types::QualifiedContractIdentifier; use rand; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::types::chainstate::PoxId; +use stacks_common::types::StacksPublicKeyBuffer; +use stacks_common::util::hash::to_hex; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; +use stacks_common::util::{get_epoch_time_secs, log}; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; -use crate::burnchains::PublicKey; +use crate::burnchains::{Burnchain, BurnchainView, PublicKey}; use crate::chainstate::burn::db::sortdb; use crate::chainstate::burn::db::sortdb::{BlockHeaderCache, SortitionDB}; use crate::chainstate::stacks::db::StacksChainState; use crate::chainstate::stacks::StacksPublicKey; -use crate::core::PEER_VERSION_EPOCH_2_2; -use crate::core::PEER_VERSION_EPOCH_2_3; +use crate::core::{StacksEpoch, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3}; use crate::monitoring; use crate::net::asn::ASEntry4; use crate::net::codec::*; -use crate::net::connection::ConnectionOptions; -use crate::net::connection::ConnectionP2P; -use crate::net::connection::ReplyHandleP2P; -use crate::net::db::PeerDB; -use crate::net::db::*; +use crate::net::connection::{ConnectionOptions, ConnectionP2P, ReplyHandleP2P}; +use crate::net::db::{PeerDB, *}; use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY; use crate::net::p2p::PeerNetwork; use crate::net::relay::*; use crate::net::stackerdb::StackerDBs; -use crate::net::Error as net_error; -use crate::net::GetBlocksInv; -use crate::net::GetPoxInv; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; -use crate::net::StacksMessage; -use crate::net::StacksP2P; -use crate::net::GETPOXINV_MAX_BITLEN; -use crate::net::*; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use crate::core::StacksEpoch; -use stacks_common::types::chainstate::PoxId; -use stacks_common::types::StacksPublicKeyBuffer; - -use clarity::vm::types::QualifiedContractIdentifier; +use crate::net::{ + Error as net_error, GetBlocksInv, GetPoxInv, Neighbor, NeighborKey, PeerAddress, StacksMessage, + StacksP2P, GETPOXINV_MAX_BITLEN, *, +}; +use crate::util_lib::db::{DBConn, Error as db_error}; // did we or did we not successfully send a message? #[derive(Debug, Clone)] @@ -2713,11 +2690,17 @@ impl ConversationP2P { mod test { use std::fs; use std::io::prelude::*; - use std::io::Read; - use std::io::Write; - use std::net::SocketAddr; - use std::net::SocketAddrV4; + use std::io::{Read, Write}; + use std::net::{SocketAddr, SocketAddrV4}; + use clarity::vm::costs::ExecutionCost; + use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId}; + use stacks_common::util::pipe::*; + use stacks_common::util::secp256k1::*; + use stacks_common::util::sleep_ms; + use stacks_common::util::uint::*; + + use super::*; use crate::burnchains::bitcoin::keys::BitcoinPublicKey; use crate::burnchains::burnchain::*; use crate::burnchains::*; @@ -2733,15 +2716,6 @@ mod test { use crate::net::test::*; use crate::net::*; use crate::util_lib::test::*; - use clarity::vm::costs::ExecutionCost; - use stacks_common::util::pipe::*; - use stacks_common::util::secp256k1::*; - use stacks_common::util::sleep_ms; - use stacks_common::util::uint::*; - - use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId}; - - use super::*; const DEFAULT_SERVICES: u16 = (ServiceFlags::RELAY as u16) | (ServiceFlags::RPC as u16); const STACKERDB_SERVICES: u16 = (ServiceFlags::RELAY as u16) diff --git a/stackslib/src/net/codec.rs b/stackslib/src/net/codec.rs index fe64845fc..32b5f2756 100644 --- a/stackslib/src/net/codec.rs +++ b/stackslib/src/net/codec.rs @@ -16,50 +16,36 @@ use std::collections::HashSet; use std::convert::TryFrom; -use std::io; use std::io::prelude::*; use std::io::Read; -use std::mem; - -use rand; -use rand::Rng; -use sha2::Digest; -use sha2::Sha512_256; - -use crate::burnchains::BurnchainView; -use crate::burnchains::PrivateKey; -use crate::burnchains::PublicKey; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::StacksBlock; -use crate::chainstate::stacks::StacksMicroblock; -use crate::chainstate::stacks::StacksPublicKey; -use crate::chainstate::stacks::StacksTransaction; -use crate::chainstate::stacks::MAX_BLOCK_LEN; -use crate::core::PEER_VERSION_TESTNET; -use crate::net::db::LocalPeer; -use crate::net::Error as net_error; -use crate::net::*; -use stacks_common::codec::{read_next_at_most, read_next_exact, MAX_MESSAGE_LEN}; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::DoubleSha256; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::MerkleHashFunc; -use stacks_common::util::log; -use stacks_common::util::retry::BoundReader; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::secp256k1::MESSAGE_SIGNATURE_ENCODED_SIZE; -use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; - -use stacks_common::codec::{ - read_next, write_next, Error as codec_error, StacksMessageCodec, MAX_RELAYERS_LEN, - PREAMBLE_ENCODED_SIZE, -}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::StacksPublicKeyBuffer; +use std::{io, mem}; use clarity::vm::types::{QualifiedContractIdentifier, StandardPrincipalData}; use clarity::vm::ContractName; +use rand; +use rand::Rng; +use sha2::{Digest, Sha512_256}; +use stacks_common::codec::{ + read_next, read_next_at_most, read_next_exact, write_next, Error as codec_error, + StacksMessageCodec, MAX_MESSAGE_LEN, MAX_RELAYERS_LEN, PREAMBLE_ENCODED_SIZE, +}; +use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; +use stacks_common::types::StacksPublicKeyBuffer; +use stacks_common::util::hash::{to_hex, DoubleSha256, Hash160, MerkleHashFunc}; +use stacks_common::util::log; +use stacks_common::util::retry::BoundReader; +use stacks_common::util::secp256k1::{ + MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey, MESSAGE_SIGNATURE_ENCODED_SIZE, +}; + +use crate::burnchains::{BurnchainView, PrivateKey, PublicKey}; +use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::{ + StacksBlock, StacksMicroblock, StacksPublicKey, StacksTransaction, MAX_BLOCK_LEN, +}; +use crate::core::PEER_VERSION_TESTNET; +use crate::net::db::LocalPeer; +use crate::net::{Error as net_error, *}; impl Preamble { /// Make an empty preamble with the given version and fork-set identifier, and payload length. diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs index 6e900e3cb..fb8211cd3 100644 --- a/stackslib/src/net/connection.rs +++ b/stackslib/src/net/connection.rs @@ -16,39 +16,28 @@ use std::collections::VecDeque; use std::convert::TryFrom; -use std::io; use std::io::{Read, Write}; -use std::net; -use std::ops::Deref; -use std::ops::DerefMut; +use std::ops::{Deref, DerefMut}; +use std::sync::mpsc::{ + sync_channel, Receiver, RecvError, RecvTimeoutError, SyncSender, TryRecvError, TrySendError, +}; use std::time::Duration; +use std::{io, net}; -use std::sync::mpsc::sync_channel; -use std::sync::mpsc::Receiver; -use std::sync::mpsc::RecvError; -use std::sync::mpsc::RecvTimeoutError; -use std::sync::mpsc::SyncSender; -use std::sync::mpsc::TryRecvError; -use std::sync::mpsc::TrySendError; - +use clarity::vm::costs::ExecutionCost; +use clarity::vm::types::BOUND_VALUE_SERIALIZATION_HEX; use mio; use mio::net as mio_net; +use stacks_common::codec::{StacksMessageCodec, MAX_MESSAGE_LEN}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::pipe::*; +use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::{get_epoch_time_secs, log, sleep_ms}; +use crate::chainstate::burn::ConsensusHash; use crate::core::mempool::MAX_BLOOM_COUNTER_TXS; +use crate::monitoring::{update_inbound_bandwidth, update_outbound_bandwidth}; use crate::net::codec::*; -use crate::net::Error as net_error; -use crate::net::HttpRequestPreamble; -use crate::net::HttpResponsePreamble; -use crate::net::MessageSequence; -use crate::net::PeerAddress; -use crate::net::Preamble; -use crate::net::ProtocolFamily; -use crate::net::RelayData; -use crate::net::StacksHttp; -use crate::net::StacksP2P; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::codec::MAX_MESSAGE_LEN; - use crate::net::download::BLOCK_DOWNLOAD_INTERVAL; use crate::net::inv::{INV_REWARD_CYCLES, INV_SYNC_INTERVAL}; use crate::net::neighbors::{ @@ -56,19 +45,10 @@ use crate::net::neighbors::{ WALK_MAX_DURATION, WALK_MIN_DURATION, WALK_RESET_INTERVAL, WALK_RESET_PROB, WALK_RETRY_COUNT, WALK_STATE_TIMEOUT, }; - -use clarity::vm::{costs::ExecutionCost, types::BOUND_VALUE_SERIALIZATION_HEX}; - -use crate::chainstate::burn::ConsensusHash; - -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::pipe::*; -use stacks_common::util::secp256k1::Secp256k1PublicKey; -use stacks_common::util::sleep_ms; - -use crate::monitoring::{update_inbound_bandwidth, update_outbound_bandwidth}; +use crate::net::{ + Error as net_error, HttpRequestPreamble, HttpResponsePreamble, MessageSequence, PeerAddress, + Preamble, ProtocolFamily, RelayData, StacksHttp, StacksP2P, +}; /// Receiver notification handle. /// When a message with the expected `seq` value arrives, send it to an expected receiver (possibly @@ -1402,25 +1382,22 @@ pub type ReplyHandleHttp = NetworkReplyHandle; #[cfg(test)] mod test { - use super::*; - use crate::net::*; + use std::io::prelude::*; + use std::io::{Read, Write}; + use std::sync::{Arc, Mutex}; + use std::{io, thread}; + use rand; use rand::RngCore; use stacks_common::util::pipe::*; use stacks_common::util::secp256k1::*; use stacks_common::util::*; - use std::io; - use std::io::prelude::*; - use std::io::{Read, Write}; - use std::sync::{Arc, Mutex}; - use std::thread; - - use crate::net::test::make_tcp_sockets; - use crate::net::test::NetCursor; + use super::*; use crate::chainstate::stacks::test::make_codec_test_block; use crate::net::http::*; - + use crate::net::test::{make_tcp_sockets, NetCursor}; + use crate::net::*; use crate::util_lib::test::*; fn test_connection_relay_producer_consumer( diff --git a/stackslib/src/net/db.rs b/stackslib/src/net/db.rs index 90bbf9c96..206f48a88 100644 --- a/stackslib/src/net/db.rs +++ b/stackslib/src/net/db.rs @@ -14,62 +14,34 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::fmt; - use std::collections::HashSet; +use std::convert::{From, TryFrom}; +use std::{fmt, fs}; +use clarity::vm::types::{ + QualifiedContractIdentifier, StacksAddressExtensions, StandardPrincipalData, +}; +use rand::seq::SliceRandom; +use rand::{thread_rng, Rng, RngCore}; use rusqlite::types::ToSql; -use rusqlite::OptionalExtension; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::{Connection, OpenFlags, NO_PARAMS}; - -use std::convert::From; -use std::convert::TryFrom; -use std::fs; - -use clarity::vm::types::QualifiedContractIdentifier; -use clarity::vm::types::StacksAddressExtensions; -use clarity::vm::types::StandardPrincipalData; - -use crate::util_lib::db::sqlite_open; -use crate::util_lib::db::tx_begin_immediate; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{query_count, query_row, query_rows, u64_to_sql, FromColumn, FromRow}; - +use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS}; use stacks_common::util; -use stacks_common::util::get_epoch_time_secs; use stacks_common::util::hash::{ bin_bytes, hex_bytes, to_bin, to_hex, Hash160, Sha256Sum, Sha512Trunc256Sum, }; -use stacks_common::util::log; use stacks_common::util::macros::is_big_endian; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use crate::util_lib::db::tx_busy_handler; - -use crate::chainstate::stacks::StacksPrivateKey; -use crate::chainstate::stacks::StacksPublicKey; - -use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; -use rand::RngCore; - -use crate::net::asn::ASEntry4; -use crate::net::Neighbor; -use crate::net::NeighborAddress; -use crate::net::NeighborKey; -use crate::net::PeerAddress; -use crate::net::ServiceFlags; - -use crate::burnchains::PrivateKey; -use crate::burnchains::PublicKey; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; +use stacks_common::util::{get_epoch_time_secs, log}; +use crate::burnchains::{PrivateKey, PublicKey}; +use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey}; use crate::core::NETWORK_P2P_PORT; - +use crate::net::asn::ASEntry4; +use crate::net::{Neighbor, NeighborAddress, NeighborKey, PeerAddress, ServiceFlags}; +use crate::util_lib::db::{ + query_count, query_row, query_rows, sqlite_open, tx_begin_immediate, tx_busy_handler, + u64_to_sql, DBConn, Error as db_error, FromColumn, FromRow, +}; use crate::util_lib::strings::UrlString; pub const PEERDB_VERSION: &'static str = "2"; @@ -1831,17 +1803,12 @@ impl PeerDB { #[cfg(test)] mod test { - use super::*; - use crate::net::Neighbor; - use crate::net::NeighborKey; - use crate::net::PeerAddress; - + use clarity::vm::types::{StacksAddressExtensions, StandardPrincipalData}; use stacks_common::types::chainstate::StacksAddress; - use stacks_common::util::hash::Hash160; - use clarity::vm::types::StacksAddressExtensions; - use clarity::vm::types::StandardPrincipalData; + use super::*; + use crate::net::{Neighbor, NeighborKey, PeerAddress}; /// Test storage, retrieval, and mutation of LocalPeer, including its stacker DB contract IDs #[test] diff --git a/stackslib/src/net/dns.rs b/stackslib/src/net/dns.rs index f342cf12e..7f36d88d6 100644 --- a/stackslib/src/net/dns.rs +++ b/stackslib/src/net/dns.rs @@ -14,39 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::sync::mpsc::sync_channel; -use std::sync::mpsc::Receiver; -use std::sync::mpsc::RecvError; -use std::sync::mpsc::RecvTimeoutError; -use std::sync::mpsc::SyncSender; -use std::sync::mpsc::TryRecvError; -use std::sync::mpsc::TrySendError; - +use std::collections::{HashMap, HashSet, VecDeque}; use std::hash::{Hash, Hasher}; -use std::net::ToSocketAddrs; +use std::net::{SocketAddr, ToSocketAddrs}; +use std::sync::mpsc::{ + sync_channel, Receiver, RecvError, RecvTimeoutError, SyncSender, TryRecvError, TrySendError, +}; + +use stacks_common::util::hash::to_hex; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log, sleep_ms}; use crate::net::asn::ASEntry4; -use crate::net::Error as net_error; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; - use crate::net::codec::*; -use crate::net::*; - +use crate::net::{Error as net_error, Neighbor, NeighborKey, PeerAddress, *}; use crate::util_lib::db::Error as db_error; -use stacks_common::util::sleep_ms; - -use std::net::SocketAddr; - -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; - -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; /// In Rust, there's no easy way to do non-blocking DNS lookups (I blame getaddrinfo), so do it in /// a separate thread, and implement a way for the block downloader to periodically poll for @@ -375,11 +356,13 @@ impl DNSClient { #[cfg(test)] mod test { - use crate::net::test::*; - use stacks_common::util::*; use std::collections::HashMap; use std::error::Error; + use stacks_common::util::*; + + use crate::net::test::*; + #[test] fn dns_start_stop() { let (client, thread_handle) = dns_thread_start(100); diff --git a/stackslib/src/net/download.rs b/stackslib/src/net/download.rs index a8c152ccb..6b9bd8723 100644 --- a/stackslib/src/net/download.rs +++ b/stackslib/src/net/download.rs @@ -14,69 +14,46 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; +use std::collections::{HashMap, HashSet, VecDeque}; use std::convert::TryFrom; use std::hash::{Hash, Hasher}; -use std::io::Read; -use std::io::Write; -use std::net::IpAddr; -use std::net::SocketAddr; -use std::sync::mpsc::sync_channel; -use std::sync::mpsc::Receiver; -use std::sync::mpsc::RecvError; -use std::sync::mpsc::RecvTimeoutError; -use std::sync::mpsc::SyncSender; -use std::sync::mpsc::TryRecvError; -use std::sync::mpsc::TrySendError; +use std::io::{Read, Write}; +use std::net::{IpAddr, SocketAddr}; +use std::sync::mpsc::{ + sync_channel, Receiver, RecvError, RecvTimeoutError, SyncSender, TryRecvError, TrySendError, +}; use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::RngCore; +use rand::{thread_rng, RngCore}; +use stacks_common::types::chainstate::{BlockHeaderHash, PoxId, SortitionId, StacksBlockId}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log}; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; +use crate::burnchains::{Burnchain, BurnchainView}; use crate::chainstate::burn::db::sortdb::{BlockHeaderCache, SortitionDB, SortitionDBConn}; use crate::chainstate::burn::BlockSnapshot; use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::Error as chainstate_error; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::core::EMPTY_MICROBLOCK_PARENT_HASH; -use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use crate::core::FIRST_STACKS_BLOCK_HASH; +use crate::chainstate::stacks::{Error as chainstate_error, StacksBlockHeader}; +use crate::core::{ + EMPTY_MICROBLOCK_PARENT_HASH, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, +}; use crate::net::asn::ASEntry4; use crate::net::atlas::AttachmentsDownloader; use crate::net::codec::*; -use crate::net::connection::ConnectionOptions; -use crate::net::connection::ReplyHandleHttp; -use crate::net::db::PeerDB; -use crate::net::db::*; +use crate::net::connection::{ConnectionOptions, ReplyHandleHttp}; +use crate::net::db::{PeerDB, *}; use crate::net::dns::*; use crate::net::inv::InvState; use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY; use crate::net::p2p::PeerNetwork; use crate::net::rpc::*; use crate::net::server::HttpPeer; -use crate::net::Error as net_error; -use crate::net::GetBlocksInv; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; -use crate::net::StacksMessage; -use crate::net::StacksP2P; -use crate::net::*; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use stacks_common::types::chainstate::{BlockHeaderHash, PoxId, SortitionId}; +use crate::net::{ + Error as net_error, GetBlocksInv, Neighbor, NeighborKey, PeerAddress, StacksMessage, StacksP2P, + *, +}; +use crate::util_lib::db::{DBConn, Error as db_error}; #[cfg(not(test))] pub const BLOCK_DOWNLOAD_INTERVAL: u64 = 180; @@ -2585,8 +2562,16 @@ pub mod test { use std::collections::HashMap; use std::convert::TryFrom; + use clarity::vm::clarity::ClarityConnection; + use clarity::vm::costs::ExecutionCost; + use clarity::vm::execute; + use clarity::vm::representations::*; use rand::Rng; + use stacks_common::util::hash::*; + use stacks_common::util::sleep_ms; + use stacks_common::util::vrf::VRFProof; + use super::*; use crate::burnchains::tests::TestMiner; use crate::chainstate::burn::db::sortdb::*; use crate::chainstate::burn::operations::*; @@ -2602,15 +2587,6 @@ pub mod test { use crate::stacks_common::types::PublicKey; use crate::util_lib::strings::*; use crate::util_lib::test::*; - use clarity::vm::clarity::ClarityConnection; - use clarity::vm::costs::ExecutionCost; - use clarity::vm::execute; - use clarity::vm::representations::*; - use stacks_common::util::hash::*; - use stacks_common::util::sleep_ms; - use stacks_common::util::vrf::VRFProof; - - use super::*; fn get_peer_availability( peer: &mut TestPeer, diff --git a/stackslib/src/net/http.rs b/stackslib/src/net/http.rs index e708e1c73..9859a4ef3 100644 --- a/stackslib/src/net/http.rs +++ b/stackslib/src/net/http.rs @@ -16,91 +16,59 @@ use std::collections::{HashMap, HashSet}; use std::convert::TryFrom; -use std::fmt; -use std::io; use std::io::prelude::*; use std::io::{Read, Write}; -use std::mem; use std::net::SocketAddr; -use std::str; use std::str::FromStr; use std::time::SystemTime; +use std::{fmt, io, mem, str}; -use clarity::vm::representations::MAX_STRING_LEN; +use clarity::vm::ast::parser::v1::CLARITY_NAME_REGEX; +use clarity::vm::representations::{ + CONTRACT_NAME_REGEX_STRING, MAX_STRING_LEN, PRINCIPAL_DATA_REGEX_STRING, + STANDARD_PRINCIPAL_REGEX_STRING, +}; +use clarity::vm::types::{ + PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, TraitIdentifier, + BOUND_VALUE_SERIALIZATION_HEX, +}; +use clarity::vm::{ClarityName, ContractName, Value}; +use libstackerdb::STACKERDB_MAX_CHUNK_SIZE; use percent_encoding::percent_decode_str; use regex::{Captures, Regex}; use serde::{Deserialize, Serialize}; -use serde_json; -use time; -use url::{form_urlencoded, Url}; - -use libstackerdb::STACKERDB_MAX_CHUNK_SIZE; - -use crate::burnchains::{Address, Txid}; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::{ - StacksBlock, StacksMicroblock, StacksPublicKey, StacksTransaction, -}; -use crate::net::atlas::Attachment; -use crate::net::ClientError; -use crate::net::Error as net_error; -use crate::net::Error::ClarityError; -use crate::net::ExtendedStacksHeader; -use crate::net::HttpContentType; -use crate::net::HttpRequestMetadata; -use crate::net::HttpRequestPreamble; -use crate::net::HttpRequestType; -use crate::net::HttpResponseMetadata; -use crate::net::HttpResponsePreamble; -use crate::net::HttpResponseType; -use crate::net::HttpVersion; -use crate::net::MemPoolSyncData; -use crate::net::MessageSequence; -use crate::net::NeighborAddress; -use crate::net::PeerAddress; -use crate::net::PeerHost; -use crate::net::ProtocolFamily; -use crate::net::StackerDBChunkData; -use crate::net::StacksHttpMessage; -use crate::net::StacksHttpPreamble; -use crate::net::UnconfirmedTransactionResponse; -use crate::net::UnconfirmedTransactionStatus; -use crate::net::HTTP_PREAMBLE_MAX_ENCODED_SIZE; -use crate::net::HTTP_PREAMBLE_MAX_NUM_HEADERS; -use crate::net::HTTP_REQUEST_ID_RESERVED; -use crate::net::MAX_HEADERS; -use crate::net::MAX_MICROBLOCKS_UNCONFIRMED; -use crate::net::{CallReadOnlyRequestBody, TipRequest}; -use crate::net::{GetAttachmentResponse, GetAttachmentsInvResponse, PostTransactionRequestBody}; -use clarity::vm::ast::parser::v1::CLARITY_NAME_REGEX; -use clarity::vm::types::{StandardPrincipalData, TraitIdentifier}; -use clarity::vm::{ - representations::{ - CONTRACT_NAME_REGEX_STRING, PRINCIPAL_DATA_REGEX_STRING, STANDARD_PRINCIPAL_REGEX_STRING, - }, - types::{PrincipalData, QualifiedContractIdentifier, BOUND_VALUE_SERIALIZATION_HEX}, - ClarityName, ContractName, Value, -}; -use stacks_common::util::hash::hex_bytes; -use stacks_common::util::hash::to_hex; -use stacks_common::util::hash::Hash160; -use stacks_common::util::log; -use stacks_common::util::retry::BoundReader; -use stacks_common::util::retry::RetryReader; - -use stacks_common::deps_common::httparse; - -use stacks_common::util::chunked_encoding::*; - -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::TransactionPayload; use stacks_common::codec::{ read_next, write_next, Error as codec_error, StacksMessageCodec, MAX_MESSAGE_LEN, MAX_PAYLOAD_LEN, }; +use stacks_common::deps_common::httparse; use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId}; +use stacks_common::util::chunked_encoding::*; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160}; +use stacks_common::util::log; +use stacks_common::util::retry::{BoundReader, RetryReader}; +use url::{form_urlencoded, Url}; +use {serde_json, time}; use super::FeeRateEstimateRequestBody; +use crate::burnchains::{Address, Txid}; +use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::{ + StacksBlock, StacksBlockHeader, StacksMicroblock, StacksPublicKey, StacksTransaction, + TransactionPayload, +}; +use crate::net::atlas::Attachment; +use crate::net::Error::ClarityError; +use crate::net::{ + CallReadOnlyRequestBody, ClientError, Error as net_error, ExtendedStacksHeader, + GetAttachmentResponse, GetAttachmentsInvResponse, HttpContentType, HttpRequestMetadata, + HttpRequestPreamble, HttpRequestType, HttpResponseMetadata, HttpResponsePreamble, + HttpResponseType, HttpVersion, MemPoolSyncData, MessageSequence, NeighborAddress, PeerAddress, + PeerHost, PostTransactionRequestBody, ProtocolFamily, StackerDBChunkData, StacksHttpMessage, + StacksHttpPreamble, TipRequest, UnconfirmedTransactionResponse, UnconfirmedTransactionStatus, + HTTP_PREAMBLE_MAX_ENCODED_SIZE, HTTP_PREAMBLE_MAX_NUM_HEADERS, HTTP_REQUEST_ID_RESERVED, + MAX_HEADERS, MAX_MICROBLOCKS_UNCONFIRMED, +}; lazy_static! { static ref PATH_GETINFO: Regex = Regex::new(r#"^/v2/info$"#).unwrap(); @@ -5064,31 +5032,20 @@ mod test { use rand; use rand::RngCore; + use stacks_common::types::chainstate::StacksAddress; + use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum}; + use super::*; use crate::burnchains::Txid; use crate::chainstate::stacks::db::blocks::test::make_sample_microblock_stream; use crate::chainstate::stacks::test::make_codec_test_block; - use crate::chainstate::stacks::StacksBlock; - use crate::chainstate::stacks::StacksMicroblock; - use crate::chainstate::stacks::StacksPrivateKey; - use crate::chainstate::stacks::StacksTransaction; - use crate::chainstate::stacks::TokenTransferMemo; - use crate::chainstate::stacks::TransactionAuth; - use crate::chainstate::stacks::TransactionPayload; - use crate::chainstate::stacks::TransactionPostConditionMode; - use crate::chainstate::stacks::TransactionVersion; + use crate::chainstate::stacks::{ + StacksBlock, StacksMicroblock, StacksPrivateKey, StacksTransaction, TokenTransferMemo, + TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionVersion, + }; use crate::net::codec::test::check_codec_and_corruption; use crate::net::test::*; - use crate::net::RPCNeighbor; - use crate::net::RPCNeighborsInfo; - use stacks_common::util::hash::to_hex; - use stacks_common::util::hash::Hash160; - use stacks_common::util::hash::MerkleTree; - use stacks_common::util::hash::Sha512Trunc256Sum; - - use stacks_common::types::chainstate::StacksAddress; - - use super::*; + use crate::net::{RPCNeighbor, RPCNeighborsInfo}; #[test] fn test_parse_reserved_header() { diff --git a/stackslib/src/net/inv.rs b/stackslib/src/net/inv.rs index 4ed88bbfc..6a3bee20c 100644 --- a/stackslib/src/net/inv.rs +++ b/stackslib/src/net/inv.rs @@ -15,55 +15,37 @@ // along with this program. If not, see . use std::cmp; -use std::collections::BTreeMap; -use std::collections::HashMap; -use std::collections::HashSet; +use std::collections::{BTreeMap, HashMap, HashSet}; use std::convert::TryFrom; -use std::io::Read; -use std::io::Write; +use std::io::{Read, Write}; use std::net::SocketAddr; use rand; use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::types::chainstate::{BlockHeaderHash, PoxId, SortitionId}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log}; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; +use crate::burnchains::{Burnchain, BurnchainView}; use crate::chainstate::burn::db::sortdb::{ BlockHeaderCache, SortitionDB, SortitionDBConn, SortitionHandleConn, }; -use crate::chainstate::burn::BlockSnapshot; +use crate::chainstate::burn::{BlockSnapshot, ConsensusHashExtensions}; use crate::chainstate::stacks::db::StacksChainState; use crate::net::asn::ASEntry4; use crate::net::chat::ConversationP2P; use crate::net::codec::*; -use crate::net::connection::ConnectionOptions; -use crate::net::connection::ConnectionP2P; -use crate::net::connection::ReplyHandleP2P; -use crate::net::db::PeerDB; -use crate::net::db::*; +use crate::net::connection::{ConnectionOptions, ConnectionP2P, ReplyHandleP2P}; +use crate::net::db::{PeerDB, *}; use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY; use crate::net::p2p::PeerNetwork; -use crate::net::Error as net_error; -use crate::net::GetBlocksInv; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; -use crate::net::StacksMessage; -use crate::net::StacksP2P; -use crate::net::*; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use crate::chainstate::burn::ConsensusHashExtensions; -use stacks_common::types::chainstate::{BlockHeaderHash, PoxId, SortitionId}; +use crate::net::{ + Error as net_error, GetBlocksInv, Neighbor, NeighborKey, PeerAddress, StacksMessage, StacksP2P, + *, +}; +use crate::util_lib::db::{DBConn, Error as db_error}; /// This module is responsible for synchronizing block inventories with other peers #[cfg(not(test))] @@ -2648,21 +2630,19 @@ impl PeerNetwork { mod test { use std::collections::HashMap; - use crate::burnchains::PoxConstants; + use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; + + use super::*; + use crate::burnchains::bitcoin::indexer::BitcoinIndexer; + use crate::burnchains::db::BurnchainHeaderReader; + use crate::burnchains::tests::BURNCHAIN_TEST_BLOCK_TIME; + use crate::burnchains::{BurnchainBlockHeader, PoxConstants}; + use crate::chainstate::coordinator::tests::get_burnchain; use crate::chainstate::stacks::*; use crate::net::test::*; use crate::net::*; use crate::util_lib::test::*; - use super::*; - - use crate::burnchains::bitcoin::indexer::BitcoinIndexer; - use crate::burnchains::db::BurnchainHeaderReader; - use crate::burnchains::tests::BURNCHAIN_TEST_BLOCK_TIME; - use crate::burnchains::BurnchainBlockHeader; - use crate::chainstate::coordinator::tests::get_burnchain; - use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; - #[test] fn peerblocksinv_has_ith_block() { let peer_inv = diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs index dc4486490..49498dafd 100644 --- a/stackslib/src/net/mod.rs +++ b/stackslib/src/net/mod.rs @@ -17,96 +17,71 @@ use std::borrow::Borrow; use std::cmp::PartialEq; use std::collections::{HashMap, HashSet}; -use std::convert::From; -use std::convert::TryFrom; -use std::error; -use std::fmt; -use std::hash::Hash; -use std::hash::Hasher; -use std::io; +use std::convert::{From, TryFrom}; +use std::hash::{Hash, Hasher}; use std::io::prelude::*; use std::io::{Read, Write}; -use std::net::IpAddr; -use std::net::Ipv4Addr; -use std::net::Ipv6Addr; -use std::net::SocketAddr; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}; use std::ops::Deref; use std::str::FromStr; +use std::{error, fmt, io}; -use rand::thread_rng; -use rand::RngCore; +use clarity::vm::analysis::contract_interface_builder::ContractInterface; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::types::{ + PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, TraitIdentifier, +}; +use clarity::vm::{ClarityName, ContractName, Value}; +use libstackerdb::{ + Error as libstackerdb_error, SlotMetadata, StackerDBChunkAckData, StackerDBChunkData, +}; +use rand::{thread_rng, RngCore}; use regex::Regex; -use rusqlite; use rusqlite::types::ToSqlOutput; use rusqlite::ToSql; use serde::de::Error as de_Error; use serde::ser::Error as ser_Error; use serde::{Deserialize, Serialize}; -use serde_json; -use url; +use stacks_common::codec::{ + read_next, write_next, Error as codec_error, StacksMessageCodec, + BURNCHAIN_HEADER_HASH_ENCODED_SIZE, +}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, PoxId, StacksAddress, StacksBlockId, +}; +use stacks_common::types::StacksPublicKeyBuffer; +use stacks_common::util::hash::{ + hex_bytes, to_hex, Hash160, Sha256Sum, DOUBLE_SHA256_ENCODED_SIZE, HASH160_ENCODED_SIZE, +}; +use stacks_common::util::secp256k1::{ + MessageSignature, Secp256k1PublicKey, MESSAGE_SIGNATURE_ENCODED_SIZE, +}; +use stacks_common::util::{get_epoch_time_secs, log}; +use {rusqlite, serde_json, url}; +use self::dns::*; +pub use self::http::StacksHttp; use crate::burnchains::affirmation::AffirmationMap; -use crate::burnchains::Error as burnchain_error; -use crate::burnchains::Txid; +use crate::burnchains::{Error as burnchain_error, Txid}; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::coordinator::Error as coordinator_error; use crate::chainstate::stacks::db::blocks::MemPoolRejection; use crate::chainstate::stacks::index::Error as marf_error; -use crate::chainstate::stacks::Error as chainstate_error; use crate::chainstate::stacks::{ - Error as chain_error, StacksBlock, StacksMicroblock, StacksPublicKey, StacksTransaction, - TransactionPayload, + Error as chainstate_error, Error as chain_error, StacksBlock, StacksBlockHeader, + StacksMicroblock, StacksPublicKey, StacksTransaction, TransactionPayload, }; use crate::clarity_vm::clarity::Error as clarity_error; use crate::core::mempool::*; -use crate::core::POX_REWARD_CYCLE_LENGTH; +use crate::core::{StacksEpoch, POX_REWARD_CYCLE_LENGTH}; +use crate::cost_estimates::FeeRateEstimate; use crate::net::atlas::{Attachment, AttachmentInstance}; use crate::net::http::HttpReservedHeader; pub use crate::net::http::StacksBlockAcceptedData; use crate::util_lib::bloom::{BloomFilter, BloomNodeHasher}; use crate::util_lib::boot::boot_code_tx_auth; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; +use crate::util_lib::db::{DBConn, Error as db_error}; use crate::util_lib::strings::UrlString; -use clarity::vm::types::QualifiedContractIdentifier; -use clarity::vm::types::StandardPrincipalData; -use clarity::vm::types::TraitIdentifier; -use clarity::vm::{ - analysis::contract_interface_builder::ContractInterface, types::PrincipalData, ClarityName, - ContractName, Value, -}; -use stacks_common::codec::Error as codec_error; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::codec::{read_next, write_next}; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::DOUBLE_SHA256_ENCODED_SIZE; -use stacks_common::util::hash::HASH160_ENCODED_SIZE; -use stacks_common::util::hash::{hex_bytes, to_hex}; -use stacks_common::util::log; -use stacks_common::util::secp256k1::MessageSignature; -use stacks_common::util::secp256k1::Secp256k1PublicKey; -use stacks_common::util::secp256k1::MESSAGE_SIGNATURE_ENCODED_SIZE; - -use crate::chainstate::stacks::StacksBlockHeader; - -use crate::cost_estimates::FeeRateEstimate; -use clarity::vm::costs::ExecutionCost; -use stacks_common::codec::BURNCHAIN_HEADER_HASH_ENCODED_SIZE; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::PoxId; -use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress, StacksBlockId}; -use stacks_common::types::StacksPublicKeyBuffer; -use stacks_common::util::hash::Sha256Sum; - -use self::dns::*; -pub use self::http::StacksHttp; - -use crate::core::StacksEpoch; - -use libstackerdb::{ - Error as libstackerdb_error, SlotMetadata, StackerDBChunkAckData, StackerDBChunkData, -}; /// Implements `ASEntry4` object, which is used in db.rs to store the AS number of an IP address. pub mod asn; @@ -146,12 +121,8 @@ pub mod server; pub mod stackerdb; pub mod stream; -use crate::net::stackerdb::StackerDBConfig; -use crate::net::stackerdb::StackerDBSync; -use crate::net::stackerdb::StackerDBSyncResult; -use crate::net::stackerdb::StackerDBs; - pub use crate::net::neighbors::{NeighborComms, PeerNetworkComms}; +use crate::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBSyncResult, StackerDBs}; pub use crate::net::stream::StreamCursor; #[cfg(test)] @@ -2359,30 +2330,40 @@ pub trait Requestable: std::fmt::Display { #[cfg(test)] pub mod test { - use std::fs; - use std::io; - use std::io::Cursor; - use std::io::ErrorKind; - use std::io::Read; - use std::io::Write; + use std::collections::HashMap; + use std::io::{Cursor, ErrorKind, Read, Write}; use std::net::*; - use std::ops::Deref; - use std::ops::DerefMut; + use std::ops::{Deref, DerefMut}; use std::sync::mpsc::sync_channel; - use std::thread; - use std::{collections::HashMap, sync::Mutex}; + use std::sync::Mutex; + use std::{fs, io, thread}; use clarity::vm::ast::ASTRules; - use mio; - use rand; + use clarity::vm::costs::ExecutionCost; + use clarity::vm::database::STXBalance; + use clarity::vm::types::*; + use clarity::vm::ClarityVersion; use rand::RngCore; + use stacks_common::address::*; + use stacks_common::codec::StacksMessageCodec; + use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; + use stacks_common::types::chainstate::TrieHash; + use stacks_common::types::StacksEpochId; + use stacks_common::util::get_epoch_time_secs; + use stacks_common::util::hash::*; + use stacks_common::util::secp256k1::*; + use stacks_common::util::uint::*; + use stacks_common::util::vrf::*; + use {mio, rand}; + use super::*; use crate::burnchains::bitcoin::address::*; use crate::burnchains::bitcoin::indexer::BitcoinIndexer; use crate::burnchains::bitcoin::keys::*; + use crate::burnchains::bitcoin::spv::BITCOIN_GENESIS_BLOCK_HASH_REGTEST; use crate::burnchains::bitcoin::*; use crate::burnchains::burnchain::*; - use crate::burnchains::db::BurnchainDB; + use crate::burnchains::db::{BurnchainDB, BurnchainHeaderReader}; use crate::burnchains::tests::*; use crate::burnchains::*; use crate::chainstate::burn::db::sortdb; @@ -2392,15 +2373,17 @@ pub mod test { use crate::chainstate::coordinator::tests::*; use crate::chainstate::coordinator::*; use crate::chainstate::stacks::address::PoxAddress; + use crate::chainstate::stacks::boot::test::get_parent_tip; use crate::chainstate::stacks::boot::*; - use crate::chainstate::stacks::db::StacksChainState; - use crate::chainstate::stacks::db::*; + use crate::chainstate::stacks::db::accounts::MinerReward; + use crate::chainstate::stacks::db::{StacksChainState, *}; + use crate::chainstate::stacks::events::StacksTransactionReceipt; use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::tests::chain_histories::mine_smart_contract_block_contract_call_microblock; use crate::chainstate::stacks::tests::*; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::{StacksMicroblockHeader, *}; use crate::chainstate::*; - use crate::core::NETWORK_P2P_PORT; + use crate::core::{StacksEpochExtension, NETWORK_P2P_PORT}; use crate::net::asn::*; use crate::net::atlas::*; use crate::net::chat::*; @@ -2413,34 +2396,8 @@ pub mod test { use crate::net::relay::*; use crate::net::rpc::RPCHandlerArgs; use crate::net::Error as net_error; - use crate::util_lib::strings::*; - use clarity::vm::costs::ExecutionCost; - use clarity::vm::database::STXBalance; - use clarity::vm::types::*; - use clarity::vm::ClarityVersion; - use stacks_common::address::*; - use stacks_common::address::*; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::*; - use stacks_common::util::secp256k1::*; - use stacks_common::util::uint::*; - use stacks_common::util::vrf::*; - - use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash; - - use super::*; - use crate::chainstate::stacks::boot::test::get_parent_tip; - use crate::chainstate::stacks::StacksMicroblockHeader; - use crate::chainstate::stacks::{db::accounts::MinerReward, events::StacksTransactionReceipt}; - use crate::core::StacksEpochExtension; use crate::util_lib::boot::boot_code_test_addr; - use stacks_common::codec::StacksMessageCodec; - use stacks_common::types::chainstate::TrieHash; - use stacks_common::types::StacksEpochId; - - use crate::burnchains::bitcoin::spv::BITCOIN_GENESIS_BLOCK_HASH_REGTEST; - - use crate::burnchains::db::BurnchainHeaderReader; + use crate::util_lib::strings::*; impl StacksMessageCodec for BlockstackOperationType { fn consensus_serialize(&self, fd: &mut W) -> Result<(), codec_error> { diff --git a/stackslib/src/net/neighbors/comms.rs b/stackslib/src/net/neighbors/comms.rs index 92b2a75ed..75ea4c2ab 100644 --- a/stackslib/src/net/neighbors/comms.rs +++ b/stackslib/src/net/neighbors/comms.rs @@ -14,34 +14,27 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::core::PEER_VERSION_TESTNET; - -use crate::net::{ - connection::{ConnectionOptions, ReplyHandleP2P}, - db::{LocalPeer, PeerDB}, - neighbors::{ - NeighborWalk, NeighborWalkDB, NeighborWalkResult, MAX_NEIGHBOR_BLOCK_DELAY, - NEIGHBOR_MINIMUM_CONTACT_INTERVAL, - }, - p2p::PeerNetwork, - Error as net_error, HandshakeData, Neighbor, NeighborAddress, NeighborKey, PeerAddress, - StacksMessage, StacksMessageType, NUM_NEIGHBORS, -}; - -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use std::cmp; -use std::mem; - -use std::collections::HashMap; -use std::collections::HashSet; - -use crate::burnchains::Address; -use crate::burnchains::PublicKey; +use std::collections::{HashMap, HashSet}; +use std::{cmp, mem}; use stacks_common::types::chainstate::StacksPublicKey; use stacks_common::util::hash::Hash160; use stacks_common::util::log; +use stacks_common::util::secp256k1::Secp256k1PublicKey; + +use crate::burnchains::{Address, PublicKey}; +use crate::core::PEER_VERSION_TESTNET; +use crate::net::connection::{ConnectionOptions, ReplyHandleP2P}; +use crate::net::db::{LocalPeer, PeerDB}; +use crate::net::neighbors::{ + NeighborWalk, NeighborWalkDB, NeighborWalkResult, MAX_NEIGHBOR_BLOCK_DELAY, + NEIGHBOR_MINIMUM_CONTACT_INTERVAL, +}; +use crate::net::p2p::PeerNetwork; +use crate::net::{ + Error as net_error, HandshakeData, Neighbor, NeighborAddress, NeighborKey, PeerAddress, + StacksMessage, StacksMessageType, NUM_NEIGHBORS, +}; /// A trait for representing session state for a set of connected neighbors, for the purposes of executing some P2P /// algorithm. diff --git a/stackslib/src/net/neighbors/db.rs b/stackslib/src/net/neighbors/db.rs index d3afce27a..fd85f0ce1 100644 --- a/stackslib/src/net/neighbors/db.rs +++ b/stackslib/src/net/neighbors/db.rs @@ -14,35 +14,23 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::net::db::PeerDB; +use std::collections::{HashMap, HashSet}; +use std::{cmp, mem}; +use rand::prelude::*; +use rand::thread_rng; +use stacks_common::util::hash::Hash160; +use stacks_common::util::{get_epoch_time_secs, log}; + +use crate::burnchains::{Address, Burnchain, BurnchainView}; +use crate::net::db::PeerDB; +use crate::net::neighbors::{NeighborWalkResult, NEIGHBOR_MINIMUM_CONTACT_INTERVAL, NUM_NEIGHBORS}; +use crate::net::p2p::PeerNetwork; use crate::net::{ Error as net_error, HandshakeAcceptData, HandshakeData, Neighbor, NeighborAddress, NeighborKey, Preamble, StackerDBHandshakeData, StacksMessage, }; - -use crate::net::neighbors::{NeighborWalkResult, NEIGHBOR_MINIMUM_CONTACT_INTERVAL, NUM_NEIGHBORS}; - -use crate::net::p2p::PeerNetwork; - -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; - -use std::cmp; -use std::mem; - -use std::collections::HashMap; -use std::collections::HashSet; - -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; - -use rand::prelude::*; -use rand::thread_rng; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::Hash160; -use stacks_common::util::log; +use crate::util_lib::db::{DBConn, DBTx}; /// Capture replacement state #[derive(Debug, Clone, PartialEq)] diff --git a/stackslib/src/net/neighbors/mod.rs b/stackslib/src/net/neighbors/mod.rs index 6a68a41cd..031e9f91a 100644 --- a/stackslib/src/net/neighbors/mod.rs +++ b/stackslib/src/net/neighbors/mod.rs @@ -14,44 +14,22 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::net::db::PeerDB; -use crate::net::Error as net_error; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; - -use crate::net::codec::*; -use crate::net::*; - -use crate::net::connection::ConnectionOptions; -use crate::net::connection::ReplyHandleP2P; - -use crate::net::db::LocalPeer; - -use crate::net::p2p::PeerNetwork; - -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; -use crate::util_lib::db::Error as db_error; - -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use std::cmp; -use std::mem; +use std::collections::{HashMap, HashSet}; use std::net::SocketAddr; - -use std::collections::HashMap; -use std::collections::HashSet; - -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; -use crate::burnchains::PublicKey; +use std::{cmp, mem}; use rand::prelude::*; use rand::thread_rng; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::log; +use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::{get_epoch_time_secs, log}; + +use crate::burnchains::{Address, Burnchain, BurnchainView, PublicKey}; +use crate::net::codec::*; +use crate::net::connection::{ConnectionOptions, ReplyHandleP2P}; +use crate::net::db::{LocalPeer, PeerDB}; +use crate::net::p2p::PeerNetwork; +use crate::net::{Error as net_error, Neighbor, NeighborKey, PeerAddress, *}; +use crate::util_lib::db::{DBConn, DBTx, Error as db_error}; pub mod comms; pub mod db; diff --git a/stackslib/src/net/neighbors/neighbor.rs b/stackslib/src/net/neighbors/neighbor.rs index 733e0edd8..a1d513daa 100644 --- a/stackslib/src/net/neighbors/neighbor.rs +++ b/stackslib/src/net/neighbors/neighbor.rs @@ -14,25 +14,20 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::net::{db::PeerDB, Error as net_error, Neighbor, NeighborAddress, NeighborKey}; - -use crate::util_lib::db::{DBConn, DBTx}; +use std::cmp; +use clarity::vm::types::QualifiedContractIdentifier; +use rand::prelude::*; +use rand::thread_rng; use stacks_common::types::chainstate::StacksPublicKey; use stacks_common::util::hash::Hash160; use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::{get_epoch_time_secs, log}; -use std::cmp; - -use crate::burnchains::Address; -use crate::burnchains::PublicKey; - -use rand::prelude::*; -use rand::thread_rng; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::log; - -use clarity::vm::types::QualifiedContractIdentifier; +use crate::burnchains::{Address, PublicKey}; +use crate::net::db::PeerDB; +use crate::net::{Error as net_error, Neighbor, NeighborAddress, NeighborKey}; +use crate::util_lib::db::{DBConn, DBTx}; /// Walk-specific helper functions for neighbors impl Neighbor { diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs index ea31f4b83..5cbda3c77 100644 --- a/stackslib/src/net/neighbors/walk.rs +++ b/stackslib/src/net/neighbors/walk.rs @@ -14,45 +14,29 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::net::db::PeerDB; - -use crate::net::{ - neighbors::{ - NeighborComms, NeighborReplacements, NeighborWalkDB, ToNeighborKey, - MAX_NEIGHBOR_BLOCK_DELAY, NEIGHBOR_MINIMUM_CONTACT_INTERVAL, - }, - Error as net_error, HandshakeAcceptData, HandshakeData, MessageSequence, Neighbor, - NeighborAddress, NeighborKey, PeerAddress, Preamble, StackerDBHandshakeData, StacksMessage, - StacksMessageType, NUM_NEIGHBORS, -}; - -use crate::net::neighbors::NeighborCommsRequest; - -use crate::net::connection::ConnectionOptions; -use crate::net::connection::ReplyHandleP2P; - -use crate::net::db::LocalPeer; -use crate::net::p2p::PeerNetwork; - -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use std::cmp; -use std::mem; - -use std::collections::HashMap; -use std::collections::HashSet; - -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; -use crate::burnchains::PublicKey; +use std::collections::{HashMap, HashSet}; +use std::{cmp, mem}; use rand::prelude::*; use rand::thread_rng; use stacks_common::types::chainstate::StacksPublicKey; -use stacks_common::util::get_epoch_time_secs; use stacks_common::util::hash::Hash160; -use stacks_common::util::log; +use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::{get_epoch_time_secs, log}; + +use crate::burnchains::{Address, Burnchain, BurnchainView, PublicKey}; +use crate::net::connection::{ConnectionOptions, ReplyHandleP2P}; +use crate::net::db::{LocalPeer, PeerDB}; +use crate::net::neighbors::{ + NeighborComms, NeighborCommsRequest, NeighborReplacements, NeighborWalkDB, ToNeighborKey, + MAX_NEIGHBOR_BLOCK_DELAY, NEIGHBOR_MINIMUM_CONTACT_INTERVAL, +}; +use crate::net::p2p::PeerNetwork; +use crate::net::{ + Error as net_error, HandshakeAcceptData, HandshakeData, MessageSequence, Neighbor, + NeighborAddress, NeighborKey, PeerAddress, Preamble, StackerDBHandshakeData, StacksMessage, + StacksMessageType, NUM_NEIGHBORS, +}; /// This struct records information from an inbound peer that has authenticated to this node. As /// new remote nodes connect, this node will remember this state for them so that the neighbor walk diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs index f4d212714..9bcb0c730 100644 --- a/stackslib/src/net/p2p.rs +++ b/stackslib/src/net/p2p.rs @@ -14,37 +14,28 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; use std::cmp::Ordering; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::mem; -use std::net::IpAddr; -use std::net::Ipv4Addr; -use std::net::Ipv6Addr; -use std::net::SocketAddr; -use std::sync::mpsc::sync_channel; -use std::sync::mpsc::Receiver; -use std::sync::mpsc::RecvError; -use std::sync::mpsc::SendError; -use std::sync::mpsc::SyncSender; -use std::sync::mpsc::TryRecvError; -use std::sync::mpsc::TrySendError; +use std::collections::{HashMap, HashSet, VecDeque}; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}; +use std::sync::mpsc::{ + sync_channel, Receiver, RecvError, SendError, SyncSender, TryRecvError, TrySendError, +}; +use std::{cmp, mem}; -use mio; +use clarity::vm::ast::ASTRules; +use clarity::vm::database::BurnStateDB; +use clarity::vm::types::QualifiedContractIdentifier; use mio::net as mio_net; use rand::prelude::*; use rand::thread_rng; +use stacks_common::types::chainstate::{PoxId, SortitionId}; +use stacks_common::util::hash::to_hex; +use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log}; +use {mio, url}; -use url; - -use crate::burnchains::db::BurnchainDB; -use crate::burnchains::db::BurnchainHeaderReader; -use crate::burnchains::Address; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; -use crate::burnchains::PublicKey; +use crate::burnchains::db::{BurnchainDB, BurnchainHeaderReader}; +use crate::burnchains::{Address, Burnchain, BurnchainView, PublicKey}; use crate::chainstate::burn::db::sortdb::{BlockHeaderCache, SortitionDB}; use crate::chainstate::burn::BlockSnapshot; use crate::chainstate::coordinator::{ @@ -52,50 +43,24 @@ use crate::chainstate::coordinator::{ static_get_stacks_tip_affirmation_map, }; use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::{MAX_BLOCK_LEN, MAX_TRANSACTION_LEN}; +use crate::chainstate::stacks::{StacksBlockHeader, MAX_BLOCK_LEN, MAX_TRANSACTION_LEN}; use crate::monitoring::{update_inbound_neighbors, update_outbound_neighbors}; use crate::net::asn::ASEntry4; -use crate::net::atlas::AtlasDB; -use crate::net::atlas::{AttachmentInstance, AttachmentsDownloader}; -use crate::net::chat::ConversationP2P; -use crate::net::chat::NeighborStats; -use crate::net::connection::ConnectionOptions; -use crate::net::connection::NetworkReplyHandle; -use crate::net::connection::ReplyHandleP2P; -use crate::net::db::LocalPeer; -use crate::net::db::PeerDB; +use crate::net::atlas::{AtlasDB, AttachmentInstance, AttachmentsDownloader}; +use crate::net::chat::{ConversationP2P, NeighborStats}; +use crate::net::connection::{ConnectionOptions, NetworkReplyHandle, ReplyHandleP2P}; +use crate::net::db::{LocalPeer, PeerDB}; use crate::net::download::BlockDownloader; use crate::net::inv::*; use crate::net::neighbors::*; -use crate::net::poll::NetworkPollState; -use crate::net::poll::NetworkState; +use crate::net::poll::{NetworkPollState, NetworkState}; use crate::net::prune::*; -use crate::net::relay::RelayerStats; -use crate::net::relay::*; -use crate::net::relay::*; +use crate::net::relay::{RelayerStats, *, *}; use crate::net::rpc::RPCHandlerArgs; use crate::net::server::*; use crate::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBTx, StackerDBs}; -use crate::net::Error as net_error; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; -use crate::net::*; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::DBTx; -use crate::util_lib::db::Error as db_error; -use clarity::vm::database::BurnStateDB; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::to_hex; -use stacks_common::util::log; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use crate::chainstate::stacks::StacksBlockHeader; -use stacks_common::types::chainstate::{PoxId, SortitionId}; - -use clarity::vm::ast::ASTRules; -use clarity::vm::types::QualifiedContractIdentifier; +use crate::net::{Error as net_error, Neighbor, NeighborKey, PeerAddress, *}; +use crate::util_lib::db::{DBConn, DBTx, Error as db_error}; /// inter-thread request to send a p2p message from another thread in this program. #[derive(Debug)] @@ -5784,12 +5749,18 @@ impl PeerNetwork { #[cfg(test)] mod test { - use std::thread; - use std::time; + use std::{thread, time}; + use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; + use clarity::vm::types::StacksAddressExtensions; + use clarity::vm::MAX_CALL_STACK_DEPTH; use rand; use rand::RngCore; + use stacks_common::types::chainstate::BurnchainHeaderHash; + use stacks_common::util::secp256k1::Secp256k1PrivateKey; + use stacks_common::util::{log, sleep_ms}; + use super::*; use crate::burnchains::burnchain::*; use crate::burnchains::*; use crate::chainstate::stacks::test::*; @@ -5802,16 +5773,6 @@ mod test { use crate::net::test::*; use crate::net::*; use crate::util_lib::test::*; - use clarity::vm::types::StacksAddressExtensions; - use stacks_common::types::chainstate::BurnchainHeaderHash; - use stacks_common::util::log; - use stacks_common::util::secp256k1::Secp256k1PrivateKey; - use stacks_common::util::sleep_ms; - - use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; - use clarity::vm::MAX_CALL_STACK_DEPTH; - - use super::*; fn make_random_peer_address() -> PeerAddress { let mut rng = rand::thread_rng(); diff --git a/stackslib/src/net/poll.rs b/stackslib/src/net/poll.rs index c534f2413..6b26265ec 100644 --- a/stackslib/src/net/poll.rs +++ b/stackslib/src/net/poll.rs @@ -14,39 +14,19 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::net::Error as net_error; -use crate::net::Neighbor; -use crate::net::NeighborKey; -use crate::net::PeerAddress; - -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; - -use std::collections::HashMap; -use std::collections::HashSet; -use std::io; -use std::io::Error as io_error; -use std::io::ErrorKind; -use std::io::Read; -use std::io::Write; -use std::net; -use std::net::SocketAddr; -use std::time; +use std::collections::{HashMap, HashSet}; +use std::io::{Error as io_error, ErrorKind, Read, Write}; +use std::net::{Shutdown, SocketAddr}; use std::time::Duration; +use std::{io, net, time}; -use stacks_common::util::log; -use stacks_common::util::sleep_ms; - -use mio; -use mio::net as mio_net; -use mio::PollOpt; -use mio::Ready; -use mio::Token; - -use std::net::Shutdown; - -use rand; +use mio::{net as mio_net, PollOpt, Ready, Token}; use rand::RngCore; +use stacks_common::util::{log, sleep_ms}; +use {mio, rand}; + +use crate::net::{Error as net_error, Neighbor, NeighborKey, PeerAddress}; +use crate::util_lib::db::{DBConn, Error as db_error}; const SERVER: Token = mio::Token(0); @@ -467,15 +447,13 @@ impl NetworkState { #[cfg(test)] mod test { - use super::*; - use mio; - use mio::net as mio_net; - use mio::PollOpt; - use mio::Ready; - use mio::Token; - use std::collections::HashSet; + use mio; + use mio::{net as mio_net, PollOpt, Ready, Token}; + + use super::*; + #[test] fn test_bind() { let mut ns = NetworkState::new(100).unwrap(); diff --git a/stackslib/src/net/prune.rs b/stackslib/src/net/prune.rs index 214bfe258..7447a87e3 100644 --- a/stackslib/src/net/prune.rs +++ b/stackslib/src/net/prune.rs @@ -14,40 +14,24 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::net::p2p::*; -/// This module contains the logic for pruning client and neighbor connections -use crate::net::*; - -use crate::net::Error as net_error; - -use crate::net::connection::ConnectionOptions; - -use crate::net::chat::NeighborStats; - -use crate::net::poll::NetworkPollState; -use crate::net::poll::NetworkState; - -use crate::net::db::LocalPeer; -use crate::net::db::PeerDB; - -use crate::net::neighbors::*; - -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; - -use std::net::Shutdown; -use std::net::SocketAddr; - use std::cmp::Ordering; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; - -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::log; +use std::collections::{HashMap, HashSet, VecDeque}; +use std::net::{Shutdown, SocketAddr}; use rand::prelude::*; use rand::thread_rng; +use stacks_common::util::{get_epoch_time_secs, log}; + +use crate::net::chat::NeighborStats; +use crate::net::connection::ConnectionOptions; +use crate::net::db::{LocalPeer, PeerDB}; +use crate::net::neighbors::*; +use crate::net::p2p::*; +use crate::net::poll::{NetworkPollState, NetworkState}; +use crate::net::Error as net_error; +/// This module contains the logic for pruning client and neighbor connections +use crate::net::*; +use crate::util_lib::db::{DBConn, Error as db_error}; impl PeerNetwork { /// Find out which organizations have which of our outbound neighbors. diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs index 42b7c01a8..50de37d3c 100644 --- a/stackslib/src/net/relay.rs +++ b/stackslib/src/net/relay.rs @@ -14,30 +14,35 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::cmp; -use std::collections::BTreeMap; -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::mem; +use std::collections::{BTreeMap, HashMap, HashSet, VecDeque}; +use std::{cmp, mem}; +use clarity::vm::ast::errors::{ParseError, ParseErrors}; +use clarity::vm::ast::{ast_check_size, ASTRules}; +use clarity::vm::costs::ExecutionCost; +use clarity::vm::errors::RuntimeErrorType; +use clarity::vm::types::{QualifiedContractIdentifier, StacksAddressExtensions}; +use clarity::vm::ClarityVersion; use rand::prelude::*; -use rand::thread_rng; -use rand::Rng; +use rand::{thread_rng, Rng}; +use stacks_common::codec::MAX_PAYLOAD_LEN; +use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId, SortitionId, StacksBlockId}; +use stacks_common::types::StacksEpochId; +use stacks_common::util::get_epoch_time_secs; +use stacks_common::util::hash::Sha512Trunc256Sum; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; +use crate::burnchains::{Burnchain, BurnchainView}; use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleConn}; -use crate::chainstate::burn::BlockSnapshot; -use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::burn::{BlockSnapshot, ConsensusHash}; use crate::chainstate::coordinator::comm::CoordinatorChannels; +use crate::chainstate::coordinator::BlockEventDispatcher; +use crate::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState; use crate::chainstate::stacks::db::{StacksChainState, StacksEpochReceipt, StacksHeaderInfo}; use crate::chainstate::stacks::events::StacksTransactionReceipt; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::TransactionPayload; +use crate::chainstate::stacks::{StacksBlockHeader, TransactionPayload}; use crate::clarity_vm::clarity::Error as clarity_error; -use crate::core::mempool::MemPoolDB; -use crate::core::mempool::*; +use crate::core::mempool::{MemPoolDB, *}; +use crate::monitoring::update_stacks_tip_height; use crate::net::chat::*; use crate::net::connection::*; use crate::net::db::*; @@ -48,25 +53,7 @@ use crate::net::rpc::*; use crate::net::stackerdb::{ StackerDBConfig, StackerDBEventDispatcher, StackerDBSyncResult, StackerDBs, }; -use crate::net::Error as net_error; -use crate::net::*; -use clarity::vm::ast::errors::{ParseError, ParseErrors}; -use clarity::vm::ast::{ast_check_size, ASTRules}; -use clarity::vm::costs::ExecutionCost; -use clarity::vm::errors::RuntimeErrorType; -use clarity::vm::types::{QualifiedContractIdentifier, StacksAddressExtensions}; -use clarity::vm::ClarityVersion; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::Sha512Trunc256Sum; - -use crate::chainstate::coordinator::BlockEventDispatcher; -use crate::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState; -use crate::monitoring::update_stacks_tip_height; -use stacks_common::codec::MAX_PAYLOAD_LEN; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::{PoxId, SortitionId}; -use stacks_common::types::StacksEpochId; +use crate::net::{Error as net_error, *}; pub type BlocksAvailableMap = HashMap; @@ -2458,11 +2445,33 @@ pub mod test { use std::cell::RefCell; use std::collections::HashMap; + use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; + use clarity::vm::ast::ASTRules; + use clarity::vm::costs::LimitedCostTracker; + use clarity::vm::database::ClarityDatabase; + use clarity::vm::types::QualifiedContractIdentifier; + use clarity::vm::{ClarityVersion, MAX_CALL_STACK_DEPTH}; + use stacks_common::address::AddressHashMode; + use stacks_common::types::chainstate::{ + BlockHeaderHash, StacksBlockId, StacksWorkScore, TrieHash, + }; + use stacks_common::types::Address; + use stacks_common::util::hash::MerkleTree; + use stacks_common::util::sleep_ms; + use stacks_common::util::vrf::VRFProof; + + use super::*; use crate::burnchains::tests::TestMiner; - use crate::chainstate::stacks::db::blocks::MINIMUM_TX_FEE; - use crate::chainstate::stacks::db::blocks::MINIMUM_TX_FEE_RATE_PER_BYTE; - use crate::chainstate::stacks::Error as ChainstateError; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::db::blocks::{MINIMUM_TX_FEE, MINIMUM_TX_FEE_RATE_PER_BYTE}; + use crate::chainstate::stacks::miner::{BlockBuilderSettings, StacksMicroblockBuilder}; + use crate::chainstate::stacks::test::codec_all_transactions; + use crate::chainstate::stacks::tests::{ + make_coinbase, make_coinbase_with_nonce, make_smart_contract_with_version, + make_user_stacks_transfer, + }; + use crate::chainstate::stacks::{Error as ChainstateError, *}; + use crate::clarity_vm::clarity::ClarityConnection; + use crate::core::*; use crate::net::asn::*; use crate::net::chat::*; use crate::net::codec::*; @@ -2473,36 +2482,6 @@ pub mod test { use crate::net::test::*; use crate::net::*; use crate::util_lib::test::*; - use clarity::vm::costs::LimitedCostTracker; - use clarity::vm::database::ClarityDatabase; - use stacks_common::util::sleep_ms; - use stacks_common::util::vrf::VRFProof; - - use super::*; - use crate::clarity_vm::clarity::ClarityConnection; - use crate::core::*; - use clarity::vm::types::QualifiedContractIdentifier; - use clarity::vm::ClarityVersion; - use stacks_common::types::chainstate::BlockHeaderHash; - - use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; - use clarity::vm::ast::ASTRules; - use clarity::vm::MAX_CALL_STACK_DEPTH; - - use crate::chainstate::stacks::miner::BlockBuilderSettings; - use crate::chainstate::stacks::miner::StacksMicroblockBuilder; - use crate::chainstate::stacks::test::codec_all_transactions; - use crate::chainstate::stacks::tests::make_coinbase; - use crate::chainstate::stacks::tests::make_coinbase_with_nonce; - use crate::chainstate::stacks::tests::make_smart_contract_with_version; - use crate::chainstate::stacks::tests::make_user_stacks_transfer; - use crate::core::*; - use stacks_common::address::AddressHashMode; - use stacks_common::types::chainstate::StacksBlockId; - use stacks_common::types::chainstate::StacksWorkScore; - use stacks_common::types::chainstate::TrieHash; - use stacks_common::types::Address; - use stacks_common::util::hash::MerkleTree; #[test] fn test_relayer_stats_add_relyed_messages() { diff --git a/stackslib/src/net/rpc.rs b/stackslib/src/net/rpc.rs index 44c544742..699dac10c 100644 --- a/stackslib/src/net/rpc.rs +++ b/stackslib/src/net/rpc.rs @@ -14,131 +14,79 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::collections::HashMap; -use std::collections::HashSet; -use std::collections::VecDeque; -use std::io; +use std::collections::{HashMap, HashSet, VecDeque}; +use std::convert::TryFrom; use std::io::prelude::*; use std::io::{Read, Seek, SeekFrom, Write}; use std::net::SocketAddr; use std::time::Instant; -use std::{convert::TryFrom, fmt}; +use std::{fmt, io}; +use clarity::vm::analysis::errors::CheckErrors; +use clarity::vm::ast::ASTRules; +use clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; +use clarity::vm::database::clarity_store::{make_contract_hash_key, ContractCommitment}; +use clarity::vm::database::{ + BurnStateDB, ClarityDatabase, ClaritySerializable, STXBalance, StoreType, +}; +use clarity::vm::errors::Error::Unchecked; +use clarity::vm::errors::{Error as ClarityRuntimeError, InterpreterError}; +use clarity::vm::types::{ + PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, TraitIdentifier, +}; +use clarity::vm::{ClarityName, ClarityVersion, ContractName, SymbolicExpression, Value}; +use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData}; use rand::prelude::*; use rand::thread_rng; use rusqlite::{DatabaseName, NO_PARAMS}; - -use crate::burnchains::affirmation::AffirmationMap; -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; -use crate::burnchains::*; -use crate::chainstate::burn::db::sortdb::SortitionDB; -use crate::chainstate::burn::ConsensusHash; -use crate::chainstate::stacks::db::blocks::CheckError; -use crate::chainstate::stacks::db::{blocks::MINIMUM_TX_FEE_RATE_PER_BYTE, StacksChainState}; -use crate::chainstate::stacks::Error as chain_error; -use crate::chainstate::stacks::*; -use crate::clarity_vm::clarity::ClarityConnection; -use crate::core::mempool::*; -use crate::cost_estimates::metrics::CostMetric; -use crate::cost_estimates::CostEstimator; -use crate::cost_estimates::FeeEstimator; -use crate::monitoring; -use crate::net::atlas::{AtlasDB, Attachment, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST}; -use crate::net::connection::ConnectionHttp; -use crate::net::connection::ConnectionOptions; -use crate::net::connection::ReplyHandleHttp; -use crate::net::db::PeerDB; -use crate::net::http::*; -use crate::net::p2p::PeerMap; -use crate::net::p2p::PeerNetwork; -use crate::net::relay::Relayer; -use crate::net::stackerdb::StackerDBTx; -use crate::net::stackerdb::StackerDBs; -use crate::net::BlocksDatum; -use crate::net::Error as net_error; -use crate::net::HttpRequestMetadata; -use crate::net::HttpRequestType; -use crate::net::HttpResponseMetadata; -use crate::net::HttpResponseType; -use crate::net::MemPoolSyncData; -use crate::net::MicroblocksData; -use crate::net::NeighborAddress; -use crate::net::NeighborsData; -use crate::net::PeerAddress; -use crate::net::PeerHost; -use crate::net::ProtocolFamily; -use crate::net::RPCFeeEstimate; -use crate::net::RPCFeeEstimateResponse; -use crate::net::StackerDBPushChunkData; -use crate::net::StacksHttp; -use crate::net::StacksHttpMessage; -use crate::net::StacksMessageType; -use crate::net::StreamCursor; -use crate::net::UnconfirmedTransactionResponse; -use crate::net::UnconfirmedTransactionStatus; -use crate::net::UrlString; -use crate::net::HTTP_REQUEST_ID_RESERVED; -use crate::net::MAX_HEADERS; -use crate::net::MAX_NEIGHBORS_DATA_LEN; -use crate::net::{ - AccountEntryResponse, AttachmentPage, CallReadOnlyResponse, ConstantValResponse, - ContractSrcResponse, DataVarResponse, GetAttachmentResponse, GetAttachmentsInvResponse, - MapEntryResponse, -}; -use crate::net::{BlocksData, GetIsTraitImplementedResponse}; -use crate::net::{ClientError, TipRequest}; -use crate::net::{ - RPCAffirmationData, RPCLastPoxAnchorData, RPCPeerInfoData, RPCPoxContractVersion, - RPCPoxInfoData, -}; -use crate::net::{RPCNeighbor, RPCNeighborsInfo}; -use crate::util_lib::db::DBConn; -use crate::util_lib::db::Error as db_error; -use clarity::vm::database::clarity_store::make_contract_hash_key; -use clarity::vm::types::TraitIdentifier; -use clarity::vm::ClarityVersion; -use clarity::vm::{ - analysis::errors::CheckErrors, - ast::ASTRules, - costs::{ExecutionCost, LimitedCostTracker}, - database::{ - clarity_store::ContractCommitment, BurnStateDB, ClarityDatabase, ClaritySerializable, - STXBalance, StoreType, - }, - errors::Error as ClarityRuntimeError, - errors::Error::Unchecked, - errors::InterpreterError, - types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData}, - ClarityName, ContractName, SymbolicExpression, Value, -}; -use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData}; use stacks_common::codec::StacksMessageCodec; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::{hex_bytes, to_hex}; - -use crate::chainstate::stacks::boot::{POX_1_NAME, POX_2_NAME, POX_3_NAME}; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::clarity_vm::database::marf::MarfedKV; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress, StacksBlockId}; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, +}; use stacks_common::types::StacksPublicKeyBuffer; use stacks_common::util::chunked_encoding::*; +use stacks_common::util::get_epoch_time_secs; +use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha256Sum}; use stacks_common::util::secp256k1::MessageSignature; - -use crate::clarity_vm::clarity::Error as clarity_error; - -use crate::{ - chainstate::burn::operations::leader_block_commit::OUTPUTS_PER_COMMIT, version_string, -}; -use stacks_common::types; -use stacks_common::util; -use stacks_common::util::hash::Sha256Sum; - -use crate::util_lib::boot::boot_code_id; +use stacks_common::{types, util}; use super::{RPCPoxCurrentCycleInfo, RPCPoxNextCycleInfo}; +use crate::burnchains::affirmation::AffirmationMap; +use crate::burnchains::{Burnchain, BurnchainView, *}; +use crate::chainstate::burn::db::sortdb::SortitionDB; +use crate::chainstate::burn::operations::leader_block_commit::OUTPUTS_PER_COMMIT; +use crate::chainstate::burn::ConsensusHash; +use crate::chainstate::stacks::boot::{POX_1_NAME, POX_2_NAME, POX_3_NAME}; +use crate::chainstate::stacks::db::blocks::{CheckError, MINIMUM_TX_FEE_RATE_PER_BYTE}; +use crate::chainstate::stacks::db::StacksChainState; +use crate::chainstate::stacks::{Error as chain_error, StacksBlockHeader, *}; +use crate::clarity_vm::clarity::{ClarityConnection, Error as clarity_error}; +use crate::clarity_vm::database::marf::MarfedKV; +use crate::core::mempool::*; +use crate::cost_estimates::metrics::CostMetric; +use crate::cost_estimates::{CostEstimator, FeeEstimator}; +use crate::net::atlas::{AtlasDB, Attachment, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST}; +use crate::net::connection::{ConnectionHttp, ConnectionOptions, ReplyHandleHttp}; +use crate::net::db::PeerDB; +use crate::net::http::*; +use crate::net::p2p::{PeerMap, PeerNetwork}; +use crate::net::relay::Relayer; +use crate::net::stackerdb::{StackerDBTx, StackerDBs}; +use crate::net::{ + AccountEntryResponse, AttachmentPage, BlocksData, BlocksDatum, CallReadOnlyResponse, + ClientError, ConstantValResponse, ContractSrcResponse, DataVarResponse, Error as net_error, + GetAttachmentResponse, GetAttachmentsInvResponse, GetIsTraitImplementedResponse, + HttpRequestMetadata, HttpRequestType, HttpResponseMetadata, HttpResponseType, MapEntryResponse, + MemPoolSyncData, MicroblocksData, NeighborAddress, NeighborsData, PeerAddress, PeerHost, + ProtocolFamily, RPCAffirmationData, RPCFeeEstimate, RPCFeeEstimateResponse, + RPCLastPoxAnchorData, RPCNeighbor, RPCNeighborsInfo, RPCPeerInfoData, RPCPoxContractVersion, + RPCPoxInfoData, StackerDBPushChunkData, StacksHttp, StacksHttpMessage, StacksMessageType, + StreamCursor, TipRequest, UnconfirmedTransactionResponse, UnconfirmedTransactionStatus, + UrlString, HTTP_REQUEST_ID_RESERVED, MAX_HEADERS, MAX_NEIGHBORS_DATA_LEN, +}; +use crate::util_lib::boot::boot_code_id; +use crate::util_lib::db::{DBConn, Error as db_error}; +use crate::{monitoring, version_string}; pub const STREAM_CHUNK_SIZE: u64 = 4096; @@ -4001,37 +3949,31 @@ mod test { use std::convert::TryInto; use std::iter::FromIterator; + use clarity::vm::types::*; + use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE}; + use stacks_common::address::*; + use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; + use stacks_common::util::get_epoch_time_secs; + use stacks_common::util::hash::{hex_bytes, Sha512Trunc256Sum}; + use stacks_common::util::pipe::*; + + use super::*; use crate::burnchains::bitcoin::indexer::BitcoinIndexer; - use crate::burnchains::Burnchain; - use crate::burnchains::BurnchainView; - use crate::burnchains::*; + use crate::burnchains::{Burnchain, BurnchainView, *}; use crate::chainstate::burn::ConsensusHash; use crate::chainstate::stacks::db::blocks::test::*; use crate::chainstate::stacks::db::StacksChainState; use crate::chainstate::stacks::miner::*; use crate::chainstate::stacks::test::*; - use crate::chainstate::stacks::Error as chain_error; - use crate::chainstate::stacks::*; + use crate::chainstate::stacks::{ + Error as chain_error, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *, + }; + use crate::core::mempool::{BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS}; use crate::net::codec::*; use crate::net::http::*; use crate::net::stream::*; use crate::net::test::*; use crate::net::*; - use clarity::vm::types::*; - use libstackerdb::SlotMetadata; - use libstackerdb::STACKERDB_MAX_CHUNK_SIZE; - use stacks_common::address::*; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::hash::{hex_bytes, Sha512Trunc256Sum}; - use stacks_common::util::pipe::*; - - use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG; - use stacks_common::types::chainstate::BlockHeaderHash; - use stacks_common::types::chainstate::BurnchainHeaderHash; - - use crate::core::mempool::{BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS}; - - use super::*; const TEST_CONTRACT: &'static str = " (define-constant cst 123) diff --git a/stackslib/src/net/server.rs b/stackslib/src/net/server.rs index 306d4a72f..9e9694016 100644 --- a/stackslib/src/net/server.rs +++ b/stackslib/src/net/server.rs @@ -14,20 +14,17 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::io::Error as io_error; -use std::io::ErrorKind; -use std::io::{Read, Write}; +use std::collections::{HashMap, VecDeque}; +use std::io::{Error as io_error, ErrorKind, Read, Write}; +use std::sync::mpsc::{sync_channel, Receiver, RecvError, SendError, SyncSender, TryRecvError}; -use std::collections::HashMap; -use std::collections::VecDeque; - -use std::sync::mpsc::sync_channel; -use std::sync::mpsc::Receiver; -use std::sync::mpsc::RecvError; -use std::sync::mpsc::SendError; -use std::sync::mpsc::SyncSender; -use std::sync::mpsc::TryRecvError; +use mio::net as mio_net; +use stacks_common::util::get_epoch_time_secs; +use crate::burnchains::{Burnchain, BurnchainView}; +use crate::chainstate::burn::db::sortdb::SortitionDB; +use crate::chainstate::stacks::db::StacksChainState; +use crate::core::mempool::*; use crate::net::atlas::AtlasDB; use crate::net::connection::*; use crate::net::db::*; @@ -35,20 +32,7 @@ use crate::net::http::*; use crate::net::p2p::{PeerMap, PeerNetwork}; use crate::net::poll::*; use crate::net::rpc::*; -use crate::net::Error as net_error; -use crate::net::*; - -use crate::chainstate::burn::db::sortdb::SortitionDB; -use crate::chainstate::stacks::db::StacksChainState; - -use crate::burnchains::Burnchain; -use crate::burnchains::BurnchainView; - -use mio::net as mio_net; - -use stacks_common::util::get_epoch_time_secs; - -use crate::core::mempool::*; +use crate::net::{Error as net_error, *}; #[derive(Debug)] pub struct HttpPeer { @@ -719,50 +703,31 @@ impl HttpPeer { #[cfg(test)] mod test { + use std::cell::RefCell; + use std::net::{SocketAddr, TcpStream}; + use std::sync::mpsc::{sync_channel, Receiver, RecvError, SendError, SyncSender, TryRecvError}; + use std::thread; + + use clarity::vm::contracts::Contract; + use clarity::vm::representations::{ClarityName, ContractName}; + use clarity::vm::types::*; + use stacks_common::codec::MAX_MESSAGE_LEN; + use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash}; + use stacks_common::util::pipe::*; + use stacks_common::util::{get_epoch_time_secs, sleep_ms}; + use super::*; + use crate::burnchains::{Burnchain, BurnchainView, *}; + use crate::chainstate::burn::ConsensusHash; + use crate::chainstate::stacks::db::blocks::test::*; + use crate::chainstate::stacks::db::StacksChainState; + use crate::chainstate::stacks::test::*; + use crate::chainstate::stacks::{Error as chain_error, StacksBlockHeader, *, *}; use crate::net::codec::*; use crate::net::http::*; use crate::net::rpc::*; use crate::net::test::*; use crate::net::*; - use std::cell::RefCell; - - use crate::burnchains::Burnchain; - use crate::burnchains::BurnchainView; - use stacks_common::types::chainstate::BurnchainHeaderHash; - - use crate::burnchains::*; - use crate::chainstate::stacks::db::blocks::test::*; - use crate::chainstate::stacks::db::StacksChainState; - use crate::chainstate::stacks::test::*; - use crate::chainstate::stacks::Error as chain_error; - use crate::chainstate::stacks::*; - use crate::chainstate::stacks::*; - use stacks_common::types::chainstate::BlockHeaderHash; - - use std::sync::mpsc::sync_channel; - use std::sync::mpsc::Receiver; - use std::sync::mpsc::RecvError; - use std::sync::mpsc::SendError; - use std::sync::mpsc::SyncSender; - use std::sync::mpsc::TryRecvError; - - use std::thread; - - use std::net::SocketAddr; - use std::net::TcpStream; - - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::pipe::*; - use stacks_common::util::sleep_ms; - - use crate::chainstate::burn::ConsensusHash; - use crate::chainstate::stacks::StacksBlockHeader; - use clarity::vm::contracts::Contract; - use clarity::vm::representations::ClarityName; - use clarity::vm::representations::ContractName; - use clarity::vm::types::*; - use stacks_common::codec::MAX_MESSAGE_LEN; fn test_http_server( test_name: &str, diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs index 885d92c19..eba0b0586 100644 --- a/stackslib/src/net/stackerdb/config.rs +++ b/stackslib/src/net/stackerdb/config.rs @@ -37,33 +37,27 @@ use std::collections::{HashMap, HashSet}; use std::mem; -use crate::net::stackerdb::{ - StackerDBConfig, StackerDBs, STACKERDB_INV_MAX, STACKERDB_MAX_CHUNK_SIZE, +use clarity::vm::analysis::ContractAnalysis; +use clarity::vm::clarity::ClarityConnection; +use clarity::vm::database::BurnStateDB; +use clarity::vm::types::{ + BufferLength, FixedFunction, FunctionType, ListTypeData, PrincipalData, + QualifiedContractIdentifier, SequenceSubtype, StandardPrincipalData, TupleTypeSignature, + TypeSignature, }; - -use crate::net::Error as net_error; -use crate::net::NeighborAddress; -use crate::net::PeerAddress; +use clarity::vm::ClarityName; +use stacks_common::types::chainstate::{StacksAddress, StacksBlockId}; +use stacks_common::types::StacksEpochId; +use stacks_common::util::hash::Hash160; use crate::chainstate::burn::db::sortdb::SortitionDB; use crate::chainstate::stacks::db::StacksChainState; use crate::chainstate::stacks::Error as chainstate_error; - use crate::clarity_vm::clarity::{ClarityReadOnlyConnection, Error as clarity_error}; -use clarity::vm::analysis::ContractAnalysis; -use clarity::vm::clarity::ClarityConnection; -use clarity::vm::database::BurnStateDB; -use clarity::vm::types::QualifiedContractIdentifier; -use clarity::vm::types::StandardPrincipalData; -use clarity::vm::types::{ - BufferLength, FixedFunction, FunctionType, ListTypeData, PrincipalData, SequenceSubtype, - TupleTypeSignature, TypeSignature, +use crate::net::stackerdb::{ + StackerDBConfig, StackerDBs, STACKERDB_INV_MAX, STACKERDB_MAX_CHUNK_SIZE, }; -use clarity::vm::ClarityName; - -use stacks_common::types::chainstate::{StacksAddress, StacksBlockId}; -use stacks_common::types::StacksEpochId; -use stacks_common::util::hash::Hash160; +use crate::net::{Error as net_error, NeighborAddress, PeerAddress}; const MAX_HINT_REPLICAS: u32 = 128; diff --git a/stackslib/src/net/stackerdb/db.rs b/stackslib/src/net/stackerdb/db.rs index 4b4232f67..6034f3d05 100644 --- a/stackslib/src/net/stackerdb/db.rs +++ b/stackslib/src/net/stackerdb/db.rs @@ -14,38 +14,28 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::collections::HashMap; -use std::collections::HashSet; - -use std::fs; -use std::io; +use std::collections::{HashMap, HashSet}; use std::path::Path; +use std::{fs, io}; -use libstackerdb::SlotMetadata; -use libstackerdb::STACKERDB_MAX_CHUNK_SIZE; +use clarity::vm::types::QualifiedContractIdentifier; +use clarity::vm::ContractName; +use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE}; +use rusqlite::types::ToSql; +use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS}; +use stacks_common::types::chainstate::{ConsensusHash, StacksAddress}; +use stacks_common::util::get_epoch_time_secs; +use stacks_common::util::hash::Sha512Trunc256Sum; +use stacks_common::util::secp256k1::MessageSignature; use crate::chainstate::stacks::address::PoxAddress; use crate::net::stackerdb::{StackerDBConfig, StackerDBTx, StackerDBs, STACKERDB_INV_MAX}; -use crate::net::Error as net_error; -use crate::net::{StackerDBChunkData, StackerDBHandshakeData}; - -use rusqlite::{ - types::ToSql, Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS, -}; - +use crate::net::{Error as net_error, StackerDBChunkData, StackerDBHandshakeData}; use crate::util_lib::db::{ opt_u64_to_sql, query_row, query_row_panic, query_rows, sql_pragma, sqlite_open, tx_begin_immediate, tx_busy_handler, u64_to_sql, DBConn, Error as db_error, FromColumn, FromRow, }; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::secp256k1::MessageSignature; - -use clarity::vm::types::QualifiedContractIdentifier; -use clarity::vm::ContractName; const STACKER_DB_SCHEMA: &'static [&'static str] = &[ r#" diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs index 386254467..8520cec1f 100644 --- a/stackslib/src/net/stackerdb/mod.rs +++ b/stackslib/src/net/stackerdb/mod.rs @@ -118,36 +118,23 @@ pub mod config; pub mod db; pub mod sync; -use crate::net::Error as net_error; -use crate::net::NackData; -use crate::net::NackErrorCodes; -use crate::net::Neighbor; -use crate::net::NeighborAddress; -use crate::net::NeighborKey; -use crate::net::Preamble; -use crate::net::StackerDBChunkData; -use crate::net::StackerDBChunkInvData; -use crate::net::StackerDBGetChunkData; -use crate::net::StackerDBPushChunkData; -use crate::net::StacksMessage; -use crate::net::StacksMessageType; - -use crate::util_lib::db::{DBConn, DBTx}; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::secp256k1::MessageSignature; use std::collections::{HashMap, HashSet}; -use crate::net::neighbors::NeighborComms; - -use crate::net::p2p::PeerNetwork; - -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::util::get_epoch_time_secs; - -use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE}; - use clarity::vm::types::QualifiedContractIdentifier; +use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE}; +use stacks_common::types::chainstate::{ConsensusHash, StacksAddress}; +use stacks_common::util::get_epoch_time_secs; +use stacks_common::util::hash::Sha512Trunc256Sum; +use stacks_common::util::secp256k1::MessageSignature; + +use crate::net::neighbors::NeighborComms; +use crate::net::p2p::PeerNetwork; +use crate::net::{ + Error as net_error, NackData, NackErrorCodes, Neighbor, NeighborAddress, NeighborKey, Preamble, + StackerDBChunkData, StackerDBChunkInvData, StackerDBGetChunkData, StackerDBPushChunkData, + StacksMessage, StacksMessageType, +}; +use crate::util_lib::db::{DBConn, DBTx}; /// maximum chunk inventory size pub const STACKERDB_INV_MAX: u32 = 4096; diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs index 3c22df43d..a5d875d86 100644 --- a/stackslib/src/net/stackerdb/sync.rs +++ b/stackslib/src/net/stackerdb/sync.rs @@ -17,34 +17,26 @@ use std::collections::{HashMap, HashSet}; use std::mem; -use crate::net::stackerdb::{ - StackerDBConfig, StackerDBSync, StackerDBSyncResult, StackerDBSyncState, StackerDBs, -}; - -use crate::net::db::PeerDB; - -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::chainstate::StacksAddress; +use clarity::vm::types::QualifiedContractIdentifier; +use rand::prelude::SliceRandom; +use rand::{thread_rng, Rng, RngCore}; +use stacks_common::types::chainstate::{ConsensusHash, StacksAddress}; use stacks_common::util::get_epoch_time_secs; use stacks_common::util::hash::Hash160; use crate::net::chat::ConversationP2P; use crate::net::connection::ReplyHandleP2P; -use crate::net::p2p::PeerNetwork; -use crate::net::Error as net_error; -use crate::net::{ - NackData, Neighbor, NeighborAddress, NeighborKey, StackerDBChunkData, StackerDBChunkInvData, - StackerDBGetChunkData, StackerDBGetChunkInvData, StackerDBPushChunkData, StacksMessageType, -}; - +use crate::net::db::PeerDB; use crate::net::neighbors::NeighborComms; - -use clarity::vm::types::QualifiedContractIdentifier; - -use rand::prelude::SliceRandom; -use rand::thread_rng; -use rand::Rng; -use rand::RngCore; +use crate::net::p2p::PeerNetwork; +use crate::net::stackerdb::{ + StackerDBConfig, StackerDBSync, StackerDBSyncResult, StackerDBSyncState, StackerDBs, +}; +use crate::net::{ + Error as net_error, NackData, Neighbor, NeighborAddress, NeighborKey, StackerDBChunkData, + StackerDBChunkInvData, StackerDBGetChunkData, StackerDBGetChunkInvData, StackerDBPushChunkData, + StacksMessageType, +}; const MAX_CHUNKS_IN_FLIGHT: usize = 6; const MAX_DB_NEIGHBORS: usize = 32; diff --git a/stackslib/src/net/stackerdb/tests/config.rs b/stackslib/src/net/stackerdb/tests/config.rs index 1c63745b3..dec38e469 100644 --- a/stackslib/src/net/stackerdb/tests/config.rs +++ b/stackslib/src/net/stackerdb/tests/config.rs @@ -14,37 +14,26 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::burnchains::Burnchain; -use crate::core::StacksEpochExtension; -use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH; - -use crate::chainstate::stacks::boot::test::{ - instantiate_pox_peer, instantiate_pox_peer_with_epoch, -}; -use crate::chainstate::stacks::StacksTransaction; -use crate::chainstate::stacks::StacksTransactionSigner; -use crate::chainstate::stacks::TransactionAuth; -use crate::chainstate::stacks::TransactionPayload; -use crate::chainstate::stacks::TransactionVersion; - -use crate::net::test::TestEventObserver; -use crate::net::Error as net_error; -use crate::net::NeighborAddress; -use crate::net::PeerAddress; -use crate::net::StackerDBConfig; - -use clarity::vm::ClarityVersion; -use clarity::vm::ContractName; - +use clarity::vm::types::QualifiedContractIdentifier; +use clarity::vm::{ClarityVersion, ContractName}; use stacks_common::address::AddressHashMode; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::StacksPrivateKey; -use stacks_common::types::chainstate::StacksPublicKey; +use stacks_common::types::chainstate::{ + BurnchainHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey, +}; use stacks_common::types::StacksEpoch; use stacks_common::util::hash::Hash160; -use clarity::vm::types::QualifiedContractIdentifier; +use crate::burnchains::Burnchain; +use crate::chainstate::stacks::boot::test::{ + instantiate_pox_peer, instantiate_pox_peer_with_epoch, +}; +use crate::chainstate::stacks::{ + StacksTransaction, StacksTransactionSigner, TransactionAuth, TransactionPayload, + TransactionVersion, +}; +use crate::core::{StacksEpochExtension, BITCOIN_REGTEST_FIRST_BLOCK_HASH}; +use crate::net::test::TestEventObserver; +use crate::net::{Error as net_error, NeighborAddress, PeerAddress, StackerDBConfig}; fn make_smart_contract( name: &str, diff --git a/stackslib/src/net/stackerdb/tests/db.rs b/stackslib/src/net/stackerdb/tests/db.rs index 273274e83..7371b6b9c 100644 --- a/stackslib/src/net/stackerdb/tests/db.rs +++ b/stackslib/src/net/stackerdb/tests/db.rs @@ -17,26 +17,21 @@ use std::fs; use std::path::Path; -use crate::net::stackerdb::{db::SlotValidation, StackerDBConfig, StackerDBs}; -use libstackerdb::SlotMetadata; - -use crate::net::Error as net_error; -use crate::net::StackerDBChunkData; - +use clarity::vm::types::QualifiedContractIdentifier; use clarity::vm::ContractName; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::chainstate::StacksAddress; - -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::secp256k1::MessageSignature; - +use libstackerdb::SlotMetadata; use stacks_common::address::{ AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, }; -use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey}; +use stacks_common::types::chainstate::{ + ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey, +}; +use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum}; +use stacks_common::util::secp256k1::MessageSignature; -use clarity::vm::types::QualifiedContractIdentifier; +use crate::net::stackerdb::db::SlotValidation; +use crate::net::stackerdb::{StackerDBConfig, StackerDBs}; +use crate::net::{Error as net_error, StackerDBChunkData}; fn setup_test_path(path: &str) { let dirname = Path::new(path).parent().unwrap().to_str().unwrap(); diff --git a/stackslib/src/net/stackerdb/tests/sync.rs b/stackslib/src/net/stackerdb/tests/sync.rs index 87fd47f19..92187820c 100644 --- a/stackslib/src/net/stackerdb/tests/sync.rs +++ b/stackslib/src/net/stackerdb/tests/sync.rs @@ -16,39 +16,28 @@ use std::fs; -use crate::net::stackerdb::{db::SlotValidation, StackerDBConfig, StackerDBs}; -use libstackerdb::SlotMetadata; - -use crate::net::Error as net_error; -use crate::net::StackerDBChunkData; - +use clarity::vm::types::QualifiedContractIdentifier; use clarity::vm::ContractName; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::chainstate::StacksAddress; - -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::Sha512Trunc256Sum; -use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey}; - +use libstackerdb::SlotMetadata; +use rand::prelude::*; +use rand::seq::SliceRandom; +use rand::{thread_rng, Rng, RngCore}; use stacks_common::address::{ AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, }; -use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey}; - -use rand::prelude::*; -use rand::seq::SliceRandom; -use rand::thread_rng; -use rand::Rng; -use rand::RngCore; +use stacks_common::types::chainstate::{ + ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey, +}; +use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum}; +use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey}; use crate::net::relay::Relayer; -use crate::net::test::TestPeer; -use crate::net::test::TestPeerConfig; - +use crate::net::stackerdb::db::SlotValidation; +use crate::net::stackerdb::{StackerDBConfig, StackerDBs}; +use crate::net::test::{TestPeer, TestPeerConfig}; +use crate::net::{Error as net_error, StackerDBChunkData}; use crate::util_lib::test::with_timeout; -use clarity::vm::types::QualifiedContractIdentifier; - const BASE_PORT: u16 = 33000; // Minimum chunk size for FROST is 97 + T * 33, where T = 3000 diff --git a/stackslib/src/net/stream.rs b/stackslib/src/net/stream.rs index 55bac847d..b9f683cfc 100644 --- a/stackslib/src/net/stream.rs +++ b/stackslib/src/net/stream.rs @@ -17,22 +17,17 @@ use std::io; use std::io::{Read, Write}; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::StacksBlockId; +use rand::{thread_rng, Rng}; +use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId}; use crate::burnchains::Txid; -use crate::chainstate::stacks::{StacksBlock, StacksBlockHeader, StacksMicroblock}; - use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::Error as ChainstateError; - +use crate::chainstate::stacks::{ + Error as ChainstateError, StacksBlock, StacksBlockHeader, StacksMicroblock, +}; use crate::core::mempool::MemPoolDB; - use crate::net::MemPoolSyncData; -use rand::thread_rng; -use rand::Rng; - /// Interface for streaming data pub trait Streamer { /// Return the offset into the stream at which this Streamer points. This value is equivalent diff --git a/stackslib/src/net/tests/neighbors.rs b/stackslib/src/net/tests/neighbors.rs index 149988ff5..333543e7c 100644 --- a/stackslib/src/net/tests/neighbors.rs +++ b/stackslib/src/net/tests/neighbors.rs @@ -14,26 +14,23 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::core::PEER_VERSION_TESTNET; +use clarity::vm::types::{StacksAddressExtensions, StandardPrincipalData}; +use rand::prelude::*; +use rand::thread_rng; +use stacks_common::util::hash::*; +use stacks_common::util::sleep_ms; use crate::core::{ - StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, STACKS_EPOCH_MAX, + StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, + PEER_VERSION_TESTNET, STACKS_EPOCH_MAX, }; use crate::net::asn::*; use crate::net::chat::*; use crate::net::db::*; use crate::net::neighbors::*; use crate::net::test::*; -use crate::net::Error as net_error; -use crate::net::*; +use crate::net::{Error as net_error, *}; use crate::util_lib::test::*; -use clarity::vm::types::StacksAddressExtensions; -use clarity::vm::types::StandardPrincipalData; -use stacks_common::util::hash::*; -use stacks_common::util::sleep_ms; - -use rand::prelude::*; -use rand::thread_rng; const TEST_IN_OUT_DEGREES: u64 = 0x1; diff --git a/stackslib/src/net/tests/stream.rs b/stackslib/src/net/tests/stream.rs index 0edf612c9..31649fbf9 100644 --- a/stackslib/src/net/tests/stream.rs +++ b/stackslib/src/net/tests/stream.rs @@ -15,25 +15,17 @@ // along with this program. If not, see . use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::ConsensusHash; -use stacks_common::types::chainstate::StacksBlockId; -use stacks_common::types::chainstate::StacksPrivateKey; - -use crate::net::ExtendedStacksHeader; -use crate::net::StreamCursor; - -use crate::util_lib::db::DBConn; - -use crate::chainstate::stacks::db::StacksChainState; -use crate::chainstate::stacks::Error as chainstate_error; -use crate::chainstate::stacks::StacksBlock; -use crate::chainstate::stacks::StacksBlockHeader; -use crate::chainstate::stacks::StacksMicroblock; +use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, StacksPrivateKey}; use crate::chainstate::stacks::db::blocks::test::*; use crate::chainstate::stacks::db::test::instantiate_chainstate; - +use crate::chainstate::stacks::db::StacksChainState; +use crate::chainstate::stacks::{ + Error as chainstate_error, StacksBlock, StacksBlockHeader, StacksMicroblock, +}; use crate::core::MemPoolDB; +use crate::net::{ExtendedStacksHeader, StreamCursor}; +use crate::util_lib::db::DBConn; fn stream_one_header_to_vec( blocks_conn: &DBConn, diff --git a/stackslib/src/util_lib/bloom.rs b/stackslib/src/util_lib/bloom.rs index e3633288f..d34fca233 100644 --- a/stackslib/src/util_lib/bloom.rs +++ b/stackslib/src/util_lib/bloom.rs @@ -19,28 +19,15 @@ use std::collections::HashMap; use std::hash::Hasher; use std::io::{Read, Seek, SeekFrom, Write}; -use stacks_common::util::hash::Sha512Trunc256Sum; - -use siphasher::sip::SipHasher; // this is SipHash-2-4 - -use stacks_common::codec::Error as codec_error; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::codec::{read_next, write_next}; - -use crate::util_lib::db::query_expect_row; -use crate::util_lib::db::Error as db_error; -use crate::util_lib::db::{DBConn, DBTx}; - -use stacks_common::util::hash::to_hex; - -use rusqlite::blob::Blob; -use rusqlite::Error as sqlite_error; -use rusqlite::Row; -use rusqlite::ToSql; -use rusqlite::NO_PARAMS; - use rand::prelude::*; use rand::thread_rng; +use rusqlite::blob::Blob; +use rusqlite::{Error as sqlite_error, Row, ToSql, NO_PARAMS}; +use siphasher::sip::SipHasher; // this is SipHash-2-4 +use stacks_common::codec::{read_next, write_next, Error as codec_error, StacksMessageCodec}; +use stacks_common::util::hash::{to_hex, Sha512Trunc256Sum}; + +use crate::util_lib::db::{query_expect_row, DBConn, DBTx, Error as db_error}; /// A field of bits of known length! #[derive(Debug, Clone, PartialEq)] @@ -605,15 +592,13 @@ impl BloomHash for BloomNodeHasher { #[cfg(test)] pub mod test { - use super::*; - use std::fs; use rand::prelude::*; use rand::thread_rng; - use rusqlite::OpenFlags; + use super::*; use crate::util_lib::db::{sql_pragma, tx_begin_immediate, tx_busy_handler, DBConn, DBTx}; pub fn setup_bloom_counter(db_name: &str) -> DBConn { diff --git a/stackslib/src/util_lib/boot.rs b/stackslib/src/util_lib/boot.rs index b58016689..af3f44327 100644 --- a/stackslib/src/util_lib/boot.rs +++ b/stackslib/src/util_lib/boot.rs @@ -1,15 +1,16 @@ use std::convert::TryFrom; +use clarity::vm::database::STXBalance; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::ContractName; +use stacks_common::types::chainstate::StacksAddress; +use stacks_common::util::secp256k1::MessageSignature; + use crate::chainstate::stacks::db::StacksAccount; use crate::chainstate::stacks::{ SinglesigHashMode, SinglesigSpendingCondition, TransactionAuth, TransactionPublicKeyEncoding, TransactionSpendingCondition, }; -use clarity::vm::database::STXBalance; -use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; -use clarity::vm::ContractName; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::util::secp256k1::MessageSignature; pub fn boot_code_id(name: &str, mainnet: bool) -> QualifiedContractIdentifier { let addr = boot_code_addr(mainnet); diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs index 8409b154c..5d5f6226d 100644 --- a/stackslib/src/util_lib/db.rs +++ b/stackslib/src/util_lib/db.rs @@ -15,48 +15,28 @@ // along with this program. If not, see . use std::convert::TryInto; -use std::error; -use std::fmt; -use std::fs; -use std::io; use std::io::Error as IOError; -use std::ops::Deref; -use std::ops::DerefMut; -use std::path::Path; -use std::path::PathBuf; +use std::ops::{Deref, DerefMut}; +use std::path::{Path, PathBuf}; use std::time::Duration; - -use rand::thread_rng; -use rand::Rng; -use rand::RngCore; -use rusqlite::types::{FromSql, ToSql}; -use rusqlite::Connection; -use rusqlite::Error as sqlite_error; -use rusqlite::OpenFlags; -use rusqlite::OptionalExtension; -use rusqlite::Row; -use rusqlite::Transaction; -use rusqlite::TransactionBehavior; -use rusqlite::NO_PARAMS; -use serde_json::Error as serde_error; +use std::{error, fmt, fs, io}; use clarity::vm::types::QualifiedContractIdentifier; -use stacks_common::types::chainstate::SortitionId; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::types::chainstate::StacksBlockId; +use rand::{thread_rng, Rng, RngCore}; +use rusqlite::types::{FromSql, ToSql}; +use rusqlite::{ + Connection, Error as sqlite_error, OpenFlags, OptionalExtension, Row, Transaction, + TransactionBehavior, NO_PARAMS, +}; +use serde_json::Error as serde_error; +use stacks_common::types::chainstate::{SortitionId, StacksAddress, StacksBlockId, TrieHash}; use stacks_common::types::Address; use stacks_common::util::hash::to_hex; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; use stacks_common::util::sleep_ms; -use crate::chainstate::stacks::index::marf::MarfConnection; -use crate::chainstate::stacks::index::marf::MarfTransaction; -use crate::chainstate::stacks::index::marf::MARF; -use crate::chainstate::stacks::index::Error as MARFError; -use crate::chainstate::stacks::index::MARFValue; -use crate::chainstate::stacks::index::MarfTrieId; -use stacks_common::types::chainstate::TrieHash; +use crate::chainstate::stacks::index::marf::{MarfConnection, MarfTransaction, MARF}; +use crate::chainstate::stacks::index::{Error as MARFError, MARFValue, MarfTrieId}; pub type DBConn = rusqlite::Connection; pub type DBTx<'a> = rusqlite::Transaction<'a>; diff --git a/stackslib/src/util_lib/mod.rs b/stackslib/src/util_lib/mod.rs index 8d41c6027..85b09a3af 100644 --- a/stackslib/src/util_lib/mod.rs +++ b/stackslib/src/util_lib/mod.rs @@ -6,13 +6,12 @@ pub mod strings; #[cfg(test)] pub mod test { - use super::*; - use stacks_common::util::get_epoch_time_secs; - use stacks_common::util::sleep_ms; - use std::panic; - use std::process; use std::sync::mpsc::sync_channel; - use std::thread; + use std::{panic, process, thread}; + + use stacks_common::util::{get_epoch_time_secs, sleep_ms}; + + use super::*; pub fn with_timeout(timeout_secs: u64, test_func: F) where diff --git a/stackslib/src/util_lib/strings.rs b/stackslib/src/util_lib/strings.rs index 47291e192..cb4395627 100644 --- a/stackslib/src/util_lib/strings.rs +++ b/stackslib/src/util_lib/strings.rs @@ -16,17 +16,10 @@ use std::borrow::Borrow; use std::convert::TryFrom; -use std::fmt; -use std::io; use std::io::prelude::*; use std::io::{Read, Write}; -use std::ops::Deref; -use std::ops::DerefMut; - -use regex::Regex; -use url; - -use stacks_common::codec::Error as codec_error; +use std::ops::{Deref, DerefMut}; +use std::{fmt, io}; use clarity::vm::errors::RuntimeErrorType; use clarity::vm::representations::{ @@ -36,10 +29,13 @@ use clarity::vm::representations::{ use clarity::vm::types::{ PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, Value, }; -use stacks_common::codec::MAX_MESSAGE_LEN; +use regex::Regex; +use stacks_common::codec::{ + read_next, read_next_at_most, write_next, Error as codec_error, StacksMessageCodec, + MAX_MESSAGE_LEN, +}; use stacks_common::util::retry::BoundReader; - -use stacks_common::codec::{read_next, read_next_at_most, write_next, StacksMessageCodec}; +use url; lazy_static! { static ref URL_STRING_REGEX: Regex = @@ -326,12 +322,11 @@ impl UrlString { mod test { use std::error::Error; + use super::*; use crate::net::codec::test::check_codec_and_corruption; use crate::net::codec::*; use crate::net::*; - use super::*; - #[test] fn tx_stacks_strings_codec() { let s = "hello-world"; diff --git a/stx-genesis/build.rs b/stx-genesis/build.rs index bc8083856..710585c24 100644 --- a/stx-genesis/build.rs +++ b/stx-genesis/build.rs @@ -1,11 +1,8 @@ use std::fmt::Write as FmtWrite; -use std::fs; +use std::fs::File; +use std::io::{BufRead, BufReader, Read, Write}; use std::path::Path; -use std::{ - env, - fs::File, - io::{BufRead, BufReader, Read, Write}, -}; +use std::{env, fs}; use libflate::deflate; use sha2::{Digest, Sha256}; diff --git a/stx-genesis/src/lib.rs b/stx-genesis/src/lib.rs index dc287a36f..9d25704b7 100644 --- a/stx-genesis/src/lib.rs +++ b/stx-genesis/src/lib.rs @@ -1,5 +1,5 @@ -use std::io::{self, BufReader}; -use std::io::{prelude::*, Cursor, Lines}; +use std::io::prelude::*; +use std::io::{self, BufReader, Cursor, Lines}; use libflate::deflate::{self, Decoder}; diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs index 2076c0904..8f2ba1df5 100644 --- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs +++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs @@ -1,24 +1,19 @@ +use std::cmp; +use std::io::Cursor; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; +use std::time::Instant; + use async_h1::client; use async_std::io::ReadExt; use async_std::net::TcpStream; use base64::encode; use http_types::{Method, Request, Url}; -use std::io::Cursor; -use std::sync::{ - atomic::{AtomicBool, Ordering}, - Arc, -}; -use std::time::Instant; - use serde::Serialize; use serde_json::value::RawValue; - -use std::cmp; - -use super::super::operations::BurnchainOpSigner; -use super::super::Config; -use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError}; - +use stacks::burnchains::bitcoin::address::{ + BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType, SegwitBitcoinAddress, +}; use stacks::burnchains::bitcoin::indexer::{ BitcoinIndexer, BitcoinIndexerConfig, BitcoinIndexerRuntime, }; @@ -26,26 +21,22 @@ use stacks::burnchains::bitcoin::spv::SpvClient; use stacks::burnchains::bitcoin::BitcoinNetworkType; use stacks::burnchains::db::BurnchainDB; use stacks::burnchains::indexer::BurnchainIndexer; -use stacks::burnchains::BurnchainStateTransitionOps; -use stacks::burnchains::Error as burnchain_error; -use stacks::burnchains::PoxConstants; -use stacks::burnchains::PublicKey; use stacks::burnchains::{ - bitcoin::address::{ - BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType, SegwitBitcoinAddress, - }, - Txid, + Burnchain, BurnchainParameters, BurnchainStateTransitionOps, Error as burnchain_error, + PoxConstants, PublicKey, Txid, }; -use stacks::burnchains::{Burnchain, BurnchainParameters}; use stacks::chainstate::burn::db::sortdb::SortitionDB; use stacks::chainstate::burn::operations::{ BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, TransferStxOp, UserBurnSupportOp, }; +#[cfg(test)] +use stacks::chainstate::burn::Opcodes; use stacks::chainstate::coordinator::comm::CoordinatorChannels; #[cfg(test)] use stacks::chainstate::stacks::address::PoxAddress; use stacks::core::{StacksEpoch, StacksEpochId}; +use stacks::monitoring::{increment_btc_blocks_received_counter, increment_btc_ops_sent_counter}; use stacks_common::codec::StacksMessageCodec; use stacks_common::deps_common::bitcoin::blockdata::opcodes; use stacks_common::deps_common::bitcoin::blockdata::script::{Builder, Script}; @@ -53,21 +44,18 @@ use stacks_common::deps_common::bitcoin::blockdata::transaction::{ OutPoint, Transaction, TxIn, TxOut, }; use stacks_common::deps_common::bitcoin::network::encodable::ConsensusEncodable; +#[cfg(test)] +use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_deserialize; +use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder; +use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; +use stacks_common::types::chainstate::BurnchainHeaderHash; use stacks_common::util::hash::{hex_bytes, Hash160}; use stacks_common::util::secp256k1::Secp256k1PublicKey; use stacks_common::util::sleep_ms; -#[cfg(test)] -use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_deserialize; - -use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder; -use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash; - -use stacks::monitoring::{increment_btc_blocks_received_counter, increment_btc_ops_sent_counter}; - -#[cfg(test)] -use stacks::chainstate::burn::Opcodes; -use stacks_common::types::chainstate::BurnchainHeaderHash; +use super::super::operations::BurnchainOpSigner; +use super::super::Config; +use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError}; /// The number of bitcoin blocks that can have /// passed since the UTXO cache was last refreshed before diff --git a/testnet/stacks-node/src/burnchains/mocknet_controller.rs b/testnet/stacks-node/src/burnchains/mocknet_controller.rs index 7ae121ac3..0c1ae9c84 100644 --- a/testnet/stacks-node/src/burnchains/mocknet_controller.rs +++ b/testnet/stacks-node/src/burnchains/mocknet_controller.rs @@ -1,15 +1,16 @@ use std::collections::VecDeque; use std::time::Instant; +use clarity::vm::costs::ExecutionCost; use stacks::burnchains::bitcoin::BitcoinBlock; use stacks::burnchains::{ Burnchain, BurnchainBlock, BurnchainBlockHeader, BurnchainStateTransitionOps, Txid, }; use stacks::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx}; -use stacks::chainstate::burn::operations::DelegateStxOp; +use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; use stacks::chainstate::burn::operations::{ - leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS, BlockstackOperationType, LeaderBlockCommitOp, - LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp, + BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, + StackStxOp, TransferStxOp, UserBurnSupportOp, }; use stacks::chainstate::burn::BlockSnapshot; use stacks::core::{ @@ -23,7 +24,6 @@ use stacks_common::util::hash::Sha256Sum; use super::super::operations::BurnchainOpSigner; use super::super::Config; use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError}; -use clarity::vm::costs::ExecutionCost; /// MocknetController is simulating a simplistic burnchain. pub struct MocknetController { diff --git a/testnet/stacks-node/src/burnchains/mod.rs b/testnet/stacks-node/src/burnchains/mod.rs index f0badf789..5506cf623 100644 --- a/testnet/stacks-node/src/burnchains/mod.rs +++ b/testnet/stacks-node/src/burnchains/mod.rs @@ -1,24 +1,19 @@ pub mod bitcoin_regtest_controller; pub mod mocknet_controller; -pub use self::bitcoin_regtest_controller::BitcoinRegtestController; -pub use self::mocknet_controller::MocknetController; - -use super::operations::BurnchainOpSigner; - use std::fmt; use std::time::Instant; use stacks::burnchains; -use stacks::burnchains::BurnchainStateTransitionOps; -use stacks::burnchains::Txid; +use stacks::burnchains::{BurnchainStateTransitionOps, Txid}; use stacks::chainstate::burn::db::sortdb::SortitionDB; use stacks::chainstate::burn::operations::BlockstackOperationType; use stacks::chainstate::burn::BlockSnapshot; - use stacks::core::{StacksEpoch, StacksEpochId}; -pub use self::bitcoin_regtest_controller::make_bitcoin_indexer; +pub use self::bitcoin_regtest_controller::{make_bitcoin_indexer, BitcoinRegtestController}; +pub use self::mocknet_controller::MocknetController; +use super::operations::BurnchainOpSigner; #[derive(Debug)] pub enum Error { diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs index 3ef1a5803..30ebfb698 100644 --- a/testnet/stacks-node/src/config.rs +++ b/testnet/stacks-node/src/config.rs @@ -2,43 +2,33 @@ use std::convert::TryInto; use std::fs; use std::net::{SocketAddr, ToSocketAddrs}; use std::path::PathBuf; -use std::sync::Arc; -use std::sync::Mutex; - -use rand::RngCore; +use std::sync::{Arc, Mutex}; use clarity::vm::costs::ExecutionCost; use clarity::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier}; +use rand::RngCore; use stacks::burnchains::bitcoin::BitcoinNetworkType; -use stacks::burnchains::Burnchain; -use stacks::burnchains::{MagicBytes, BLOCKSTACK_MAGIC_MAINNET}; +use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET}; use stacks::chainstate::stacks::index::marf::MARFOpenOpts; use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode; -use stacks::chainstate::stacks::miner::BlockBuilderSettings; -use stacks::chainstate::stacks::miner::MinerStatus; +use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus}; use stacks::chainstate::stacks::MAX_BLOCK_LEN; use stacks::core::mempool::MemPoolWalkSettings; -use stacks::core::StacksEpoch; -use stacks::core::StacksEpochExtension; -use stacks::core::StacksEpochId; use stacks::core::{ - CHAIN_ID_MAINNET, CHAIN_ID_TESTNET, PEER_VERSION_MAINNET, PEER_VERSION_TESTNET, + StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET, + PEER_VERSION_MAINNET, PEER_VERSION_TESTNET, }; use stacks::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator; use stacks::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer; use stacks::cost_estimates::fee_scalar::ScalarFeeRateEstimator; -use stacks::cost_estimates::metrics::CostMetric; -use stacks::cost_estimates::metrics::ProportionalDotProduct; -use stacks::cost_estimates::CostEstimator; -use stacks::cost_estimates::FeeEstimator; -use stacks::cost_estimates::PessimisticEstimator; +use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct}; +use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator}; use stacks::net::atlas::AtlasConfig; use stacks::net::connection::ConnectionOptions; use stacks::net::{Neighbor, NeighborKey, PeerAddress}; use stacks_common::util::get_epoch_time_ms; use stacks_common::util::hash::hex_bytes; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; const DEFAULT_SATS_PER_VB: u64 = 50; const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs index 8849e8257..235627b06 100644 --- a/testnet/stacks-node/src/event_dispatcher.rs +++ b/testnet/stacks-node/src/event_dispatcher.rs @@ -5,43 +5,37 @@ use std::time::Duration; use async_h1::client; use async_std::net::TcpStream; -use http_types::{Method, Request, Url}; -use serde_json::json; - use clarity::vm::analysis::contract_interface_builder::build_contract_interface; use clarity::vm::costs::ExecutionCost; use clarity::vm::events::{FTEventType, NFTEventType, STXEventType}; use clarity::vm::types::{AssetIdentifier, QualifiedContractIdentifier, Value}; +use http_types::{Method, Request, Url}; +pub use libsigner::StackerDBChunksEvent; +use serde_json::json; use stacks::burnchains::{PoxConstants, Txid}; +use stacks::chainstate::burn::operations::BlockstackOperationType; +use stacks::chainstate::burn::ConsensusHash; use stacks::chainstate::coordinator::BlockEventDispatcher; use stacks::chainstate::stacks::address::PoxAddress; -use stacks::chainstate::stacks::db::StacksHeaderInfo; +use stacks::chainstate::stacks::db::accounts::MinerReward; +use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState; +use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo}; use stacks::chainstate::stacks::events::{ StacksTransactionEvent, StacksTransactionReceipt, TransactionOrigin, }; +use stacks::chainstate::stacks::miner::TransactionEvent; use stacks::chainstate::stacks::{ - db::accounts::MinerReward, db::MinerRewardInfo, StacksTransaction, + StacksBlock, StacksMicroblock, StacksTransaction, TransactionPayload, }; -use stacks::chainstate::stacks::{StacksBlock, StacksMicroblock}; -use stacks::core::mempool::MemPoolDropReason; -use stacks::core::mempool::MemPoolEventDispatcher; +use stacks::core::mempool::{MemPoolDropReason, MemPoolEventDispatcher}; +use stacks::libstackerdb::StackerDBChunkData; use stacks::net::atlas::{Attachment, AttachmentInstance}; +use stacks::net::stackerdb::StackerDBEventDispatcher; use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksBlockId}; use stacks_common::util::hash::bytes_to_hex; use super::config::{EventKeyType, EventObserverConfig}; -use stacks::chainstate::burn::operations::BlockstackOperationType; -use stacks::chainstate::burn::ConsensusHash; -use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState; -use stacks::chainstate::stacks::miner::TransactionEvent; -use stacks::chainstate::stacks::TransactionPayload; - -use stacks::net::stackerdb::StackerDBEventDispatcher; - -use stacks::libstackerdb::StackerDBChunkData; - -pub use libsigner::StackerDBChunksEvent; #[derive(Debug, Clone)] struct EventObserver { @@ -1066,13 +1060,14 @@ impl EventDispatcher { #[cfg(test)] mod test { - use crate::event_dispatcher::EventObserver; use clarity::vm::costs::ExecutionCost; use stacks::burnchains::{PoxConstants, Txid}; use stacks::chainstate::stacks::db::StacksHeaderInfo; use stacks::chainstate::stacks::StacksBlock; use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksBlockId}; + use crate::event_dispatcher::EventObserver; + #[test] fn build_block_processed_event() { let observer = EventObserver { diff --git a/testnet/stacks-node/src/keychain.rs b/testnet/stacks-node/src/keychain.rs index b3249f52b..7ea3b9055 100644 --- a/testnet/stacks-node/src/keychain.rs +++ b/testnet/stacks-node/src/keychain.rs @@ -2,18 +2,16 @@ use stacks::burnchains::BurnchainSigner; use stacks::chainstate::stacks::{ StacksPrivateKey, StacksPublicKey, StacksTransactionSigner, TransactionAuth, }; -use stacks_common::address::AddressHashMode; +use stacks_common::address::{ + AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, +}; use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::hash::{Hash160, Sha256Sum}; +use stacks_common::util::secp256k1::Secp256k1PublicKey; use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF}; use super::operations::BurnchainOpSigner; -use stacks_common::address::{ - C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, -}; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - /// A wrapper around a node's seed, coupled with operations for using it #[derive(Clone)] pub struct Keychain { @@ -198,23 +196,17 @@ mod tests { use stacks::burnchains::PrivateKey; use stacks::chainstate::stacks::{ - StacksPrivateKey, StacksPublicKey, StacksTransactionSigner, TransactionAuth, + StacksPrivateKey, StacksPublicKey, StacksTransaction, StacksTransactionSigner, + TokenTransferMemo, TransactionAuth, TransactionPayload, TransactionPostConditionMode, + TransactionVersion, }; use stacks_common::address::AddressHashMode; use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::hash::{Hash160, Sha256Sum}; use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF}; - use crate::operations::BurnchainOpSigner; - use super::Keychain; - - use stacks::chainstate::stacks::StacksTransaction; - use stacks::chainstate::stacks::TokenTransferMemo; - use stacks::chainstate::stacks::TransactionPayload; - use stacks::chainstate::stacks::TransactionPostConditionMode; - use stacks::chainstate::stacks::TransactionVersion; - + use crate::operations::BurnchainOpSigner; use crate::stacks_common::types::Address; /// Legacy implementation; kept around for testing diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs index 987b5e1f0..33f1214dc 100644 --- a/testnet/stacks-node/src/main.rs +++ b/testnet/stacks-node/src/main.rs @@ -35,6 +35,12 @@ pub mod run_loop; pub mod syncctl; pub mod tenure; +use std::convert::TryInto; +use std::{env, panic, process}; + +use backtrace::Backtrace; +use pico_args::Arguments; + pub use self::burnchains::{ BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController, }; @@ -45,15 +51,6 @@ pub use self::node::{ChainTip, Node}; pub use self::run_loop::{helium, neon}; pub use self::tenure::Tenure; -use pico_args::Arguments; -use std::env; - -use std::convert::TryInto; -use std::panic; -use std::process; - -use backtrace::Backtrace; - fn main() { panic::set_hook(Box::new(|panic_info| { error!("Process abort due to thread panic: {}", panic_info); @@ -66,8 +63,7 @@ fn main() { let pid = process::id(); eprintln!("Dumping core for pid {}", std::process::id()); - use libc::kill; - use libc::SIGQUIT; + use libc::{kill, SIGQUIT}; // *should* trigger a core dump, if you run `ulimit -c unlimited` first! unsafe { kill(pid.try_into().unwrap(), SIGQUIT) }; diff --git a/testnet/stacks-node/src/monitoring/prometheus.rs b/testnet/stacks-node/src/monitoring/prometheus.rs index 9342a8f8d..65c427d2b 100644 --- a/testnet/stacks-node/src/monitoring/prometheus.rs +++ b/testnet/stacks-node/src/monitoring/prometheus.rs @@ -1,9 +1,8 @@ use async_std::net::{TcpListener, TcpStream}; use async_std::prelude::*; use async_std::task; -use stacks::prometheus::{gather, Encoder, TextEncoder}; - use http_types::{Body, Response, StatusCode}; +use stacks::prometheus::{gather, Encoder, TextEncoder}; pub fn start_serving_prometheus_metrics(bind_address: String) { let addr = bind_address.clone(); diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs index 16ef13b0c..70aca0eb7 100644 --- a/testnet/stacks-node/src/neon_node.rs +++ b/testnet/stacks-node/src/neon_node.rs @@ -138,94 +138,79 @@ /// /// This file may be refactored in the future into a full-fledged module. use std::cmp; -use std::collections::HashMap; -use std::collections::VecDeque; +use std::collections::{HashMap, VecDeque}; use std::convert::{TryFrom, TryInto}; use std::default::Default; -use std::mem; use std::net::SocketAddr; +use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::mpsc::{Receiver, SyncSender, TrySendError}; -use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex}; +use std::sync::{Arc, Mutex}; +use std::thread::JoinHandle; use std::time::Duration; -use std::{thread, thread::JoinHandle}; +use std::{mem, thread}; +use clarity::vm::ast::ASTRules; use clarity::vm::costs::ExecutionCost; -use stacks::burnchains::{ - db::BurnchainHeaderReader, Burnchain, BurnchainParameters, BurnchainSigner, Txid, -}; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use stacks::burnchains::db::BurnchainHeaderReader; +use stacks::burnchains::{Burnchain, BurnchainParameters, BurnchainSigner, Txid}; use stacks::chainstate::burn::db::sortdb::SortitionDB; +use stacks::chainstate::burn::operations::leader_block_commit::{ + RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS, +}; use stacks::chainstate::burn::operations::{ - leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS}, BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, }; -use stacks::chainstate::burn::BlockSnapshot; -use stacks::chainstate::burn::ConsensusHash; +use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash}; use stacks::chainstate::coordinator::comm::CoordinatorChannels; use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider}; use stacks::chainstate::stacks::address::PoxAddress; use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap; -use stacks::chainstate::stacks::db::StacksHeaderInfo; -use stacks::chainstate::stacks::db::{StacksChainState, MINER_REWARD_MATURITY}; -use stacks::chainstate::stacks::Error as ChainstateError; -use stacks::chainstate::stacks::StacksPublicKey; -use stacks::chainstate::stacks::{ - miner::get_mining_spend_amount, miner::signal_mining_blocked, miner::signal_mining_ready, - miner::BlockBuilderSettings, miner::MinerStatus, miner::StacksMicroblockBuilder, - StacksBlockBuilder, StacksBlockHeader, +use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY}; +use stacks::chainstate::stacks::miner::{ + get_mining_spend_amount, signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, + MinerStatus, StacksMicroblockBuilder, }; use stacks::chainstate::stacks::{ - CoinbasePayload, StacksBlock, StacksMicroblock, StacksTransaction, StacksTransactionSigner, + CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader, + StacksMicroblock, StacksPublicKey, StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionPayload, TransactionVersion, }; use stacks::core::mempool::MemPoolDB; -use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH; -use stacks::core::STACKS_EPOCH_2_4_MARKER; -use stacks::cost_estimates::metrics::CostMetric; -use stacks::cost_estimates::metrics::UnitMetric; -use stacks::cost_estimates::UnitEstimator; -use stacks::cost_estimates::{CostEstimator, FeeEstimator}; +use stacks::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, STACKS_EPOCH_2_4_MARKER}; +use stacks::cost_estimates::metrics::{CostMetric, UnitMetric}; +use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator}; +use stacks::monitoring; use stacks::monitoring::{increment_stx_blocks_mined_counter, update_active_miners_count_gauge}; -use stacks::net::{ - atlas::{AtlasConfig, AtlasDB}, - db::{LocalPeer, PeerDB}, - dns::DNSClient, - dns::DNSResolver, - p2p::PeerNetwork, - relay::Relayer, - rpc::RPCHandlerArgs, - stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs}, - Error as NetError, NetworkResult, PeerAddress, PeerNetworkComms, ServiceFlags, -}; +use stacks::net::atlas::{AtlasConfig, AtlasDB}; +use stacks::net::db::{LocalPeer, PeerDB}; +use stacks::net::dns::{DNSClient, DNSResolver}; +use stacks::net::p2p::PeerNetwork; +use stacks::net::relay::Relayer; +use stacks::net::rpc::RPCHandlerArgs; +use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs}; +use stacks::net::{Error as NetError, NetworkResult, PeerAddress, PeerNetworkComms, ServiceFlags}; use stacks::util_lib::strings::{UrlString, VecDisplay}; use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::{ - BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, VRFSeed, + BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, + StacksPrivateKey, VRFSeed, }; use stacks_common::types::StacksEpochId; -use stacks_common::util::get_epoch_time_ms; -use stacks_common::util::get_epoch_time_secs; use stacks_common::util::hash::{to_hex, Hash160, Sha256Sum}; use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::vrf::VRFPublicKey; - -use crate::burnchains::bitcoin_regtest_controller::OngoingBlockCommit; -use crate::burnchains::bitcoin_regtest_controller::{addr2str, BitcoinRegtestController}; -use crate::burnchains::make_bitcoin_indexer; -use crate::run_loop::neon::Counters; -use crate::run_loop::neon::RunLoop; -use crate::run_loop::RegisteredKey; -use crate::ChainTip; +use stacks_common::util::vrf::{VRFProof, VRFPublicKey}; +use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs}; use super::{BurnchainController, Config, EventDispatcher, Keychain}; +use crate::burnchains::bitcoin_regtest_controller::{ + addr2str, BitcoinRegtestController, OngoingBlockCommit, +}; +use crate::burnchains::make_bitcoin_indexer; +use crate::run_loop::neon::{Counters, RunLoop}; +use crate::run_loop::RegisteredKey; use crate::syncctl::PoxSyncWatchdogComms; -use stacks::monitoring; - -use stacks_common::types::chainstate::{StacksBlockId, StacksPrivateKey}; -use stacks_common::util::vrf::VRFProof; - -use clarity::vm::ast::ASTRules; -use clarity::vm::types::PrincipalData; -use clarity::vm::types::QualifiedContractIdentifier; +use crate::ChainTip; pub const RELAYER_MAX_BUFFER: usize = 100; const VRF_MOCK_MINER_KEY: u64 = 1; diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs index a8023bc21..0e9f5aa11 100644 --- a/testnet/stacks-node/src/node.rs +++ b/testnet/stacks-node/src/node.rs @@ -1,12 +1,27 @@ +use std::collections::{HashMap, HashSet}; use std::convert::TryFrom; use std::default::Default; use std::net::SocketAddr; -use std::{collections::HashMap, collections::HashSet, env}; -use std::{thread, thread::JoinHandle, time}; +use std::thread::JoinHandle; +use std::{env, thread, time}; +use clarity::vm::database::BurnStateDB; +use rand::RngCore; +use stacks::burnchains::bitcoin::BitcoinNetworkType; +use stacks::burnchains::db::BurnchainDB; +use stacks::burnchains::{PoxConstants, Txid}; +use stacks::chainstate::burn::db::sortdb::SortitionDB; +use stacks::chainstate::burn::operations::leader_block_commit::{ + RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS, +}; +use stacks::chainstate::burn::operations::{ + BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, +}; use stacks::chainstate::burn::ConsensusHash; +use stacks::chainstate::stacks::address::PoxAddress; use stacks::chainstate::stacks::db::{ - ChainStateBootData, ClarityTx, StacksChainState, StacksHeaderInfo, + ChainStateBootData, ChainstateAccountBalance, ChainstateAccountLockup, ChainstateBNSName, + ChainstateBNSNamespace, ClarityTx, StacksChainState, StacksEpochReceipt, StacksHeaderInfo, }; use stacks::chainstate::stacks::events::{ StacksTransactionEvent, StacksTransactionReceipt, TransactionOrigin, @@ -15,54 +30,28 @@ use stacks::chainstate::stacks::{ CoinbasePayload, StacksBlock, StacksMicroblock, StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionPayload, TransactionVersion, }; -use stacks::chainstate::{burn::db::sortdb::SortitionDB, stacks::db::StacksEpochReceipt}; use stacks::core::mempool::MemPoolDB; use stacks::core::STACKS_EPOCH_2_1_MARKER; use stacks::cost_estimates::metrics::UnitMetric; use stacks::cost_estimates::UnitEstimator; -use stacks::net::atlas::AttachmentInstance; -use stacks::net::{ - atlas::{AtlasConfig, AtlasDB}, - db::PeerDB, - p2p::PeerNetwork, - rpc::RPCHandlerArgs, - stackerdb::StackerDBs, - Error as NetError, PeerAddress, -}; +use stacks::net::atlas::{AtlasConfig, AtlasDB, AttachmentInstance}; +use stacks::net::db::PeerDB; +use stacks::net::p2p::PeerNetwork; +use stacks::net::rpc::RPCHandlerArgs; +use stacks::net::stackerdb::StackerDBs; +use stacks::net::{Error as NetError, PeerAddress}; use stacks::util_lib::strings::UrlString; -use stacks::{ - burnchains::db::BurnchainDB, - burnchains::PoxConstants, - chainstate::burn::operations::{ - leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS}, - BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, - }, -}; -use stacks::{ - burnchains::Txid, - chainstate::stacks::db::{ - ChainstateAccountBalance, ChainstateAccountLockup, ChainstateBNSName, - ChainstateBNSNamespace, - }, -}; -use stacks_common::types::chainstate::TrieHash; -use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, VRFSeed}; +use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, TrieHash, VRFSeed}; use stacks_common::util::get_epoch_time_secs; use stacks_common::util::hash::Sha256Sum; use stacks_common::util::secp256k1::Secp256k1PrivateKey; use stacks_common::util::vrf::VRFPublicKey; -use crate::run_loop; -use crate::{genesis_data::USE_TEST_GENESIS_CHAINSTATE, run_loop::RegisteredKey}; - -use crate::burnchains::make_bitcoin_indexer; - use super::{BurnchainController, BurnchainTip, Config, EventDispatcher, Keychain, Tenure}; -use clarity::vm::database::BurnStateDB; -use stacks::burnchains::bitcoin::BitcoinNetworkType; - -use rand::RngCore; -use stacks::chainstate::stacks::address::PoxAddress; +use crate::burnchains::make_bitcoin_indexer; +use crate::genesis_data::USE_TEST_GENESIS_CHAINSTATE; +use crate::run_loop; +use crate::run_loop::RegisteredKey; #[derive(Debug, Clone)] pub struct ChainTip { diff --git a/testnet/stacks-node/src/run_loop/helium.rs b/testnet/stacks-node/src/run_loop/helium.rs index 436ff1bca..c7212d413 100644 --- a/testnet/stacks-node/src/run_loop/helium.rs +++ b/testnet/stacks-node/src/run_loop/helium.rs @@ -1,11 +1,11 @@ +use stacks::chainstate::stacks::db::ClarityTx; +use stacks_common::types::chainstate::BurnchainHeaderHash; + use super::RunLoopCallbacks; use crate::burnchains::Error as BurnchainControllerError; use crate::{ BitcoinRegtestController, BurnchainController, ChainTip, Config, MocknetController, Node, }; -use stacks::chainstate::stacks::db::ClarityTx; - -use stacks_common::types::chainstate::BurnchainHeaderHash; /// RunLoop is coordinating a simulated burnchain and some simulated nodes /// taking turns in producing blocks. diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs index 0f8c8ffb5..bc76a128c 100644 --- a/testnet/stacks-node/src/run_loop/mod.rs +++ b/testnet/stacks-node/src/run_loop/mod.rs @@ -1,25 +1,20 @@ pub mod helium; pub mod neon; -use crate::{BurnchainController, BurnchainTip, ChainTip, Tenure}; - -use stacks::chainstate::stacks::db::StacksChainState; -use stacks::chainstate::stacks::{ - TransactionAuth, TransactionPayload, TransactionSpendingCondition, -}; -use stacks_common::util::vrf::VRFPublicKey; - +use clarity::vm::costs::ExecutionCost; use clarity::vm::database::BurnStateDB; +use stacks::burnchains::{PoxConstants, Txid}; +use stacks::chainstate::stacks::db::StacksChainState; +use stacks::chainstate::stacks::events::StacksTransactionReceipt; +use stacks::chainstate::stacks::{ + StacksBlock, TransactionAuth, TransactionPayload, TransactionSpendingCondition, +}; +use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::util::vrf::VRFPublicKey; use crate::stacks::chainstate::coordinator::BlockEventDispatcher; use crate::stacks::chainstate::stacks::index::ClarityMarfTrieId; -use crate::EventDispatcher; -use clarity::vm::costs::ExecutionCost; -use stacks::burnchains::PoxConstants; -use stacks::burnchains::Txid; -use stacks::chainstate::stacks::events::StacksTransactionReceipt; -use stacks::chainstate::stacks::StacksBlock; -use stacks_common::types::chainstate::StacksBlockId; +use crate::{BurnchainController, BurnchainTip, ChainTip, EventDispatcher, Tenure}; macro_rules! info_blue { ($($arg:tt)*) => ({ diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs index b3bfe0785..3688acb15 100644 --- a/testnet/stacks-node/src/run_loop/neon.rs +++ b/testnet/stacks-node/src/run_loop/neon.rs @@ -1,19 +1,12 @@ -use std::cmp; -use std::sync::atomic::{AtomicBool, Ordering}; - #[cfg(test)] use std::sync::atomic::AtomicU64; - +use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::mpsc::sync_channel; - -use std::sync::Arc; -use std::sync::Mutex; -use std::thread; +use std::sync::{Arc, Mutex}; use std::thread::JoinHandle; +use std::{cmp, thread}; -use stacks_common::deps_common::ctrlc as termination; -use stacks_common::deps_common::ctrlc::SignalId; - +use libc; use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType}; use stacks::burnchains::Burnchain; use stacks::chainstate::burn::db::sortdb::SortitionDB; @@ -25,31 +18,29 @@ use stacks::chainstate::coordinator::{ ChainsCoordinatorConfig, CoordinatorCommunication, Error as coord_error, }; use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState}; +use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus}; use stacks::core::StacksEpochId; use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment}; use stacks::util_lib::db::Error as db_error; +use stacks_common::deps_common::ctrlc as termination; +use stacks_common::deps_common::ctrlc::SignalId; +use stacks_common::types::PublicKey; +use stacks_common::util::hash::Hash160; +use stacks_common::util::{get_epoch_time_secs, sleep_ms}; use stx_genesis::GenesisData; use super::RunLoopCallbacks; use crate::burnchains::make_bitcoin_indexer; use crate::monitoring::start_serving_monitoring_metrics; -use crate::neon_node::Globals; -use crate::neon_node::StacksNode; -use crate::neon_node::BLOCK_PROCESSOR_STACK_SIZE; -use crate::neon_node::RELAYER_MAX_BUFFER; -use crate::node::use_test_genesis_chainstate; +use crate::neon_node::{Globals, StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER}; +use crate::node::{ + get_account_balances, get_account_lockups, get_names, get_namespaces, + use_test_genesis_chainstate, +}; use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms}; use crate::{ - node::{get_account_balances, get_account_lockups, get_names, get_namespaces}, run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain, }; -use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus}; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::sleep_ms; - -use libc; -use stacks_common::types::PublicKey; -use stacks_common::util::hash::Hash160; pub const STDERR: i32 = 2; #[cfg(test)] diff --git a/testnet/stacks-node/src/stacks_events.rs b/testnet/stacks-node/src/stacks_events.rs index 882891398..f63b17a6a 100644 --- a/testnet/stacks-node/src/stacks_events.rs +++ b/testnet/stacks-node/src/stacks_events.rs @@ -1,11 +1,11 @@ +use std::io::prelude::*; +use std::io::BufReader; +use std::net::{TcpListener, TcpStream}; + use chrono::{SecondsFormat, Utc}; use lazy_static::lazy_static; use regex::Regex; use serde_json::{json, Value}; -use std::io::prelude::*; -use std::io::BufReader; -use std::net::TcpListener; -use std::net::TcpStream; const DEFAULT_ADDR: &str = "127.0.0.1:3700"; diff --git a/testnet/stacks-node/src/syncctl.rs b/testnet/stacks-node/src/syncctl.rs index 87b082f2a..85a3404c4 100644 --- a/testnet/stacks-node/src/syncctl.rs +++ b/testnet/stacks-node/src/syncctl.rs @@ -1,18 +1,14 @@ use std::collections::VecDeque; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::Arc; use stacks::burnchains::{Burnchain, Error as burnchain_error}; use stacks::chainstate::stacks::db::StacksChainState; -use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::sleep_ms; +use stacks_common::util::{get_epoch_time_secs, sleep_ms}; use crate::burnchains::BurnchainTip; use crate::Config; -use std::sync::{ - atomic::{AtomicBool, AtomicU64, Ordering}, - Arc, -}; - // amount of time to wait for an inv or download sync to complete. // These _really should_ complete before the PoX sync watchdog permits processing the next reward // cycle, so this number is intentionally high (like, there's something really wrong with your diff --git a/testnet/stacks-node/src/tenure.rs b/testnet/stacks-node/src/tenure.rs index 011e1fbcd..882a65d06 100644 --- a/testnet/stacks-node/src/tenure.rs +++ b/testnet/stacks-node/src/tenure.rs @@ -1,7 +1,3 @@ -/// Only used by the Helium (Mocknet) node -use super::node::ChainTip; -use super::{BurnchainTip, Config}; - use std::thread; use std::time::{Duration, Instant}; @@ -11,15 +7,20 @@ use stacks::burnchains::PoxConstants; use stacks::chainstate::burn::db::sortdb::SortitionDB; use stacks::chainstate::burn::db::sortdb::SortitionDBConn; use stacks::chainstate::stacks::db::StacksChainState; +use stacks::chainstate::stacks::miner::BlockBuilderSettings; use stacks::chainstate::stacks::{ - miner::BlockBuilderSettings, StacksBlock, StacksBlockBuilder, StacksMicroblock, - StacksPrivateKey, StacksPublicKey, StacksTransaction, + StacksBlock, StacksBlockBuilder, StacksMicroblock, StacksPrivateKey, StacksPublicKey, + StacksTransaction, }; use stacks::core::mempool::MemPoolDB; use stacks_common::types::chainstate::VRFSeed; use stacks_common::util::hash::Hash160; use stacks_common::util::vrf::VRFProof; +/// Only used by the Helium (Mocknet) node +use super::node::ChainTip; +use super::{BurnchainTip, Config}; + pub struct TenureArtifacts { pub anchored_block: StacksBlock, pub microblocks: Vec, diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs index ff9cc4576..fdb09dd22 100644 --- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs +++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs @@ -1,10 +1,8 @@ +use std::env; +use std::io::{BufRead, BufReader}; use std::process::{Child, Command, Stdio}; -use crate::config::InitialBalance; -use crate::helium::RunLoop; -use crate::tests::to_addr; -use crate::Config; - +use clarity::vm::costs::ExecutionCost; use stacks::chainstate::burn::operations::BlockstackOperationType::{ LeaderBlockCommit, LeaderKeyRegister, }; @@ -13,9 +11,10 @@ use stacks::core::StacksEpochId; use stacks_common::util::hash::hex_bytes; use super::PUBLISH_CONTRACT; -use clarity::vm::costs::ExecutionCost; -use std::env; -use std::io::{BufRead, BufReader}; +use crate::config::InitialBalance; +use crate::helium::RunLoop; +use crate::tests::to_addr; +use crate::Config; pub enum BitcoinCoreError { SpawnFailed(String), diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs index 50601eb3d..60577cb69 100644 --- a/testnet/stacks-node/src/tests/epoch_205.rs +++ b/testnet/stacks-node/src/tests/epoch_205.rs @@ -1,54 +1,40 @@ use std::collections::HashMap; -use std::env; -use std::sync::atomic::Ordering; -use std::thread; - -use clarity::vm::types::PrincipalData; -use clarity::vm::ContractName; -use stacks::burnchains::Burnchain; -use stacks::burnchains::Txid; -use stacks::chainstate::burn::operations::BlockstackOperationType; -use stacks::chainstate::stacks::db::StacksChainState; -use stacks::chainstate::stacks::StacksBlockHeader; -use stacks::chainstate::stacks::StacksPrivateKey; -use stacks::chainstate::stacks::StacksTransaction; -use stacks::chainstate::stacks::TransactionPayload; -use stacks::core::StacksEpoch; -use stacks::core::StacksEpochId; -use stacks::core::{ - PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1, -}; -use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::util::hash::hex_bytes; -use stacks_common::util::sleep_ms; use std::convert::TryFrom; - -use crate::config::EventKeyType; -use crate::config::EventObserverConfig; -use crate::config::InitialBalance; -use crate::neon; -use crate::tests::bitcoin_regtest::BitcoinCoreController; -use crate::tests::make_contract_call; -use crate::tests::make_contract_call_mblock_only; -use crate::tests::make_contract_publish; -use crate::tests::make_contract_publish_microblock_only; -use crate::tests::neon_integrations::*; -use crate::tests::run_until_burnchain_height; -use crate::tests::select_transactions_where; -use crate::tests::to_addr; -use crate::BitcoinRegtestController; -use crate::BurnchainController; -use crate::Keychain; -use stacks::core; +use std::sync::atomic::Ordering; +use std::{env, thread}; use clarity::vm::costs::ExecutionCost; +use clarity::vm::types::PrincipalData; +use clarity::vm::ContractName; +use stacks::burnchains::{Burnchain, Txid}; use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; -use stacks::chainstate::burn::operations::LeaderBlockCommitOp; +use stacks::chainstate::burn::operations::{BlockstackOperationType, LeaderBlockCommitOp}; use stacks::chainstate::stacks::address::PoxAddress; -use stacks_common::types::chainstate::VRFSeed; +use stacks::chainstate::stacks::db::StacksChainState; +use stacks::chainstate::stacks::{ + StacksBlockHeader, StacksPrivateKey, StacksTransaction, TransactionPayload, +}; +use stacks::core; +use stacks::core::{ + StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, + PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1, +}; +use stacks_common::codec::StacksMessageCodec; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, VRFSeed, +}; +use stacks_common::util::hash::hex_bytes; +use stacks_common::util::sleep_ms; + +use crate::config::{EventKeyType, EventObserverConfig, InitialBalance}; +use crate::tests::bitcoin_regtest::BitcoinCoreController; +use crate::tests::neon_integrations::*; +use crate::tests::{ + make_contract_call, make_contract_call_mblock_only, make_contract_publish, + make_contract_publish_microblock_only, run_until_burnchain_height, select_transactions_where, + to_addr, +}; +use crate::{neon, BitcoinRegtestController, BurnchainController, Keychain}; #[test] #[ignore] diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs index 12f00bf06..fb7391696 100644 --- a/testnet/stacks-node/src/tests/epoch_21.rs +++ b/testnet/stacks-node/src/tests/epoch_21.rs @@ -1,75 +1,50 @@ -use std::collections::HashMap; -use std::collections::HashSet; -use std::env; -use std::thread; - -use stacks::burnchains::Burnchain; -use stacks::chainstate::stacks::db::StacksChainState; -use stacks::chainstate::stacks::StacksBlockHeader; -use stacks_common::types::chainstate::StacksAddress; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; - -use crate::config::Config; -use crate::config::EventKeyType; -use crate::config::EventObserverConfig; -use crate::config::InitialBalance; -use crate::neon; -use crate::neon::RunLoopCounter; -use crate::tests::bitcoin_regtest::BitcoinCoreController; -use crate::tests::neon_integrations::*; -use crate::tests::*; -use crate::BitcoinRegtestController; -use crate::BurnchainController; -use stacks::core; - -use stacks::chainstate::burn::db::sortdb::SortitionDB; -use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS; -use stacks::chainstate::burn::operations::leader_block_commit::OUTPUTS_PER_COMMIT; -use stacks::chainstate::burn::operations::BlockstackOperationType; -use stacks::chainstate::burn::operations::LeaderBlockCommitOp; -use stacks::chainstate::burn::operations::PreStxOp; -use stacks::chainstate::burn::operations::TransferStxOp; - -use stacks::chainstate::stacks::address::PoxAddress; +use std::collections::{HashMap, HashSet}; +use std::{env, thread}; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::ClarityVersion; use stacks::burnchains::bitcoin::address::{ BitcoinAddress, LegacyBitcoinAddressType, SegwitBitcoinAddress, }; use stacks::burnchains::bitcoin::BitcoinNetworkType; -use stacks::burnchains::PoxConstants; -use stacks::burnchains::Txid; +use stacks::burnchains::{Burnchain, PoxConstants, Txid}; +use stacks::chainstate::burn::db::sortdb::SortitionDB; +use stacks::chainstate::burn::operations::leader_block_commit::{ + BURN_BLOCK_MINED_AT_MODULUS, OUTPUTS_PER_COMMIT, +}; +use stacks::chainstate::burn::operations::{ + BlockstackOperationType, LeaderBlockCommitOp, PreStxOp, TransferStxOp, +}; +use stacks::chainstate::coordinator::comm::CoordinatorChannels; +use stacks::chainstate::stacks::address::PoxAddress; +use stacks::chainstate::stacks::db::StacksChainState; +use stacks::chainstate::stacks::miner::{ + set_mining_spend_amount, signal_mining_blocked, signal_mining_ready, +}; +use stacks::chainstate::stacks::StacksBlockHeader; +use stacks::clarity_cli::vm_execute as execute; +use stacks::core; +use stacks::core::BURNCHAIN_TX_SEARCH_WINDOW; +use stacks::util_lib::boot::boot_code_id; +use stacks_common::types::chainstate::{ + BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed, +}; +use stacks_common::types::PrivateKey; +use stacks_common::util::hash::{Hash160, Sha256Sum}; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; +use stacks_common::util::sleep_ms; +use crate::burnchains::bitcoin_regtest_controller::UTXO; +use crate::config::{Config, EventKeyType, EventObserverConfig, InitialBalance}; +use crate::neon::RunLoopCounter; +use crate::operations::BurnchainOpSigner; use crate::stacks_common::address::AddressHashMode; use crate::stacks_common::types::Address; use crate::stacks_common::util::hash::{bytes_to_hex, hex_bytes}; - -use stacks_common::types::chainstate::BlockHeaderHash; -use stacks_common::types::chainstate::BurnchainHeaderHash; -use stacks_common::types::chainstate::VRFSeed; -use stacks_common::types::PrivateKey; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::Sha256Sum; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use stacks::chainstate::coordinator::comm::CoordinatorChannels; -use stacks::chainstate::stacks::miner::set_mining_spend_amount; -use stacks::chainstate::stacks::miner::signal_mining_blocked; -use stacks::chainstate::stacks::miner::signal_mining_ready; - -use stacks::clarity_cli::vm_execute as execute; - -use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; -use clarity::vm::ClarityVersion; -use stacks::core::BURNCHAIN_TX_SEARCH_WINDOW; - -use crate::burnchains::bitcoin_regtest_controller::UTXO; -use crate::operations::BurnchainOpSigner; -use crate::Keychain; - -use stacks_common::util::sleep_ms; - -use stacks::util_lib::boot::boot_code_id; -use stacks_common::types::chainstate::StacksBlockId; +use crate::tests::bitcoin_regtest::BitcoinCoreController; +use crate::tests::neon_integrations::*; +use crate::tests::*; +use crate::{neon, BitcoinRegtestController, BurnchainController, Keychain}; const MINER_BURN_PUBLIC_KEY: &'static str = "03dc62fe0b8964d01fc9ca9a5eec0e22e557a12cc656919e648f04e0b26fea5faa"; diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs index a0bab09e5..4e817452b 100644 --- a/testnet/stacks-node/src/tests/epoch_22.rs +++ b/testnet/stacks-node/src/tests/epoch_22.rs @@ -1,46 +1,32 @@ use std::collections::HashMap; -use std::env; -use std::thread; +use std::{env, thread}; -use stacks::burnchains::Burnchain; +use clarity::vm::types::PrincipalData; +use clarity::vm::ClarityVersion; +use stacks::burnchains::{Burnchain, PoxConstants}; use stacks::chainstate::stacks::address::PoxAddress; use stacks::chainstate::stacks::db::StacksChainState; -use stacks::chainstate::stacks::miner::signal_mining_blocked; -use stacks::chainstate::stacks::miner::signal_mining_ready; +use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready}; +use stacks::clarity_cli::vm_execute as execute; +use stacks::core; use stacks::core::STACKS_EPOCH_MAX; -use stacks_common::types::chainstate::StacksAddress; +use stacks::util_lib::boot::boot_code_id; +use stacks_common::types::chainstate::{StacksAddress, StacksBlockId}; use stacks_common::types::PrivateKey; +use stacks_common::util::hash::Hash160; +use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::sleep_ms; -use crate::config::EventKeyType; -use crate::config::EventObserverConfig; -use crate::config::InitialBalance; -use crate::neon; +use super::neon_integrations::get_account; +use crate::config::{EventKeyType, EventObserverConfig, InitialBalance}; use crate::neon_node::StacksNode; +use crate::stacks_common::types::Address; +use crate::stacks_common::util::hash::bytes_to_hex; use crate::tests::bitcoin_regtest::BitcoinCoreController; use crate::tests::epoch_21::wait_pox_stragglers; use crate::tests::neon_integrations::*; use crate::tests::*; -use crate::BitcoinRegtestController; -use crate::BurnchainController; -use stacks::core; - -use super::neon_integrations::get_account; -use crate::stacks_common::types::Address; -use crate::stacks_common::util::hash::bytes_to_hex; -use stacks::burnchains::PoxConstants; - -use stacks_common::util::hash::Hash160; -use stacks_common::util::secp256k1::Secp256k1PublicKey; - -use stacks::clarity_cli::vm_execute as execute; - -use clarity::vm::types::PrincipalData; -use clarity::vm::ClarityVersion; - -use stacks_common::util::sleep_ms; - -use stacks::util_lib::boot::boot_code_id; -use stacks_common::types::chainstate::StacksBlockId; +use crate::{neon, BitcoinRegtestController, BurnchainController}; #[test] #[ignore] diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs index 2b4d817e1..73a731a5b 100644 --- a/testnet/stacks-node/src/tests/epoch_23.rs +++ b/testnet/stacks-node/src/tests/epoch_23.rs @@ -14,28 +14,19 @@ // along with this program. If not, see . use std::collections::HashMap; -use std::env; -use std::thread; +use std::{env, thread}; -use clarity::vm::types::QualifiedContractIdentifier; -use stacks::burnchains::Burnchain; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use stacks::burnchains::{Burnchain, PoxConstants}; +use stacks::core; use stacks::core::STACKS_EPOCH_MAX; use stacks_common::util::sleep_ms; -use crate::config::EventKeyType; -use crate::config::EventObserverConfig; -use crate::config::InitialBalance; -use crate::neon; +use crate::config::{EventKeyType, EventObserverConfig, InitialBalance}; use crate::tests::bitcoin_regtest::BitcoinCoreController; use crate::tests::neon_integrations::*; use crate::tests::*; -use crate::BitcoinRegtestController; -use crate::BurnchainController; -use stacks::core; - -use stacks::burnchains::PoxConstants; - -use clarity::vm::types::PrincipalData; +use crate::{neon, BitcoinRegtestController, BurnchainController}; #[test] #[ignore] diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs index a3dd6f95e..97f974422 100644 --- a/testnet/stacks-node/src/tests/epoch_24.rs +++ b/testnet/stacks-node/src/tests/epoch_24.rs @@ -13,12 +13,9 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::config::{EventKeyType, EventObserverConfig, InitialBalance}; -use crate::tests::neon_integrations::{ - get_account, get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait, - submit_tx, test_observer, wait_for_runloop, -}; -use crate::tests::{make_contract_call, to_addr}; +use std::collections::HashMap; +use std::{env, thread}; + use clarity::boot_util::boot_code_id; use clarity::vm::types::PrincipalData; use clarity::vm::{ClarityVersion, Value}; @@ -28,23 +25,26 @@ use stacks::chainstate::stacks::address::PoxAddress; use stacks::chainstate::stacks::boot::RawRewardSetEntry; use stacks::chainstate::stacks::db::StacksChainState; use stacks::chainstate::stacks::{Error, StacksTransaction, TransactionPayload}; -use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, StacksPrivateKey}; -use stacks_common::util::hash::{bytes_to_hex, hex_bytes, Hash160}; -use stacks_common::util::secp256k1::Secp256k1PublicKey; -use std::collections::HashMap; -use std::{env, thread}; - -use crate::tests::bitcoin_regtest::BitcoinCoreController; -use crate::{neon, BitcoinRegtestController, BurnchainController}; use stacks::clarity_cli::vm_execute as execute; use stacks::core; - use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG}; use stacks_common::codec::StacksMessageCodec; use stacks_common::consts::STACKS_EPOCH_MAX; +use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, StacksPrivateKey}; use stacks_common::types::Address; +use stacks_common::util::hash::{bytes_to_hex, hex_bytes, Hash160}; +use stacks_common::util::secp256k1::Secp256k1PublicKey; use stacks_common::util::sleep_ms; +use crate::config::{EventKeyType, EventObserverConfig, InitialBalance}; +use crate::tests::bitcoin_regtest::BitcoinCoreController; +use crate::tests::neon_integrations::{ + get_account, get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait, + submit_tx, test_observer, wait_for_runloop, +}; +use crate::tests::{make_contract_call, to_addr}; +use crate::{neon, BitcoinRegtestController, BurnchainController}; + #[cfg(test)] pub fn get_reward_set_entries_at_block( state: &mut StacksChainState, diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs index 842b6baeb..ef20119a8 100644 --- a/testnet/stacks-node/src/tests/integrations.rs +++ b/testnet/stacks-node/src/tests/integrations.rs @@ -2,49 +2,44 @@ use std::collections::HashMap; use std::fmt::Write; use std::sync::Mutex; -use reqwest; - -use crate::config::InitialBalance; -use crate::helium::RunLoop; -use crate::tests::make_sponsored_stacks_transfer_on_testnet; +use clarity::vm::analysis::contract_interface_builder::{ + build_contract_interface, ContractInterface, +}; +use clarity::vm::analysis::mem_type_check; use clarity::vm::costs::ExecutionCost; -use clarity::vm::types::StacksAddressExtensions; -use clarity::vm::ClarityVersion; -use clarity::vm::{ - analysis::{ - contract_interface_builder::{build_contract_interface, ContractInterface}, - mem_type_check, - }, - types::{QualifiedContractIdentifier, ResponseData, TupleData}, - Value, +use clarity::vm::types::{ + QualifiedContractIdentifier, ResponseData, StacksAddressExtensions, TupleData, }; +use clarity::vm::{ClarityVersion, Value}; +use reqwest; use stacks::burnchains::Address; -use stacks::chainstate::stacks::db::blocks::MINIMUM_TX_FEE_RATE_PER_BYTE; +use stacks::chainstate::stacks::db::blocks::{MemPoolRejection, MINIMUM_TX_FEE_RATE_PER_BYTE}; +use stacks::chainstate::stacks::db::StacksChainState; use stacks::chainstate::stacks::{ - db::blocks::MemPoolRejection, db::StacksChainState, StacksBlockHeader, StacksPrivateKey, - StacksTransaction, + StacksBlockHeader, StacksPrivateKey, StacksTransaction, TokenTransferMemo, + TransactionContractCall, TransactionPayload, }; -use stacks::chainstate::stacks::{TokenTransferMemo, TransactionContractCall, TransactionPayload}; use stacks::clarity_vm::clarity::ClarityConnection; use stacks::core::mempool::MAXIMUM_MEMPOOL_TX_CHAINING; -use stacks::core::StacksEpoch; -use stacks::core::StacksEpochId; -use stacks::core::PEER_VERSION_EPOCH_2_0; -use stacks::core::PEER_VERSION_EPOCH_2_05; -use stacks::core::PEER_VERSION_EPOCH_2_1; -use stacks::net::GetIsTraitImplementedResponse; -use stacks::net::{AccountEntryResponse, CallReadOnlyRequestBody, ContractSrcResponse}; +use stacks::core::{ + StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, + PEER_VERSION_EPOCH_2_1, +}; +use stacks::net::{ + AccountEntryResponse, CallReadOnlyRequestBody, ContractSrcResponse, + GetIsTraitImplementedResponse, +}; use stacks_common::codec::StacksMessageCodec; -use stacks_common::types::chainstate::{StacksAddress, VRFSeed}; -use stacks_common::util::hash::Sha256Sum; -use stacks_common::util::hash::{hex_bytes, to_hex}; - -use stacks_common::types::chainstate::StacksBlockId; +use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, VRFSeed}; +use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum}; use super::{ make_contract_call, make_contract_publish, make_stacks_transfer, to_addr, ADDR_4, SK_1, SK_2, SK_3, }; +use crate::config::InitialBalance; +use crate::helium::RunLoop; +use crate::tests::make_sponsored_stacks_transfer_on_testnet; const OTHER_CONTRACT: &'static str = " (define-data-var x uint u0) diff --git a/testnet/stacks-node/src/tests/mempool.rs b/testnet/stacks-node/src/tests/mempool.rs index 1b65aa37e..d55c024aa 100644 --- a/testnet/stacks-node/src/tests/mempool.rs +++ b/testnet/stacks-node/src/tests/mempool.rs @@ -1,38 +1,35 @@ -use std::convert::From; -use std::convert::TryFrom; +use std::convert::{From, TryFrom}; use std::sync::Mutex; +use clarity::vm::costs::ExecutionCost; use clarity::vm::database::NULL_BURN_STATE_DB; -use clarity::vm::{ - representations::ContractName, types::PrincipalData, types::QualifiedContractIdentifier, - types::StandardPrincipalData, Value, -}; -use stacks::chainstate::stacks::TransactionAnchorMode; +use clarity::vm::representations::ContractName; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData}; +use clarity::vm::Value; +use stacks::chainstate::stacks::db::blocks::MemPoolRejection; use stacks::chainstate::stacks::{ - db::blocks::MemPoolRejection, Error as ChainstateError, StacksBlockHeader, - StacksMicroblockHeader, StacksPrivateKey, StacksPublicKey, StacksTransaction, - StacksTransactionSigner, TokenTransferMemo, TransactionAuth, TransactionPayload, - TransactionSpendingCondition, TransactionVersion, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, + Error as ChainstateError, StacksBlockHeader, StacksMicroblockHeader, StacksPrivateKey, + StacksPublicKey, StacksTransaction, StacksTransactionSigner, TokenTransferMemo, + TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionSpendingCondition, + TransactionVersion, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, }; use stacks::core::mempool::MemPoolDB; -use stacks::core::CHAIN_ID_TESTNET; +use stacks::core::{StacksEpochId, CHAIN_ID_TESTNET}; use stacks::cost_estimates::metrics::UnitMetric; use stacks::cost_estimates::UnitEstimator; use stacks::net::Error as NetError; use stacks_common::address::AddressHashMode; use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress}; -use stacks_common::util::{hash::*, secp256k1::*}; - -use crate::helium::RunLoop; -use crate::Keychain; -use clarity::vm::costs::ExecutionCost; -use stacks::core::StacksEpochId; +use stacks_common::util::hash::*; +use stacks_common::util::secp256k1::*; use super::{ make_coinbase, make_contract_call, make_contract_publish, make_poison, make_stacks_transfer, serialize_sign_standard_single_sig_tx_anchor_mode_version, to_addr, SK_1, SK_2, }; +use crate::helium::RunLoop; +use crate::Keychain; const FOO_CONTRACT: &'static str = "(define-public (foo) (ok 1)) (define-public (bar (x uint)) (ok x))"; diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs index b87ed2c73..03f61b5e4 100644 --- a/testnet/stacks-node/src/tests/mod.rs +++ b/testnet/stacks-node/src/tests/mod.rs @@ -2,41 +2,36 @@ use std::convert::TryInto; use std::sync::atomic::AtomicU64; use std::sync::Arc; -use rand::RngCore; - use clarity::vm::costs::ExecutionCost; use clarity::vm::database::BurnStateDB; use clarity::vm::events::STXEventType; use clarity::vm::types::PrincipalData; use clarity::vm::{ClarityName, ContractName, Value}; +use rand::RngCore; use stacks::chainstate::burn::ConsensusHash; +use stacks::chainstate::stacks::db::StacksChainState; use stacks::chainstate::stacks::events::StacksTransactionEvent; +use stacks::chainstate::stacks::miner::{BlockBuilderSettings, StacksMicroblockBuilder}; use stacks::chainstate::stacks::{ - db::StacksChainState, miner::BlockBuilderSettings, miner::StacksMicroblockBuilder, CoinbasePayload, StacksBlock, StacksMicroblock, StacksMicroblockHeader, StacksPrivateKey, StacksPublicKey, StacksTransaction, StacksTransactionSigner, TokenTransferMemo, TransactionAnchorMode, TransactionAuth, TransactionContractCall, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract, TransactionSpendingCondition, TransactionVersion, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, }; -use stacks::core::CHAIN_ID_TESTNET; +use stacks::core::{StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_TESTNET}; use stacks::util_lib::strings::StacksString; +use stacks_common::address::AddressHashMode; use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::get_epoch_time_secs; -use stacks_common::util::hash::hex_bytes; -use stacks_common::{address::AddressHashMode, util::hash::to_hex}; - -use crate::helium::RunLoop; -use crate::tests::neon_integrations::get_chain_info; -use crate::tests::neon_integrations::next_block_and_wait; -use crate::BitcoinRegtestController; -use stacks::core::StacksEpoch; -use stacks::core::StacksEpochExtension; -use stacks::core::StacksEpochId; +use stacks_common::util::hash::{hex_bytes, to_hex}; use super::burnchains::bitcoin_regtest_controller::ParsedUTXO; use super::Config; +use crate::helium::RunLoop; +use crate::tests::neon_integrations::{get_chain_info, next_block_and_wait}; +use crate::BitcoinRegtestController; mod atlas; mod bitcoin_regtest; diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs index 88fc30668..645476f2c 100644 --- a/testnet/stacks-node/src/tests/neon_integrations.rs +++ b/testnet/stacks-node/src/tests/neon_integrations.rs @@ -1,30 +1,37 @@ -use std::cmp; -use std::fs; +use std::collections::{HashMap, HashSet}; +use std::convert::TryFrom; use std::path::Path; -use std::sync::mpsc; -use std::sync::Arc; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{mpsc, Arc}; use std::time::{Duration, Instant}; -use std::{ - collections::HashMap, - collections::HashSet, - sync::atomic::{AtomicU64, Ordering}, -}; -use std::{env, thread}; - -use rusqlite::types::ToSql; +use std::{cmp, env, fs, thread}; +use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; +use clarity::vm::ast::ASTRules; use clarity::vm::costs::ExecutionCost; use clarity::vm::types::PrincipalData; -use clarity::vm::ClarityVersion; -use clarity::vm::Value; +use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value, MAX_CALL_STACK_DEPTH}; +use rand::Rng; +use rusqlite::types::ToSql; use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType}; use stacks::burnchains::bitcoin::BitcoinNetworkType; -use stacks::burnchains::Txid; -use stacks::burnchains::{Address, Burnchain, PoxConstants}; +use stacks::burnchains::db::BurnchainDB; +use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid}; +use stacks::chainstate::burn::db::sortdb::SortitionDB; use stacks::chainstate::burn::operations::{ BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp, }; +use stacks::chainstate::burn::ConsensusHash; use stacks::chainstate::coordinator::comm::CoordinatorChannels; +use stacks::chainstate::stacks::db::StacksChainState; +use stacks::chainstate::stacks::miner::{ + signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent, + TransactionSuccessEvent, +}; +use stacks::chainstate::stacks::{ + StacksBlock, StacksBlockHeader, StacksMicroblock, StacksMicroblockHeader, StacksPrivateKey, + StacksPublicKey, StacksTransaction, TransactionContractCall, TransactionPayload, +}; use stacks::clarity_cli::vm_execute as execute; use stacks::core; use stacks::core::{ @@ -35,71 +42,34 @@ use stacks::core::{ use stacks::net::atlas::{AtlasConfig, AtlasDB, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST}; use stacks::net::{ AccountEntryResponse, ContractSrcResponse, GetAttachmentResponse, GetAttachmentsInvResponse, - PostTransactionRequestBody, RPCPeerInfoData, StacksBlockAcceptedData, - UnconfirmedTransactionResponse, + PostTransactionRequestBody, RPCFeeEstimateResponse, RPCPeerInfoData, RPCPoxInfoData, + StacksBlockAcceptedData, UnconfirmedTransactionResponse, }; use stacks::util_lib::boot::boot_code_id; -use stacks::{ - burnchains::db::BurnchainDB, - chainstate::{burn::ConsensusHash, stacks::StacksMicroblock}, -}; -use stacks::{ - chainstate::stacks::{ - db::StacksChainState, StacksBlock, StacksBlockHeader, StacksMicroblockHeader, - StacksPrivateKey, StacksPublicKey, StacksTransaction, TransactionContractCall, - TransactionPayload, - }, - net::RPCPoxInfoData, - util_lib::db::query_row_columns, - util_lib::db::query_rows, - util_lib::db::u64_to_sql, -}; +use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql}; use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::{ BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, }; -use stacks_common::util::hash::Hash160; -use stacks_common::util::hash::{bytes_to_hex, hex_bytes, to_hex}; -use stacks_common::util::secp256k1::Secp256k1PrivateKey; -use stacks_common::util::secp256k1::Secp256k1PublicKey; +use stacks_common::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160}; +use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms}; -use crate::{ - burnchains::bitcoin_regtest_controller::BitcoinRPCRequest, - burnchains::bitcoin_regtest_controller::UTXO, config::EventKeyType, - config::EventObserverConfig, config::InitialBalance, neon, operations::BurnchainOpSigner, - syncctl::PoxSyncWatchdogComms, BitcoinRegtestController, BurnchainController, Config, - ConfigFile, Keychain, -}; - -use crate::util::hash::{MerkleTree, Sha512Trunc256Sum}; -use crate::util::secp256k1::MessageSignature; - -use rand::Rng; - use super::bitcoin_regtest::BitcoinCoreController; use super::{ make_contract_call, make_contract_publish, make_contract_publish_microblock_only, make_microblock, make_stacks_transfer, make_stacks_transfer_mblock_only, to_addr, ADDR_4, SK_1, SK_2, }; - -use crate::config::FeeEstimatorName; -use crate::tests::SK_3; -use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; -use clarity::vm::ast::ASTRules; -use clarity::vm::ClarityName; -use clarity::vm::ContractName; -use clarity::vm::MAX_CALL_STACK_DEPTH; -use stacks::chainstate::burn::db::sortdb::SortitionDB; -use stacks::chainstate::stacks::miner::{ - signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent, - TransactionSuccessEvent, -}; -use stacks::net::RPCFeeEstimateResponse; -use std::convert::TryFrom; - +use crate::burnchains::bitcoin_regtest_controller::{BitcoinRPCRequest, UTXO}; +use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance}; +use crate::operations::BurnchainOpSigner; use crate::stacks_common::types::PrivateKey; +use crate::syncctl::PoxSyncWatchdogComms; +use crate::tests::SK_3; +use crate::util::hash::{MerkleTree, Sha512Trunc256Sum}; +use crate::util::secp256k1::MessageSignature; +use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain}; fn inner_neon_integration_test_conf(seed: Option>) -> (Config, StacksAddress) { let mut conf = super::new_test_conf(); @@ -201,9 +171,8 @@ pub mod test_observer { use std::sync::Mutex; use std::thread; - use tokio; - use warp; use warp::Filter; + use {tokio, warp}; use crate::event_dispatcher::{MinedBlockEvent, MinedMicroblockEvent, StackerDBChunksEvent}; diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs index e1c4af5ab..788474085 100644 --- a/testnet/stacks-node/src/tests/signer.rs +++ b/testnet/stacks-node/src/tests/signer.rs @@ -2,33 +2,26 @@ use std::sync::mpsc::{channel, Receiver, Sender}; use std::time::Duration; use std::{env, thread}; -use crate::{ - config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance}, - neon, - tests::{ - bitcoin_regtest::BitcoinCoreController, - make_contract_publish, - neon_integrations::{ - neon_integration_test_conf, next_block_and_wait, submit_tx, wait_for_runloop, - }, - to_addr, - }, - BitcoinRegtestController, BurnchainController, -}; use clarity::vm::types::QualifiedContractIdentifier; use libsigner::{RunningSigner, Signer, StackerDBEventReceiver}; use stacks::chainstate::stacks::StacksPrivateKey; use stacks_common::types::chainstate::StacksAddress; -use stacks_signer::{ - config::Config as SignerConfig, - runloop::RunLoopCommand, - utils::{build_signer_config_tomls, build_stackerdb_contract}, -}; -use tracing_subscriber::{fmt, prelude::*, EnvFilter}; -use wsts::{ - state_machine::{coordinator::frost::Coordinator as FrostCoordinator, OperationResult}, - v2, +use stacks_signer::config::Config as SignerConfig; +use stacks_signer::runloop::RunLoopCommand; +use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract}; +use tracing_subscriber::prelude::*; +use tracing_subscriber::{fmt, EnvFilter}; +use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator; +use wsts::state_machine::OperationResult; +use wsts::v2; + +use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance}; +use crate::tests::bitcoin_regtest::BitcoinCoreController; +use crate::tests::neon_integrations::{ + neon_integration_test_conf, next_block_and_wait, submit_tx, wait_for_runloop, }; +use crate::tests::{make_contract_publish, to_addr}; +use crate::{neon, BitcoinRegtestController, BurnchainController}; // Helper struct for holding the btc and stx neon nodes #[allow(dead_code)] diff --git a/testnet/stacks-node/src/tests/stackerdb.rs b/testnet/stacks-node/src/tests/stackerdb.rs index 13371fd9d..a38f98b76 100644 --- a/testnet/stacks-node/src/tests/stackerdb.rs +++ b/testnet/stacks-node/src/tests/stackerdb.rs @@ -14,39 +14,23 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use std::env; -use std::thread; - -use super::bitcoin_regtest::BitcoinCoreController; -use crate::{ - burnchains::BurnchainController, - config::EventKeyType, - config::EventObserverConfig, - config::InitialBalance, - neon, - tests::{ - make_contract_publish, - neon_integrations::{ - neon_integration_test_conf, next_block_and_wait, submit_tx, test_observer, - wait_for_runloop, - }, - to_addr, - }, - BitcoinRegtestController, -}; - -use stacks::chainstate::stacks::StacksPrivateKey; +use std::{env, thread}; use clarity::vm::types::QualifiedContractIdentifier; - +use stacks::chainstate::stacks::StacksPrivateKey; use stacks::libstackerdb::{StackerDBChunkAckData, StackerDBChunkData}; - use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::hash::Sha512Trunc256Sum; +use {reqwest, serde_json}; -use serde_json; - -use reqwest; +use super::bitcoin_regtest::BitcoinCoreController; +use crate::burnchains::BurnchainController; +use crate::config::{EventKeyType, EventObserverConfig, InitialBalance}; +use crate::tests::neon_integrations::{ + neon_integration_test_conf, next_block_and_wait, submit_tx, test_observer, wait_for_runloop, +}; +use crate::tests::{make_contract_publish, to_addr}; +use crate::{neon, BitcoinRegtestController}; fn post_stackerdb_chunk( http_origin: &str,