diff --git a/applications/tari_app_grpc/src/conversions/block_header.rs b/applications/tari_app_grpc/src/conversions/block_header.rs index 0aef8815e7..c3a5db17b8 100644 --- a/applications/tari_app_grpc/src/conversions/block_header.rs +++ b/applications/tari_app_grpc/src/conversions/block_header.rs @@ -22,7 +22,7 @@ use std::convert::TryFrom; -use tari_common_types::types::BlindingFactor; +use tari_common_types::types::{BlindingFactor, FixedHash}; use tari_core::{blocks::BlockHeader, proof_of_work::ProofOfWork}; use tari_utilities::{ByteArray, Hashable}; @@ -40,12 +40,12 @@ impl From for grpc::BlockHeader { height: h.height, prev_hash: h.prev_hash, timestamp: datetime_to_timestamp(h.timestamp), - input_mr: h.input_mr, - output_mr: h.output_mr, + input_mr: h.input_mr.to_vec(), + output_mr: h.output_mr.to_vec(), output_mmr_size: h.output_mmr_size, - kernel_mr: h.kernel_mr, + kernel_mr: h.kernel_mr.to_vec(), kernel_mmr_size: h.kernel_mmr_size, - witness_mr: h.witness_mr, + witness_mr: h.witness_mr.to_vec(), total_kernel_offset: h.total_kernel_offset.to_vec(), total_script_offset: h.total_script_offset.to_vec(), nonce: h.nonce, @@ -81,11 +81,11 @@ impl TryFrom for BlockHeader { height: header.height, prev_hash: header.prev_hash, timestamp, - input_mr: header.input_mr, - output_mr: header.output_mr, - witness_mr: header.witness_mr, + input_mr: FixedHash::try_from(header.input_mr).map_err(|err| err.to_string())?, + output_mr: FixedHash::try_from(header.output_mr).map_err(|err| err.to_string())?, + witness_mr: FixedHash::try_from(header.witness_mr).map_err(|err| err.to_string())?, output_mmr_size: header.output_mmr_size, - kernel_mr: header.kernel_mr, + kernel_mr: FixedHash::try_from(header.kernel_mr).expect("Array size 32 cannot fail"), kernel_mmr_size: header.kernel_mmr_size, total_kernel_offset, total_script_offset, diff --git a/applications/tari_base_node/src/grpc/base_node_grpc_server.rs b/applications/tari_base_node/src/grpc/base_node_grpc_server.rs index 04e8fd6efa..4320d6b4b8 100644 --- a/applications/tari_base_node/src/grpc/base_node_grpc_server.rs +++ b/applications/tari_base_node/src/grpc/base_node_grpc_server.rs @@ -542,7 +542,7 @@ impl tari_rpc::base_node_server::BaseNode for BaseNodeGrpcServer { }; // construct response let block_hash = new_block.hash(); - let mining_hash = new_block.header.merged_mining_hash(); + let mining_hash = new_block.header.merged_mining_hash().to_vec(); let block: Option = Some( new_block .try_into() @@ -587,7 +587,7 @@ impl tari_rpc::base_node_server::BaseNode for BaseNodeGrpcServer { }; // construct response let block_hash = new_block.hash(); - let mining_hash = new_block.header.merged_mining_hash(); + let mining_hash = new_block.header.merged_mining_hash().to_vec(); let (header, block_body) = new_block.into_header_body(); let mut header_bytes = Vec::new(); @@ -599,7 +599,7 @@ impl tari_rpc::base_node_server::BaseNode for BaseNodeGrpcServer { header: header_bytes, block_body: block_body_bytes, merge_mining_hash: mining_hash, - utxo_mr: header.output_mr, + utxo_mr: header.output_mr.to_vec(), }; debug!(target: LOG_TARGET, "Sending GetNewBlockBlob response to client"); Ok(Response::new(response)) diff --git a/applications/tari_console_wallet/src/wallet_modes.rs b/applications/tari_console_wallet/src/wallet_modes.rs index 28833b53c7..197ff164b2 100644 --- a/applications/tari_console_wallet/src/wallet_modes.rs +++ b/applications/tari_console_wallet/src/wallet_modes.rs @@ -166,10 +166,8 @@ pub(crate) fn parse_command_file(script: String) -> Result, Exi // skip empty lines and 'comments' starting with # if !command.trim().is_empty() && !command.trim().starts_with('#') { let command_trimmed = cli_parse_prefix.to_owned() + " " + command.trim(); - println!("\ncommand: {}", command_trimmed); let parse_vec: Vec<&str> = command_trimmed.split(' ').collect(); let cli_parsed = Cli::try_parse_from(&parse_vec); - println!("cli_parsed: {:?}\n", cli_parsed); match cli_parsed { Ok(result) => { if let Some(sub_command) = result.command2 { diff --git a/base_layer/common_types/src/types/fixed_hash.rs b/base_layer/common_types/src/types/fixed_hash.rs index 1271044f80..efe9d3e078 100644 --- a/base_layer/common_types/src/types/fixed_hash.rs +++ b/base_layer/common_types/src/types/fixed_hash.rs @@ -26,12 +26,10 @@ use std::{ ops::{Deref, DerefMut}, }; -use digest::{consts::U32, generic_array, Digest}; +use digest::{consts::U32, generic_array}; use serde::{Deserialize, Serialize}; use tari_utilities::hex::{Hex, HexError}; -use crate::types::Blake256; - const ZERO_HASH: [u8; FixedHash::byte_size()] = [0u8; FixedHash::byte_size()]; #[derive(thiserror::Error, Debug)] @@ -53,12 +51,6 @@ impl FixedHash { pub fn as_slice(&self) -> &[u8] { &self.0 } - - /// Hashes the bytes and returns the resulting `FixedHash`. Generally only be used as a convenience function for - /// tests. - pub fn hash_bytes>(bytes: T) -> Self { - Blake256::default().chain(bytes).finalize().into() - } } impl From<[u8; FixedHash::byte_size()]> for FixedHash { diff --git a/base_layer/core/src/base_node/sync/horizon_state_sync/synchronizer.rs b/base_layer/core/src/base_node/sync/horizon_state_sync/synchronizer.rs index db13b79012..38f6858c88 100644 --- a/base_layer/core/src/base_node/sync/horizon_state_sync/synchronizer.rs +++ b/base_layer/core/src/base_node/sync/horizon_state_sync/synchronizer.rs @@ -335,7 +335,7 @@ impl<'a, B: BlockchainBackend + 'static> HorizonStateSynchronization<'a, B> { } let mmr_root = kernel_mmr.get_merkle_root()?; - if mmr_root != current_header.header().kernel_mr { + if mmr_root.as_slice() != current_header.header().kernel_mr.as_slice() { return Err(HorizonSyncError::InvalidMmrRoot { mmr_tree: MmrTree::Kernel, at_height: current_header.height(), @@ -601,7 +601,7 @@ impl<'a, B: BlockchainBackend + 'static> HorizonStateSynchronization<'a, B> { let output_mmr = MutablePrunedOutputMmr::new(pruned_output_set.clone(), bitmap.clone())?; let mmr_root = output_mmr.get_merkle_root()?; - if mmr_root != current_header.header().output_mr { + if mmr_root.as_slice() != current_header.header().output_mr.as_slice() { return Err(HorizonSyncError::InvalidMmrRoot { mmr_tree: MmrTree::Utxo, at_height: current_header.height(), @@ -611,7 +611,7 @@ impl<'a, B: BlockchainBackend + 'static> HorizonStateSynchronization<'a, B> { } let mmr_root = witness_mmr.get_merkle_root()?; - if mmr_root != current_header.header().witness_mr { + if mmr_root.as_slice() != current_header.header().witness_mr.as_slice() { return Err(HorizonSyncError::InvalidMmrRoot { mmr_tree: MmrTree::Witness, at_height: current_header.height(), diff --git a/base_layer/core/src/blocks/block_header.rs b/base_layer/core/src/blocks/block_header.rs index 45edfd0879..c671111955 100644 --- a/base_layer/core/src/blocks/block_header.rs +++ b/base_layer/core/src/blocks/block_header.rs @@ -55,8 +55,8 @@ use serde::{ Serializer, }; use tari_common_types::{ - array::{copy_into_fixed_array, copy_into_fixed_array_lossy}, - types::{BlindingFactor, BlockHash, BLOCK_HASH_LENGTH}, + array::copy_into_fixed_array_lossy, + types::{BlindingFactor, BlockHash, FixedHash, BLOCK_HASH_LENGTH}, }; use tari_utilities::{epoch_time::EpochTime, hex::Hex, ByteArray, Hashable}; use thiserror::Error; @@ -64,7 +64,8 @@ use thiserror::Error; #[cfg(feature = "base_node")] use crate::blocks::{BlockBuilder, NewBlockHeaderTemplate}; use crate::{ - consensus::{ConsensusDecoding, ConsensusEncoding, ConsensusEncodingSized, ConsensusHasher}, + blocks::BlocksHashDomain, + consensus::{ConsensusDecoding, ConsensusEncoding, ConsensusEncodingSized, DomainSeparatedConsensusHasher}, proof_of_work::{PowAlgorithm, PowError, ProofOfWork}, }; @@ -96,26 +97,27 @@ pub struct BlockHeader { pub height: u64, /// Hash of the block previous to this in the chain. #[serde(with = "hash_serializer")] + // TODO: Change type to 'FixedHash' pub prev_hash: BlockHash, /// Timestamp at which the block was built. pub timestamp: EpochTime, /// This is the UTXO merkle root of the outputs /// This is calculated as Hash (txo MMR root || roaring bitmap hash of UTXO indices) - #[serde(with = "hash_serializer")] - pub output_mr: BlockHash, + #[serde(with = "fixed_hash_serializer")] + pub output_mr: FixedHash, /// This is the MMR root of the witness proofs - #[serde(with = "hash_serializer")] - pub witness_mr: BlockHash, + #[serde(with = "fixed_hash_serializer")] + pub witness_mr: FixedHash, /// The size (number of leaves) of the output and range proof MMRs at the time of this header pub output_mmr_size: u64, /// This is the MMR root of the kernels - #[serde(with = "hash_serializer")] - pub kernel_mr: BlockHash, + #[serde(with = "fixed_hash_serializer")] + pub kernel_mr: FixedHash, /// The number of MMR leaves in the kernel MMR pub kernel_mmr_size: u64, /// This is the Merkle root of the inputs in this block - #[serde(with = "hash_serializer")] - pub input_mr: BlockHash, + #[serde(with = "fixed_hash_serializer")] + pub input_mr: FixedHash, /// Sum of kernel offsets for all kernels in this block. pub total_kernel_offset: BlindingFactor, /// Sum of script offsets for all kernels in this block. @@ -134,12 +136,12 @@ impl BlockHeader { height: 0, prev_hash: vec![0; BLOCK_HASH_LENGTH], timestamp: EpochTime::now(), - output_mr: vec![0; BLOCK_HASH_LENGTH], - witness_mr: vec![0; BLOCK_HASH_LENGTH], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0; BLOCK_HASH_LENGTH], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0; BLOCK_HASH_LENGTH], + input_mr: FixedHash::zero(), total_kernel_offset: BlindingFactor::default(), total_script_offset: BlindingFactor::default(), nonce: 0, @@ -157,12 +159,12 @@ impl BlockHeader { height: prev.height + 1, prev_hash, timestamp: EpochTime::now(), - output_mr: vec![0; BLOCK_HASH_LENGTH], - witness_mr: vec![0; BLOCK_HASH_LENGTH], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: prev.output_mmr_size, - kernel_mr: vec![0; BLOCK_HASH_LENGTH], + kernel_mr: FixedHash::zero(), kernel_mmr_size: prev.kernel_mmr_size, - input_mr: vec![0; BLOCK_HASH_LENGTH], + input_mr: FixedHash::zero(), total_kernel_offset: BlindingFactor::default(), total_script_offset: BlindingFactor::default(), nonce: 0, @@ -215,22 +217,22 @@ impl BlockHeader { /// Provides a hash of the header, used for the merge mining. /// This differs from the normal hash by not hashing the nonce and kernel pow. - pub fn merged_mining_hash(&self) -> Vec { - ConsensusHasher::default() - .chain(&self.version) - .chain(&self.height) - .chain(&self.prev_hash) - .chain(&self.timestamp) - .chain(&self.input_mr) - // TODO: Cleanup if/when we migrate to fixed 32-byte array type for hashes - .chain(©_into_fixed_array_lossy::<_, 32>(&self.output_mr)) - .chain(&self.output_mmr_size) - .chain(©_into_fixed_array_lossy::<_, 32>(&self.witness_mr)) - .chain(©_into_fixed_array_lossy::<_, 32>(&self.kernel_mr)) - .chain(&self.kernel_mmr_size) - .chain(&self.total_kernel_offset) - .chain(&self.total_script_offset) - .finalize().to_vec() + pub fn merged_mining_hash(&self) -> FixedHash { + DomainSeparatedConsensusHasher::::new("block_header") + .chain(&self.version) + .chain(&self.height) + .chain(&self.prev_hash) + .chain(&self.timestamp) + .chain(&self.input_mr) + .chain(&self.output_mr) + .chain(&self.output_mmr_size) + .chain(&self.witness_mr) + .chain(&self.kernel_mr) + .chain(&self.kernel_mmr_size) + .chain(&self.total_kernel_offset) + .chain(&self.total_script_offset) + .finalize() + .into() } #[inline] @@ -257,13 +259,13 @@ impl From for BlockHeader { height: header_template.height, prev_hash: header_template.prev_hash, timestamp: EpochTime::now(), - output_mr: vec![], - witness_mr: vec![], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), // TODO: put mmr sizes in template output_mmr_size: 0, - kernel_mr: vec![], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![], + input_mr: FixedHash::zero(), total_kernel_offset: header_template.total_kernel_offset, total_script_offset: header_template.total_script_offset, nonce: 0, @@ -274,13 +276,12 @@ impl From for BlockHeader { impl Hashable for BlockHeader { fn hash(&self) -> Vec { - ConsensusHasher::default() - // TODO: this excludes extraneous length varint used for Vec since a hash is always 32-bytes. Clean this - // up if we decide to migrate to a fixed 32-byte type - .chain(©_into_fixed_array::<_, 32>(&self.merged_mining_hash()).unwrap()) + DomainSeparatedConsensusHasher::::new("block_header") + .chain(&self.merged_mining_hash().as_slice()) .chain(&self.pow) .chain(&self.nonce) - .finalize().to_vec() + .finalize() + .to_vec() } } @@ -364,18 +365,59 @@ pub(crate) mod hash_serializer { } } +pub(crate) mod fixed_hash_serializer { + use tari_utilities::hex::Hex; + + use super::*; + + #[allow(clippy::ptr_arg)] + pub fn serialize(bytes: &FixedHash, serializer: S) -> Result + where S: Serializer { + if serializer.is_human_readable() { + bytes.to_hex().serialize(serializer) + } else { + serializer.serialize_bytes(bytes.as_bytes()) + } + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result + where D: Deserializer<'de> { + struct BlockHashVisitor; + + impl<'de> Visitor<'de> for BlockHashVisitor { + type Value = FixedHash; + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str("A block header hash in binary format") + } + + fn visit_bytes(self, v: &[u8]) -> Result + where E: de::Error { + FixedHash::try_from(v).map_err(E::custom) + } + } + + if deserializer.is_human_readable() { + let s = String::deserialize(deserializer)?; + FixedHash::from_hex(&s).map_err(de::Error::custom) + } else { + deserializer.deserialize_bytes(BlockHashVisitor) + } + } +} + impl ConsensusEncoding for BlockHeader { fn consensus_encode(&self, writer: &mut W) -> Result<(), io::Error> { self.version.consensus_encode(writer)?; self.height.consensus_encode(writer)?; copy_into_fixed_array_lossy::<_, 32>(&self.prev_hash).consensus_encode(writer)?; self.timestamp.consensus_encode(writer)?; - copy_into_fixed_array_lossy::<_, 32>(&self.output_mr).consensus_encode(writer)?; - copy_into_fixed_array_lossy::<_, 32>(&self.witness_mr).consensus_encode(writer)?; + self.output_mr.as_slice().consensus_encode(writer)?; + self.witness_mr.as_slice().consensus_encode(writer)?; self.output_mmr_size.consensus_encode(writer)?; - copy_into_fixed_array_lossy::<_, 32>(&self.kernel_mr).consensus_encode(writer)?; + self.kernel_mr.as_slice().consensus_encode(writer)?; self.kernel_mmr_size.consensus_encode(writer)?; - copy_into_fixed_array_lossy::<_, 32>(&self.input_mr).consensus_encode(writer)?; + self.input_mr.as_slice().consensus_encode(writer)?; self.total_kernel_offset.consensus_encode(writer)?; self.total_script_offset.consensus_encode(writer)?; self.nonce.consensus_encode(writer)?; @@ -393,12 +435,12 @@ impl ConsensusDecoding for BlockHeader { header.height = u64::consensus_decode(reader)?; header.prev_hash = <[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?.to_vec(); header.timestamp = EpochTime::consensus_decode(reader)?; - header.output_mr = <[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?.to_vec(); - header.witness_mr = <[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?.to_vec(); + header.output_mr = FixedHash::from(<[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?); + header.witness_mr = FixedHash::from(<[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?); header.output_mmr_size = u64::consensus_decode(reader)?; - header.kernel_mr = <[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?.to_vec(); + header.kernel_mr = FixedHash::from(<[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?); header.kernel_mmr_size = u64::consensus_decode(reader)?; - header.input_mr = <[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?.to_vec(); + header.input_mr = FixedHash::from(<[u8; 32] as ConsensusDecoding>::consensus_decode(reader)?); header.total_kernel_offset = BlindingFactor::consensus_decode(reader)?; header.total_script_offset = BlindingFactor::consensus_decode(reader)?; header.nonce = u64::consensus_decode(reader)?; diff --git a/base_layer/core/src/blocks/genesis_block.rs b/base_layer/core/src/blocks/genesis_block.rs index 60e91299c3..40db564b3f 100644 --- a/base_layer/core/src/blocks/genesis_block.rs +++ b/base_layer/core/src/blocks/genesis_block.rs @@ -24,7 +24,15 @@ use std::sync::Arc; use chrono::DateTime; use tari_common::configuration::Network; -use tari_common_types::types::{BulletRangeProof, Commitment, PrivateKey, PublicKey, Signature, BLOCK_HASH_LENGTH}; +use tari_common_types::types::{ + BulletRangeProof, + Commitment, + FixedHash, + PrivateKey, + PublicKey, + Signature, + BLOCK_HASH_LENGTH, +}; use tari_crypto::{ signatures::CommitmentSignature, tari_utilities::{hash::Hashable, hex::*}, @@ -76,7 +84,7 @@ pub fn get_igor_genesis_block() -> ChainBlock { let block = get_igor_genesis_block_raw(); // Use this code to generate the correct header mr fields for igor if the gen block changes. - + // // use croaring::Bitmap; // // use crate::{KernelMmr, MutableOutputMmr, WitnessMmr}; @@ -115,13 +123,13 @@ fn get_igor_genesis_block_raw() -> Block { // Note: Use print_new_genesis_block_igor in core/tests/helpers/block_builders.rs to generate the required fields // below let sig = Signature::new( - PublicKey::from_hex("46f23560fb880900d03552e98ee511bceb03692635b3a50fe42be43e9fe80507").unwrap(), - PrivateKey::from_hex("8c781c1af074126539a950ca171b343d51659fb996b69d6f17e412cb952a610a").unwrap(), + PublicKey::from_hex("e22ad0f02bfc08e3b04c667cca050072e091a477c3a4d10345c4114ed4266818").unwrap(), + PrivateKey::from_hex("2685f18306717ed7ccfad9f96185e5cbca52b3fe109673b1075d130fad54f60e").unwrap(), ); let coinbase_meta_sig = CommitmentSignature::new( - Commitment::from_hex("5231d399cbc20df114953b04ee48987dc10b4508d936cd047a5e9764e587517c").unwrap(), - PrivateKey::from_hex("ae6c37d88b6df65295d30a09c0a92db27ee92b58f83379de5952b68af6040a09").unwrap(), - PrivateKey::from_hex("a6d7fab484d934127905925bf5cb6c163cbf91db14af3809cfd8ca83453e0803").unwrap(), + Commitment::from_hex("ecab12e0bab23ab32a0014b592fcdb4d22be7e02cb5031632ad9c3c9b2560229").unwrap(), + PrivateKey::from_hex("8a87214524cb2025a3dbaaf7cb5a6287c4d37f7521e667cdc253909adb48c70e").unwrap(), + PrivateKey::from_hex("6b5f940eaba65b6a46edc112ab9186be9310aeb086cf0878a68bccf73f712600").unwrap(), ); let mut body = AggregateBody::new( vec![], @@ -132,14 +140,14 @@ fn get_igor_genesis_block_raw() -> Block { .. Default::default() }, Commitment::from_hex( - "166e79a49c2ab50d2ef3c8246418c6e9897071dcdeaf3b6aba1ae600ebbc8202", + "dc07cc8ad8106d33d38239f63bc308959f48d47c8dbe2a65e32662b93262ba09", ) .unwrap(), - BulletRangeProof::from_hex("01007308cceb1c168fcf65174e3d5fccd466e84f36e541a6254a5677b48c186b02547b65e98f3319e83ec240485b7f5448912d8b9e656a6bf471e1a98e435f2978ba32a1e375cefc17e3f42f28b6b86bc2fa07126c15c9812ecfa5f7eebaaa5308169366cea3c6a1524ddbb9d1804193cc7a1fb149ddc70eee72c4792c0039206132a2f13dfe823a815d92337d35656f1983a31d440ad9e5fa7b47aaa2b682ba7ed29cf3ae681b730f49555d830025a50eaadaae7f62b5ce1107598130b904747292419e1520c1645547b1d046f5c1f71978eafb8edc485b7ff40e9633f1fed5446081bfe51c54cf6567cc6c14fa0715ddc285548acb256d0d52c3646cdb9b797dbceb2843d3b26d264a130da2a413b78b1e3b026a0f32ccd080cc7876b4fe0a702a92484dbafeea9470103ea380e0906bc26a43ea6215e0570a968530c1c9724d3ac5a7912f468adb6d82d1f5e34fdd43668f3b41ade8bf6c3b2148d1ac3f957c5883e60367fe906a74338837d0e98ad29db37e38c708c6c978d0e75ea656d26b2a8b38169f207c0f57f97f6169bda0427bc31430cf51671d6bb566315e19a6522ef61fb41842374285e509925a0966b66733fe2dc8bd190ba7d77c55f0b8401d78e08432d2950ff6a166ade9476a5165c7ccedaab4520b617530c9dbf83efe0a7f9a75b23e34e3ca548336cbbf696817ccbfc6467c5c9cec989050d8e7a2300ad5d65f90ba7b3fad98056114461cf1f06466a25a911c07467aad936eae99e001bc67377f450b60ef6f649e77ff495d382c39449c24d617ca54502209c1129e06").unwrap(), + BulletRangeProof::from_hex("01002c676a37bd85610b752598fdc493b0d0023b752b5c620e052731ae1278721dcc1ac376f04e6196083a830115a07452a79c82334b2130bec19784dc60d7dd4418f1fafe27b7519ba72c12dad7e8aa98ca52b5db9e051dc8d58a39f47157d72496c13c839f89fa58fa0c9303d2bf2d51bd8fbe00105602c69a75b9d1f9673f75a6abc51ab102e2ffafe96c5b13d49e2eae5a506d768dd4647aee98fa75b9a364cc3c29b0c01ca7fcc6fbf212e592f68bf104ef2c1cc5202ec500e5b37949e95062090b3d947427a7459b128215dbe75629656651362298691a8ef895d7b0bb3090b15b807a38eba20da1349dbc9bd6bb221fee6a79183433ddac29ef2027877a0230eda904e275ab6c9d87d9d2ea0fca13c92cb678edf5782eea1bdcec0d200c944a9e8c0a20ddcbc9e107ec7a84e7a6a498ba059f9bd9aded2c427a8c021e1c28e961c2f6cc4f490fda74407d99ac3cd54737050e68d7208eea5a7cfa85000fded0cfc6422a66da834bdcb14402bf1857467619143ded6de7a454b778dc1015f848bd278fe2d415334bc29b1113a76bcac126d00a9803ed931ec56fa9f085428ac9197191295e05bbae762092f0918d489a4e39e7220d91f2fc0a7de9b45676eee23c36d05967dd00073e436992456adf5974c3acc618fc11b6a216d8647a6fbaf033cd25898ee229002fec218f531a8de40d0dc4a352296bb92ececc5f4f0e46c1f81ba195fa8a667258bcabe027a44ccee5154fa2821b90ce2694c90883028db0ccd61c59fc8123b9d60bc3a4ed6024addee150c04f0cf410701a865fae07").unwrap(), // For genesis block: A default script can never be spent, intentionally script!(Nop), // Script offset never checked for coinbase, thus can use default - PublicKey::from_hex("5c498523022af6acf2bc940122a3fbe82b90ae98a16707e1d942bb6ced94ba11").unwrap(), + PublicKey::from_hex("9234814d039bf3ac6545ed40a63570a2720b9376dcbde0bc1a75d081eec50446").unwrap(), // For genesis block: Metadata signature will never be checked coinbase_meta_sig, Covenant::default(), @@ -152,7 +160,7 @@ fn get_igor_genesis_block_raw() -> Block { MicroTari(0), 0, Commitment::from_hex( - "6454fc05c089122a833bb86311dd43a5f984730d110ba6d11a354ff90c240625", + "18d80887a36fae6c2cbef5941d5eedd927aeae1003798bb63c3f292cb68cbe00", ) .unwrap(), sig,None @@ -170,12 +178,13 @@ fn get_igor_genesis_block_raw() -> Block { height: 0, prev_hash: vec![0; BLOCK_HASH_LENGTH], timestamp: timestamp.into(), - output_mr: from_hex("3674e705fec6f4fd46357bb7fe56920febde9fc6d29633bc9b1e63320163a7fb").unwrap(), - witness_mr: from_hex("883eb8d91e4d7454ca9b8f1ede38117c6a1ea990d521902e9035e68bc6ed9b8b").unwrap(), + output_mr: FixedHash::from_hex("55cd15eb1966b15e3dc8f8066371702a86b573915cd409cf8c20c7529a73c027").unwrap(), + witness_mr: FixedHash::from_hex("188b79e4cd780914fc0dfe7d57b9f32bfae04293052b867fce25c4af8b5191dc") + .unwrap(), output_mmr_size: 1, - kernel_mr: from_hex("43aa6360a31d12460a4c6ba238394a5b7e838b4c8706c6773c1378096b15e44c").unwrap(), + kernel_mr: FixedHash::from_hex("2e3fde9cd20b48f699523d1b107b4742c6aa03ed1cb210f580d0c7426463b966").unwrap(), kernel_mmr_size: 1, - input_mr: vec![0; BLOCK_HASH_LENGTH], + input_mr: FixedHash::zero(), total_kernel_offset: PrivateKey::from_hex( "0000000000000000000000000000000000000000000000000000000000000000", ) @@ -219,7 +228,7 @@ pub fn get_esmeralda_genesis_block() -> ChainBlock { // NB: `esmerlada_genesis_sanity_check` must pass // // use croaring::Bitmap; - // + // use std::convert::TryFrom; // use crate::{KernelMmr, MutableOutputMmr, WitnessMmr}; // // let mut kernel_mmr = KernelMmr::new(Vec::new()); @@ -236,17 +245,20 @@ pub fn get_esmeralda_genesis_block() -> ChainBlock { // output_mmr.push(o.hash()).unwrap(); // } // - // block.header.kernel_mr = kernel_mmr.get_merkle_root().unwrap(); - // block.header.witness_mr = witness_mmr.get_merkle_root().unwrap(); - // block.header.output_mr = output_mmr.get_merkle_root().unwrap(); + // block.header.kernel_mr = FixedHash::try_from(kernel_mmr.get_merkle_root().unwrap()).unwrap(); + // block.header.witness_mr = FixedHash::try_from(witness_mmr.get_merkle_root().unwrap()).unwrap(); + // block.header.output_mr = FixedHash::try_from(output_mmr.get_merkle_root().unwrap()).unwrap(); // println!("kernel mr: {}", block.header.kernel_mr.to_hex()); // println!("witness mr: {}", block.header.witness_mr.to_hex()); // println!("output mr: {}", block.header.output_mr.to_hex()); // Hardcode the Merkle roots once they've been computed above - block.header.kernel_mr = from_hex("e4207927f847a340051d1967310f0d1a3e53fc39ba1b5c22ac23443452e996cd").unwrap(); - block.header.witness_mr = from_hex("c4d45c4a100c697c554cd6a7c8185ee72f4f3419e7a2bb58103d3a2af1365d99").unwrap(); - block.header.output_mr = from_hex("0f40143b4b85b8e7e5a8bed92424edcf9367abc3fb28f26f4e56a32f027da38d").unwrap(); + block.header.kernel_mr = + FixedHash::from_hex("cd75034a1d4c6ef0cdc7cc28e373d6e8611feeabf7074d1c389a357af9f81d06").unwrap(); + block.header.witness_mr = + FixedHash::from_hex("186bbe903846017d4bcbac0b7d759066480dcc15a35d9af9ad3aa7c5f592dbda").unwrap(); + block.header.output_mr = + FixedHash::from_hex("a439bc9f389aa9069293431310296a685e0139e6c7bd655c0fd33aa422156f60").unwrap(); let accumulated_data = BlockHeaderAccumulatedData { hash: block.hash(), @@ -264,13 +276,13 @@ fn get_esmeralda_genesis_block_raw() -> Block { // Note: Use print_new_genesis_block_esmeralda in core/tests/helpers/block_builders.rs to generate the required // fields below let excess_sig = Signature::new( - PublicKey::from_hex("3c68e727aa41261cd51bc8cc501fe39dd6a27d949a8cfaad2f0caad72755f20f").unwrap(), - PrivateKey::from_hex("51a1cb7911c80defa0f954bdd101d69123b365257f7ee6a4f37ff77d781fc801").unwrap(), + PublicKey::from_hex("d6bcca018adacce9599ec467fb1239cc9a3b5c43fb0dedd806549d4169090d2e").unwrap(), + PrivateKey::from_hex("c8060fe4133d218fe4fef753f50eb4838b2e4fabb571357875447e9c45763500").unwrap(), ); let coinbase_meta_sig = CommitmentSignature::new( - Commitment::from_hex("945a82d3c851bb864552b0b519a162159848b0eef1d9c055fba75189e20a1617").unwrap(), - PrivateKey::from_hex("e3293da0392c53e1f7934b25a07e76226a8e12de2ee352f202503df72239b507").unwrap(), - PrivateKey::from_hex("30f3f03bee7050189e677738e5777e13016b521b78c8a0a2c4561a7a4e74fa05").unwrap(), + Commitment::from_hex("98fa97ba38931bc18c78d68531b1f4a617af90d1748a7ca508a68ff055b4214f").unwrap(), + PrivateKey::from_hex("a3fa0920d32b6e9e888afb6fb29f5d63a9bdaa1cdd2f5fc8ff0eadc272c4b80c").unwrap(), + PrivateKey::from_hex("51ff5fe696c5ff279b3f59c3de119cb2433c1d60bd0d478dad6950cae6dc3900").unwrap(), ); let coinbase = TransactionOutput::new( TransactionOutputVersion::get_current_version(), @@ -281,12 +293,12 @@ fn get_esmeralda_genesis_block_raw() -> Block { metadata: Vec::new(), sidechain_features: None, }, - Commitment::from_hex("b61eb7c261f80a79962abe85b1ec057b2a2c9f8863b0cd79fc907eaa82f2a25d").unwrap(), - BulletRangeProof::from_hex("0110aa932312797a169fda8ddc20badf899f1efe20b28a49b99c8e30b41a0f9571542d01e452e9dfdc1ea8ef13bb292bb3129e3cdad676e6cc39468542d40d8b05787b73af37e308f402e2d7245e7c05b4a8d676c8b9e45c1357f62b2033973b72cc8935bd0728cb94dd8c2458df5423c0854000f6ac6d960b1284c275f5b167515438a9a283ff98a941bf7d5a9014c963e28a760cbcc772a7a6ed40cc223a2a2fd8ba4d7f5ab02866b63eb6854173e3e2b0395dd42f2e2d602525009970955a19d087fe40b998460e499fa5d52e23ae2c74b17ac5558ac9e91efb9ea498c8001642376930e74331e52a3e24b38edcc5d8ac3de71cf5a7411bf773589294aad60688013d7daaf3f4df8b42020e77ceb1007271e021bcfca720af800a5b7c9f7479d08f818364a398f620c62aee832d781d6933b271a1c4e6bdf0e27e17a62c7b7b34522294f8c357b9d9beb7b773b93142c3f8aa5f7462bfe5bf4aac2ac20d424fe2003a6496ab08c6fc9f2b456a64f23c626b9bed0ac2a5e662a1d40c4b083204708048dc3104c87af948b6343f17cf4d81e2ae730f2d4951d6838508b43ba828b8bb525ad9c40a64469347061250cf1e7e01fb35a56f7ce416f8a3b8cc36eb78184c991a38b9d02eacc3187a8393d4db7cb7b9f79588c05681f15f56a06f63449e4983b461387298ac574273f729c3e3a494f5bbc021be4f5e36c079c503d407029a08ca6f78aeddc0edc4840c4d33bd3b4fcaca2924d0652ed1a4f1e4c33d0c8a50def65dd115e11584c65ba3a0c5cc56f81f8b7569a369a0c95cfc9dd3c20f").unwrap(), + Commitment::from_hex("b850bb8564ae69f9f9a0ee6769674629172f025bcbdf979f981df546aba9e959").unwrap(), + BulletRangeProof::from_hex("015c0fb37d025defd4f66fbdba00df78a6370ed44e6478422df0829fb8314fa204e23652cc7fc360ddeaf25ab4b2a57ed18c2d21475d53b0f68e25348e889f1c2594d6b67b65e6aae8e287e3021aecc2edd0608c48a0f382cdc32f082fe99cba29e2bc6b2838fdbdced9f5166648fc8a5557050dcde251f9a267500ddbf9ee751182251eeb250ed0f4d7d86f93e314799b62c2dcc38cc7a3f8a1d42d15ba84bc18cc2cdfbb0a2a819d36cf14d927f88a1512beeab2f41128334c438e6ace3aa81f82a4eb9283d9831e3683ae92374b78134d404a264d9c1e07680ef0df608ac2742c93f88b01f40bedcf2c39e7c0fb93665d78069a85b19390b2105a0efa078101ea9dfd7ca1cc3c6d953a19f013cb4f45525ed6fd93eb4f04e43c79c08087ef5d08faef12cdd5256c0319a271b8eeb7a42f6728ba19841335a3cb0b2b4f55775308711f1461a871f5e66f0e4277b03c902bb2551ab62214cf0d817a26f9044e08de031fe66eae7c488319a4464e4894c4dc25eb2f53bd48473a8ddfe2118cd459b8ed064afb449e3feaf212b376b9cd91150c195caa0f6650405705734e8d517bf4facd0c401f09441f06e376ad6c2be29cb3b262d7cb8b72e1364d92ed3bfc4070bb272ca61a963e3f38e26b11c7bdcdfa36defae553382ef2f5b91bd97ed56b264d3d3545e2f7465c6d6fc656a471b8b7a43cd3f1a9b43ca15a07fb3440d60d739227346087e10c1dcf87ddfe9c5732366c5028a50eb81854bba9bc708aa0097760f04e2e91c316802cdeb136a1a4570e506df65d95907f9f863c7fef533e08").unwrap(), // A default script can never be spent, intentionally script!(Nop), // The Sender offset public key is not checked for coinbase outputs - PublicKey::from_hex("7635fa3ddac74dd7cb981c56ef0e65b8d9b745c8364f9b70b24814bc4dca1459").unwrap(), + PublicKey::from_hex("20602f2433b93e10f64d07fd41fc6eb7e5a08d4297689fa03b46a6e399926117").unwrap(), // For genesis block: Metadata signature will never be checked coinbase_meta_sig, // Covenant @@ -300,7 +312,7 @@ fn get_esmeralda_genesis_block_raw() -> Block { KernelFeatures::COINBASE_KERNEL, MicroTari(0), 0, - Commitment::from_hex("1247725f8136feb350800967a9cda0359186f7071b4b0b98d9a9b5fe24f9843e").unwrap(), + Commitment::from_hex("d4276c8ab208e3c2c24c0308ffd86b69edff15161666dbc5a967781dd3d16737").unwrap(), excess_sig, None, ); @@ -316,12 +328,13 @@ fn get_esmeralda_genesis_block_raw() -> Block { height: 0, prev_hash: vec![0; BLOCK_HASH_LENGTH], timestamp: timestamp.into(), - output_mr: from_hex("a6c033d0172d268c8b58b0d1656373a596019687dbad04a2301b84348fcf0668").unwrap(), - witness_mr: from_hex("561d279cc9f60e961f2082a531b23fcdcd7825053241e26de974e6ae65e31231").unwrap(), + output_mr: FixedHash::from_hex("b114e77b790595dfbe45e1b4d805e9c0609a0a69a5a95944064a3f7585a9423f").unwrap(), + witness_mr: FixedHash::from_hex("b6b18f2de77374641f82447d4738dcfbfa0a2273b8f3ea566590d5e1e0141382") + .unwrap(), output_mmr_size: 1, - kernel_mr: from_hex("646ccd1d747b8a8f3c1b75c1de034aab03e63001f1e021f2c03722be01f34eb2").unwrap(), + kernel_mr: FixedHash::from_hex("9b82a1deefa87548060b487a050e9919f6c11bd9cb4e3ec35e65153375c9f4a4").unwrap(), kernel_mmr_size: 1, - input_mr: vec![0; BLOCK_HASH_LENGTH], + input_mr: FixedHash::zero(), total_kernel_offset: PrivateKey::from_hex( "0000000000000000000000000000000000000000000000000000000000000000", ) @@ -404,9 +417,18 @@ mod test { output_mmr.push(o.hash()).unwrap(); } - assert_eq!(kernel_mmr.get_merkle_root().unwrap(), block.header().kernel_mr); - assert_eq!(witness_mmr.get_merkle_root().unwrap(), block.header().witness_mr); - assert_eq!(output_mmr.get_merkle_root().unwrap(), block.header().output_mr); + assert_eq!( + kernel_mmr.get_merkle_root().unwrap().as_slice(), + block.header().kernel_mr.as_slice() + ); + assert_eq!( + witness_mmr.get_merkle_root().unwrap().as_slice(), + block.header().witness_mr.as_slice() + ); + assert_eq!( + output_mmr.get_merkle_root().unwrap().as_slice(), + block.header().output_mr.as_slice() + ); // Check that the faucet UTXOs balance (the faucet_value consensus constant is set correctly and faucet kernel // is correct) @@ -469,9 +491,18 @@ mod test { output_mmr.push(o.hash()).unwrap(); } - assert_eq!(kernel_mmr.get_merkle_root().unwrap(), block.header().kernel_mr); - assert_eq!(witness_mmr.get_merkle_root().unwrap(), block.header().witness_mr); - assert_eq!(output_mmr.get_merkle_root().unwrap(), block.header().output_mr); + assert_eq!( + kernel_mmr.get_merkle_root().unwrap().as_slice(), + block.header().kernel_mr.as_slice() + ); + assert_eq!( + witness_mmr.get_merkle_root().unwrap().as_slice(), + block.header().witness_mr.as_slice() + ); + assert_eq!( + output_mmr.get_merkle_root().unwrap().as_slice(), + block.header().output_mr.as_slice() + ); // Check that the faucet UTXOs balance (the faucet_value consensus constant is set correctly and faucet kernel // is correct) diff --git a/base_layer/core/src/blocks/mod.rs b/base_layer/core/src/blocks/mod.rs index 3b7eb851f1..6df31971e8 100644 --- a/base_layer/core/src/blocks/mod.rs +++ b/base_layer/core/src/blocks/mod.rs @@ -22,6 +22,7 @@ #[cfg(feature = "base_node")] mod accumulated_data; + #[cfg(feature = "base_node")] pub use accumulated_data::{ BlockAccumulatedData, @@ -32,6 +33,7 @@ pub use accumulated_data::{ DeletedBitmap, UpdateBlockAccumulatedData, }; +use tari_crypto::hash_domain; mod error; pub use error::BlockError; @@ -61,3 +63,5 @@ pub use new_block_template::NewBlockTemplate; mod new_blockheader_template; #[cfg(feature = "base_node")] pub use new_blockheader_template::NewBlockHeaderTemplate; + +hash_domain!(BlocksHashDomain, "com.tari.base_layer.core.blocks", 0); diff --git a/base_layer/core/src/chain_storage/blockchain_database.rs b/base_layer/core/src/chain_storage/blockchain_database.rs index b3469286c7..900e8d51bb 100644 --- a/base_layer/core/src/chain_storage/blockchain_database.rs +++ b/base_layer/core/src/chain_storage/blockchain_database.rs @@ -36,7 +36,7 @@ use log::*; use serde::{Deserialize, Serialize}; use tari_common_types::{ chain_metadata::ChainMetadata, - types::{BlockHash, Commitment, HashOutput, Signature}, + types::{BlockHash, Commitment, FixedHash, HashOutput, Signature}, }; use tari_mmr::pruned_hashset::PrunedHashSet; use tari_utilities::{epoch_time::EpochTime, hex::Hex, ByteArray, Hashable}; @@ -1168,11 +1168,11 @@ fn unexpected_result(request: DbKey, response: DbValue) -> Result(db: &T, block: &Block) -> Resul output_mmr.compress(); - let input_mr = input_mmr.get_merkle_root()?; - let mmr_roots = MmrRoots { - kernel_mr: kernel_mmr.get_merkle_root()?, + kernel_mr: FixedHash::try_from(kernel_mmr.get_merkle_root()?)?, kernel_mmr_size: kernel_mmr.get_leaf_count()? as u64, - input_mr, - output_mr: output_mmr.get_merkle_root()?, + input_mr: FixedHash::try_from(input_mmr.get_merkle_root()?)?, + output_mr: FixedHash::try_from(output_mmr.get_merkle_root()?)?, output_mmr_size: output_mmr.get_leaf_count() as u64, - witness_mr: witness_mmr.get_merkle_root()?, + witness_mr: FixedHash::try_from(witness_mmr.get_merkle_root()?)?, }; Ok(mmr_roots) } diff --git a/base_layer/core/src/chain_storage/error.rs b/base_layer/core/src/chain_storage/error.rs index e6c083725d..93456647ce 100644 --- a/base_layer/core/src/chain_storage/error.rs +++ b/base_layer/core/src/chain_storage/error.rs @@ -21,6 +21,7 @@ // USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. use lmdb_zero::error; +use tari_common_types::types::FixedHashSizeError; use tari_mmr::{error::MerkleMountainRangeError, MerkleProofError}; use tari_storage::lmdb_store::LMDBError; use thiserror::Error; @@ -131,6 +132,8 @@ pub enum ChainStorageError { ConversionError(String), #[error("Unable to spend UTXO because it has dependant UTXOS: {details}")] UnspendableDueToDependentUtxos { details: String }, + #[error("FixedHashSize Error: {0}")] + FixedHashSizeError(#[from] FixedHashSizeError), } impl ChainStorageError { diff --git a/base_layer/core/src/chain_storage/tests/blockchain_database.rs b/base_layer/core/src/chain_storage/tests/blockchain_database.rs index 94934f4084..aae7cc434c 100644 --- a/base_layer/core/src/chain_storage/tests/blockchain_database.rs +++ b/base_layer/core/src/chain_storage/tests/blockchain_database.rs @@ -1,10 +1,10 @@ // Copyright 2020, The Tari Project // -// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the -// following conditions are met: +// Redistribution and use in source and binary forms, with or without modification, are permitted provided that +// the following conditions are met: // -// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following -// disclaimer. +// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the +// following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the // following disclaimer in the documentation and/or other materials provided with the distribution. @@ -12,13 +12,14 @@ // 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote // products derived from this software without specific prior written permission. // -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, -// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE -// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. use std::sync::Arc; use tari_test_utils::unpack_enum; diff --git a/base_layer/core/src/consensus/consensus_encoding/hashing.rs b/base_layer/core/src/consensus/consensus_encoding/hashing.rs index 14cb78381f..7f843694c9 100644 --- a/base_layer/core/src/consensus/consensus_encoding/hashing.rs +++ b/base_layer/core/src/consensus/consensus_encoding/hashing.rs @@ -25,7 +25,7 @@ use std::{io, io::Write, marker::PhantomData}; use digest::{consts::U32, Digest}; -use tari_crypto::{hash::blake2::Blake256, hashing::DomainSeparation}; +use tari_crypto::{hash::blake2::Blake256, hash_domain, hashing::DomainSeparation}; use crate::consensus::ConsensusEncoding; @@ -74,8 +74,15 @@ where D: Digest } impl Default for ConsensusHasher { + /// This `default` implementation is provided for convenience, but should not be used as the de-facto consensus + /// hasher, rather create a new unique hash domain. fn default() -> Self { - ConsensusHasher::from_digest(Blake256::new()) + hash_domain!( + DefaultConsensusHashDomain, + "com.tari.base_layer.core.consensus.consensus_encoding.hashing", + 0 + ); + DomainSeparatedConsensusHasher::::new("default") } } @@ -131,4 +138,15 @@ mod tests { assert_eq!(hash, expected_hash.as_ref()); } + + #[test] + fn default_consensus_hash_is_not_blake256_default_hash() { + let blake256_hasher = Blake256::new(); + let blake256_hash = blake256_hasher.chain(b"").finalize(); + + let default_consensus_hasher = ConsensusHasher::default(); + let default_consensus_hash = default_consensus_hasher.chain(b"").finalize(); + + assert_ne!(blake256_hash.as_slice(), default_consensus_hash.as_slice()); + } } diff --git a/base_layer/core/src/proof_of_work/monero_rx/helpers.rs b/base_layer/core/src/proof_of_work/monero_rx/helpers.rs index 5b7449a211..2b21ce6043 100644 --- a/base_layer/core/src/proof_of_work/monero_rx/helpers.rs +++ b/base_layer/core/src/proof_of_work/monero_rx/helpers.rs @@ -191,6 +191,7 @@ mod test { TxIn, TxOut, }; + use tari_common_types::types::FixedHash; use tari_test_utils::unpack_enum; use tari_utilities::{ epoch_time::EpochTime, @@ -296,12 +297,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, @@ -352,12 +353,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, @@ -404,12 +405,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, @@ -455,12 +456,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, @@ -510,12 +511,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, @@ -561,12 +562,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, @@ -603,12 +604,12 @@ mod test { height: 0, prev_hash: vec![0], timestamp: EpochTime::now(), - output_mr: vec![0], - witness_mr: vec![0], + output_mr: FixedHash::zero(), + witness_mr: FixedHash::zero(), output_mmr_size: 0, - kernel_mr: vec![0], + kernel_mr: FixedHash::zero(), kernel_mmr_size: 0, - input_mr: vec![0], + input_mr: FixedHash::zero(), total_kernel_offset: Default::default(), total_script_offset: Default::default(), nonce: 0, diff --git a/base_layer/core/src/proto/block_header.rs b/base_layer/core/src/proto/block_header.rs index ad2e53caf9..2f54958c58 100644 --- a/base_layer/core/src/proto/block_header.rs +++ b/base_layer/core/src/proto/block_header.rs @@ -22,7 +22,7 @@ use std::convert::TryFrom; -use tari_common_types::types::BlindingFactor; +use tari_common_types::types::{BlindingFactor, FixedHash}; use tari_utilities::ByteArray; use super::core as proto; @@ -58,12 +58,12 @@ impl TryFrom for BlockHeader { height: header.height, prev_hash: header.prev_hash, timestamp, - output_mr: header.output_mr, - witness_mr: header.witness_mr, + output_mr: FixedHash::try_from(header.output_mr).map_err(|err| err.to_string())?, + witness_mr: FixedHash::try_from(header.witness_mr).map_err(|err| err.to_string())?, output_mmr_size: header.output_mmr_size, - kernel_mr: header.kernel_mr, + kernel_mr: FixedHash::try_from(header.kernel_mr).map_err(|err| err.to_string())?, kernel_mmr_size: header.kernel_mmr_size, - input_mr: header.input_mr, + input_mr: FixedHash::try_from(header.input_mr).map_err(|err| err.to_string())?, total_kernel_offset, total_script_offset, nonce: header.nonce, @@ -80,10 +80,10 @@ impl From for proto::BlockHeader { height: header.height, prev_hash: header.prev_hash, timestamp: Some(timestamp), - output_mr: header.output_mr, - witness_mr: header.witness_mr, - kernel_mr: header.kernel_mr, - input_mr: header.input_mr, + output_mr: header.output_mr.to_vec(), + witness_mr: header.witness_mr.to_vec(), + kernel_mr: header.kernel_mr.to_vec(), + input_mr: header.input_mr.to_vec(), total_kernel_offset: header.total_kernel_offset.to_vec(), total_script_offset: header.total_script_offset.to_vec(), nonce: header.nonce, diff --git a/base_layer/core/src/transactions/transaction_components/mod.rs b/base_layer/core/src/transactions/transaction_components/mod.rs index c23f06de2e..d224645044 100644 --- a/base_layer/core/src/transactions/transaction_components/mod.rs +++ b/base_layer/core/src/transactions/transaction_components/mod.rs @@ -77,7 +77,7 @@ pub const MAX_TRANSACTION_RECIPIENTS: usize = 15; //---------------------------------------- Crate functions ----------------------------------------------------// use super::tari_amount::MicroTari; -use crate::{consensus::ConsensusHasher, covenants::Covenant}; +use crate::{consensus::DomainSeparatedConsensusHasher, covenants::Covenant, transactions::TransactionHashDomain}; /// Implement the canonical hashing function for TransactionOutput and UnblindedOutput for use in /// ordering as well as for the output hash calculation for TransactionInput. @@ -94,7 +94,7 @@ pub(super) fn hash_output( encrypted_value: &EncryptedValue, minimum_value_promise: MicroTari, ) -> [u8; 32] { - let common_hash = ConsensusHasher::default() + let common_hash = DomainSeparatedConsensusHasher::::new("transaction_output") .chain(&version) .chain(features) .chain(commitment) diff --git a/base_layer/core/src/transactions/transaction_components/test.rs b/base_layer/core/src/transactions/transaction_components/test.rs index 1ee67ed725..2f107b4b29 100644 --- a/base_layer/core/src/transactions/transaction_components/test.rs +++ b/base_layer/core/src/transactions/transaction_components/test.rs @@ -231,7 +231,7 @@ fn kernel_hash() { .unwrap(); assert_eq!( &k.hash().to_hex(), - "72158351bed5c9b3d9d626821ea1d775e31456f4d762d09cee21a9032d214e3c" + "a3443f6f77ad0546128559e1ea874e184ea4967c265a7b201a837218ed0298d7" ); } @@ -250,7 +250,7 @@ fn kernel_metadata() { .unwrap(); assert_eq!( &k.hash().to_hex(), - "6bf18baef9296815dc9fa1a6ddee2e90a471c63ba86f8542311d2a73881ade18" + "7d245a06bd53031d9b24f6f5c4e94ff7782d83f51a1af9e93788f2c51f9dc4f1" ) } diff --git a/base_layer/core/src/transactions/transaction_components/transaction_input.rs b/base_layer/core/src/transactions/transaction_components/transaction_input.rs index 5135a1dd6b..72231784c6 100644 --- a/base_layer/core/src/transactions/transaction_components/transaction_input.rs +++ b/base_layer/core/src/transactions/transaction_components/transaction_input.rs @@ -40,7 +40,7 @@ use tari_script::{ExecutionStack, ScriptContext, StackItem, TariScript}; use super::{TransactionInputVersion, TransactionOutputVersion}; use crate::{ - consensus::{ConsensusDecoding, ConsensusEncoding, ConsensusHasher, DomainSeparatedConsensusHasher, MaxSizeBytes}, + consensus::{ConsensusDecoding, ConsensusEncoding, DomainSeparatedConsensusHasher, MaxSizeBytes}, covenants::Covenant, transactions::{ tari_amount::MicroTari, @@ -381,7 +381,7 @@ impl TransactionInput { ref minimum_value_promise, } => { // TODO: Change this hash to what is in RFC-0121/Consensus Encoding #testnet-reset - let writer = ConsensusHasher::default() + let writer = DomainSeparatedConsensusHasher::::new("transaction_input") .chain(version) .chain(features) .chain(commitment) diff --git a/base_layer/core/src/transactions/transaction_components/transaction_kernel.rs b/base_layer/core/src/transactions/transaction_components/transaction_kernel.rs index 7fad6e2603..21c70ffafa 100644 --- a/base_layer/core/src/transactions/transaction_components/transaction_kernel.rs +++ b/base_layer/core/src/transactions/transaction_components/transaction_kernel.rs @@ -36,7 +36,7 @@ use tari_utilities::{hex::Hex, message_format::MessageFormat, ByteArray, Hashabl use super::TransactionKernelVersion; use crate::{ - consensus::{ConsensusDecoding, ConsensusEncoding, ConsensusHasher, DomainSeparatedConsensusHasher}, + consensus::{ConsensusDecoding, ConsensusEncoding, DomainSeparatedConsensusHasher}, transactions::{ tari_amount::MicroTari, transaction_components::{KernelFeatures, TransactionError}, @@ -193,7 +193,10 @@ impl TransactionKernel { impl Hashable for TransactionKernel { /// Produce a canonical hash for a transaction kernel. fn hash(&self) -> Vec { - ConsensusHasher::default().chain(self).finalize().to_vec() + DomainSeparatedConsensusHasher::::new("transaction_kernel") + .chain(self) + .finalize() + .to_vec() } } diff --git a/base_layer/core/src/transactions/transaction_components/transaction_output.rs b/base_layer/core/src/transactions/transaction_components/transaction_output.rs index 00a78ccf5f..9323bd5671 100644 --- a/base_layer/core/src/transactions/transaction_components/transaction_output.rs +++ b/base_layer/core/src/transactions/transaction_components/transaction_output.rs @@ -55,13 +55,7 @@ use tari_script::TariScript; use super::TransactionOutputVersion; use crate::{ - consensus::{ - ConsensusDecoding, - ConsensusEncoding, - ConsensusEncodingSized, - ConsensusHasher, - DomainSeparatedConsensusHasher, - }, + consensus::{ConsensusDecoding, ConsensusEncoding, ConsensusEncodingSized, DomainSeparatedConsensusHasher}, covenants::Covenant, transactions::{ tari_amount::MicroTari, @@ -395,7 +389,7 @@ impl TransactionOutput { } pub fn witness_hash(&self) -> Vec { - ConsensusHasher::default() + DomainSeparatedConsensusHasher::::new("transaction_output_witness") .chain(&self.proof) .chain(&self.metadata_signature) .finalize() diff --git a/base_layer/core/tests/block_validation.rs b/base_layer/core/tests/block_validation.rs index c2ea9271f9..635432e7ae 100644 --- a/base_layer/core/tests/block_validation.rs +++ b/base_layer/core/tests/block_validation.rs @@ -25,6 +25,7 @@ use std::sync::Arc; use monero::blockdata::block::Block as MoneroBlock; use rand::{rngs::OsRng, RngCore}; use tari_common::configuration::Network; +use tari_common_types::types::FixedHash; use tari_core::{ blocks::{Block, BlockHeaderAccumulatedData, BlockHeaderValidationError, BlockValidationError, ChainBlock}, chain_storage::{BlockchainDatabase, BlockchainDatabaseConfig, ChainStorageError, Validators}, @@ -539,7 +540,7 @@ OutputFeatures::default()), // check mmr roots let mut new_block = db.prepare_new_block(template).unwrap(); - new_block.header.output_mr = Vec::new(); + new_block.header.output_mr = FixedHash::zero(); new_block.header.nonce = OsRng.next_u64(); find_header_with_achieved_difficulty(&mut new_block.header, 10.into()); @@ -821,6 +822,6 @@ async fn test_block_sync_body_validator() { // lets the mmr root let (template, _) = chain_block_with_new_coinbase(&genesis, vec![tx01, tx02], &rules, &factories); let mut new_block = db.prepare_new_block(template).unwrap(); - new_block.header.output_mr = Vec::new(); + new_block.header.output_mr = FixedHash::zero(); validator.validate_body(new_block).await.unwrap_err(); } diff --git a/base_layer/core/tests/helpers/block_builders.rs b/base_layer/core/tests/helpers/block_builders.rs index 18998e9d6f..5797a049eb 100644 --- a/base_layer/core/tests/helpers/block_builders.rs +++ b/base_layer/core/tests/helpers/block_builders.rs @@ -20,12 +20,12 @@ // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE // USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -use std::{iter::repeat_with, sync::Arc}; +use std::{convert::TryFrom, iter::repeat_with, sync::Arc}; use croaring::Bitmap; use rand::{rngs::OsRng, RngCore}; use tari_common::configuration::Network; -use tari_common_types::types::{Commitment, HashOutput, PublicKey}; +use tari_common_types::types::{Commitment, FixedHash, HashOutput, PublicKey}; use tari_core::{ blocks::{Block, BlockHeader, BlockHeaderAccumulatedData, ChainBlock, ChainHeader, NewBlockTemplate}, chain_storage::{BlockAddResult, BlockchainBackend, BlockchainDatabase, ChainStorageError}, @@ -163,10 +163,10 @@ fn print_new_genesis_block(network: Network) { let mut output_mmr = MutableOutputMmr::new(Vec::new(), Bitmap::create()).unwrap(); output_mmr.push(utxo.hash()).unwrap(); - header.kernel_mr = kernel_mmr.get_merkle_root().unwrap(); + header.kernel_mr = FixedHash::try_from(kernel_mmr.get_merkle_root().unwrap()).unwrap(); header.kernel_mmr_size += 1; - header.output_mr = output_mmr.get_merkle_root().unwrap(); - header.witness_mr = witness_mmr.get_merkle_root().unwrap(); + header.output_mr = FixedHash::try_from(output_mmr.get_merkle_root().unwrap()).unwrap(); + header.witness_mr = FixedHash::try_from(witness_mmr.get_merkle_root().unwrap()).unwrap(); header.output_mmr_size += 1; // header.kernel_mr = kernel.hash(); @@ -250,15 +250,24 @@ fn update_genesis_block_mmr_roots(template: NewBlockTemplate) -> Result = body.outputs().iter().map(|out| out.witness_hash()).collect(); let mut header = BlockHeader::from(header); - header.kernel_mr = BaseLayerKernelMutableMmr::new(kernel_hashes, Bitmap::create()) - .unwrap() - .get_merkle_root()?; - header.output_mr = MutableOutputMmr::new(out_hashes, Bitmap::create()) - .unwrap() - .get_merkle_root()?; - header.witness_mr = BaseLayerWitnessMutableMmr::new(rp_hashes, Bitmap::create()) - .unwrap() - .get_merkle_root()?; + header.kernel_mr = FixedHash::try_from( + BaseLayerKernelMutableMmr::new(kernel_hashes, Bitmap::create()) + .unwrap() + .get_merkle_root()?, + ) + .unwrap(); + header.output_mr = FixedHash::try_from( + MutableOutputMmr::new(out_hashes, Bitmap::create()) + .unwrap() + .get_merkle_root()?, + ) + .unwrap(); + header.witness_mr = FixedHash::try_from( + BaseLayerWitnessMutableMmr::new(rp_hashes, Bitmap::create()) + .unwrap() + .get_merkle_root()?, + ) + .unwrap(); Ok(Block { header, body }) } diff --git a/base_layer/tari_mining_helper_ffi/src/lib.rs b/base_layer/tari_mining_helper_ffi/src/lib.rs index 086929f8ff..bbeef6a692 100644 --- a/base_layer/tari_mining_helper_ffi/src/lib.rs +++ b/base_layer/tari_mining_helper_ffi/src/lib.rs @@ -371,8 +371,8 @@ mod tests { #[test] fn detect_change_in_consensus_encoding() { - const NONCE: u64 = 8105414459419666541; - const DIFFICULTY: Difficulty = Difficulty::from_u64(3640); + const NONCE: u64 = 17497411907229199779; + const DIFFICULTY: Difficulty = Difficulty::from_u64(1984); unsafe { let mut error = -1; let error_ptr = &mut error as *mut c_int; diff --git a/integration_tests/helpers/transactionOutputHashing.js b/integration_tests/helpers/transactionOutputHashing.js index 700d7c52fc..2a2759f51c 100644 --- a/integration_tests/helpers/transactionOutputHashing.js +++ b/integration_tests/helpers/transactionOutputHashing.js @@ -1,7 +1,7 @@ // Copyright 2022 The Tari Project // SPDX-License-Identifier: BSD-3-Clause -const { Blake256 } = require("./hashing"); +const { consensusHashers } = require("./hashing"); const { toLittleEndian, encodeOption, @@ -37,12 +37,12 @@ const getTransactionOutputHash = function (output) { // TODO: Keep this number in sync with 'get_current_version()' in 'transaction_output_version.rs' const OUTPUT_FEATURES_VERSION = 0x00; - let hasher = new Blake256(); assertBufferType(output.commitment, 32); assertBufferType(output.script); assertBufferType(output.covenant); assertBufferType(output.encrypted_value, 24); - const hash = hasher + const hash = consensusHashers + .transactionHasher("transaction_output") // version .chain(Buffer.from([OUTPUT_FEATURES_VERSION])) // features diff --git a/integration_tests/package-lock.json b/integration_tests/package-lock.json index 8001fd7bdf..333fa24e9f 100644 --- a/integration_tests/package-lock.json +++ b/integration_tests/package-lock.json @@ -43,27 +43,27 @@ } }, "@babel/compat-data": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.8.tgz", - "integrity": "sha512-HSmX4WZPPK3FUxYp7g2T6EyO8j96HlZJlxmKPSh6KAcqwyDrfx7hKjXpAW/0FhFfTJsR0Yt4lAjLI2coMptIHQ==", + "version": "7.18.13", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.13.tgz", + "integrity": "sha512-5yUzC5LqyTFp2HLmDoxGQelcdYgSpP9xsnMWBphAscOdFrHSAVbLNzWiy32sVNDqJRDiJK6klfDnAgu6PAGSHw==", "dev": true }, "@babel/core": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.10.tgz", - "integrity": "sha512-JQM6k6ENcBFKVtWvLavlvi/mPcpYZ3+R+2EySDEMSMbp7Mn4FexlbbJVrx2R7Ijhr01T8gyqrOaABWIOgxeUyw==", + "version": "7.18.13", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.13.tgz", + "integrity": "sha512-ZisbOvRRusFktksHSG6pjj1CSvkPkcZq/KHD45LAkVP/oiHJkNBZWfpvlLmX8OtHDG8IuzsFlVRWo08w7Qxn0A==", "dev": true, "requires": { "@ampproject/remapping": "^2.1.0", "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.18.10", + "@babel/generator": "^7.18.13", "@babel/helper-compilation-targets": "^7.18.9", "@babel/helper-module-transforms": "^7.18.9", "@babel/helpers": "^7.18.9", - "@babel/parser": "^7.18.10", + "@babel/parser": "^7.18.13", "@babel/template": "^7.18.10", - "@babel/traverse": "^7.18.10", - "@babel/types": "^7.18.10", + "@babel/traverse": "^7.18.13", + "@babel/types": "^7.18.13", "convert-source-map": "^1.7.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", @@ -92,12 +92,12 @@ } }, "@babel/generator": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.10.tgz", - "integrity": "sha512-0+sW7e3HjQbiHbj1NeU/vN8ornohYlacAfZIaXhdoGweQqgcNy69COVciYYqEXJ/v+9OBA7Frxm4CVAuNqKeNA==", + "version": "7.18.13", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.13.tgz", + "integrity": "sha512-CkPg8ySSPuHTYPJYo7IRALdqyjM9HCbt/3uOBEFbzyGVP6Mn8bwFPB0jX6982JVNBlYzM1nnPkfjuXSOPtQeEQ==", "dev": true, "requires": { - "@babel/types": "^7.18.10", + "@babel/types": "^7.18.13", "@jridgewell/gen-mapping": "^0.3.2", "jsesc": "^2.5.1" }, @@ -244,9 +244,9 @@ } }, "@babel/parser": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.10.tgz", - "integrity": "sha512-TYk3OA0HKL6qNryUayb5UUEhM/rkOQozIBEA5ITXh5DWrSp0TlUQXMyZmnWxG/DizSWBeeQ0Zbc5z8UGaaqoeg==", + "version": "7.18.13", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.13.tgz", + "integrity": "sha512-dgXcIfMuQ0kgzLB2b9tRZs7TTFFaGM2AbtA4fJgUUYukzGH4jwsS7hzQHEGs67jdehpm22vkgKwvbU+aEflgwg==", "dev": true }, "@babel/runtime": { @@ -270,27 +270,27 @@ } }, "@babel/traverse": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.10.tgz", - "integrity": "sha512-J7ycxg0/K9XCtLyHf0cz2DqDihonJeIo+z+HEdRe9YuT8TY4A66i+Ab2/xZCEW7Ro60bPCBBfqqboHSamoV3+g==", + "version": "7.18.13", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.13.tgz", + "integrity": "sha512-N6kt9X1jRMLPxxxPYWi7tgvJRH/rtoU+dbKAPDM44RFHiMH8igdsaSBgFeskhSl/kLWLDUvIh1RXCrTmg0/zvA==", "dev": true, "requires": { "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.18.10", + "@babel/generator": "^7.18.13", "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-function-name": "^7.18.9", "@babel/helper-hoist-variables": "^7.18.6", "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/parser": "^7.18.10", - "@babel/types": "^7.18.10", + "@babel/parser": "^7.18.13", + "@babel/types": "^7.18.13", "debug": "^4.1.0", "globals": "^11.1.0" } }, "@babel/types": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.10.tgz", - "integrity": "sha512-MJvnbEiiNkpjo+LknnmRrqbY1GPUUggjv+wQVjetM/AONoupqRALB7I6jGqNUAZsKcRIEu2J6FRFvsczljjsaQ==", + "version": "7.18.13", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.13.tgz", + "integrity": "sha512-ePqfTihzW0W6XAU+aMw2ykilisStJfDnsejDCXRchCcMJ4O0+8DhPXf2YUbZ6wjBlsEmZwLK/sPweWtu8hcJYQ==", "dev": true, "requires": { "@babel/helper-string-parser": "^7.18.10", @@ -714,9 +714,9 @@ "dev": true }, "@jridgewell/trace-mapping": { - "version": "0.3.14", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz", - "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==", + "version": "0.3.15", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz", + "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==", "dev": true, "requires": { "@jridgewell/resolve-uri": "^3.0.3", @@ -1051,9 +1051,9 @@ "dev": true }, "caniuse-lite": { - "version": "1.0.30001373", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001373.tgz", - "integrity": "sha512-pJYArGHrPp3TUqQzFYRmP/lwJlj8RCbVe3Gd3eJQkAV8SAC6b19XS9BjMvRdvaS8RMkaTN8ZhoHP6S1y8zzwEQ==", + "version": "1.0.30001382", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001382.tgz", + "integrity": "sha512-2rtJwDmSZ716Pxm1wCtbPvHtbDWAreTPxXbkc5RkKglow3Ig/4GNGazDI9/BVnXbG/wnv6r3B5FEbkfg9OcTGg==", "dev": true }, "capital-case": { @@ -1308,9 +1308,9 @@ "dev": true }, "electron-to-chromium": { - "version": "1.4.210", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.210.tgz", - "integrity": "sha512-kSiX4tuyZijV7Cz0MWVmGT8K2siqaOA4Z66K5dCttPPRh0HicOcOAEj1KlC8O8J1aOS/1M8rGofOzksLKaHWcQ==", + "version": "1.4.227", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.227.tgz", + "integrity": "sha512-I9VVajA3oswIJOUFg2PSBqrHLF5Y+ahIfjOV9+v6uYyBqFZutmPxA6fxocDUUmgwYevRWFu1VjLyVG3w45qa/g==", "dev": true }, "emoji-regex": { diff --git a/integration_tests/package.json b/integration_tests/package.json index cc450dd2a1..5345c02199 100644 --- a/integration_tests/package.json +++ b/integration_tests/package.json @@ -14,7 +14,7 @@ "author": "The Tari Project", "license": "ISC", "devDependencies": { - "@babel/core": "^7.18.10", + "@babel/core": "^7.18.13", "@babel/eslint-parser": "^7.18.9", "@babel/eslint-plugin": "^7.18.10", "@cucumber/cucumber": "^8.5.1",