SyntheticBird/cuprate-hinto-janai
1
0
Fork 0
mirror of https://github.com/hinto-janai/cuprate.git synced 2025-01-03 17:40:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix link errors in cargo doc (#55)

Browse source 
fix `cargo doc` - links not using `<>`
This commit is contained in:
hinto-janai 2024-02-09 19:08:39 -05:00 committed by GitHub
parent 1f677562eb
commit 0d8f71b4c7
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 115 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
consensus/rules/src/blocks.rs
View file

@ -56,7 +56,7 @@ pub fn is_randomx_seed_height(height: u64) -> bool {
/// Returns the RandomX seed height for this block. /// Returns the RandomX seed height for this block.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#randomx-seed /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#randomx-seed>
pub fn randomx_seed_height(height: u64) -> u64 { pub fn randomx_seed_height(height: u64) -> u64 {
if height <= RX_SEEDHASH_EPOCH_BLOCKS + RX_SEEDHASH_EPOCH_LAG { if height <= RX_SEEDHASH_EPOCH_BLOCKS + RX_SEEDHASH_EPOCH_LAG {
0 0
@ -69,7 +69,7 @@ pub fn randomx_seed_height(height: u64) -> u64 {
/// ///
/// `randomx_vm` must be [`Some`] after hf 12. /// `randomx_vm` must be [`Some`] after hf 12.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#pow-function /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#pow-function>
pub fn calculate_pow_hash<R: RandomX>( pub fn calculate_pow_hash<R: RandomX>(
randomx_vm: Option<&R>, randomx_vm: Option<&R>,
buf: &[u8], buf: &[u8],
@ -98,7 +98,7 @@ pub fn calculate_pow_hash<R: RandomX>(
/// Returns if the blocks POW hash is valid for the current difficulty. /// Returns if the blocks POW hash is valid for the current difficulty.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#checking-pow-hash /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#checking-pow-hash>
pub fn check_block_pow(hash: &[u8; 32], difficulty: u128) -> Result<(), BlockError> { pub fn check_block_pow(hash: &[u8; 32], difficulty: u128) -> Result<(), BlockError> {
let int_hash = U256::from_le_slice(hash); let int_hash = U256::from_le_slice(hash);
@ -118,7 +118,7 @@ pub fn check_block_pow(hash: &[u8; 32], difficulty: u128) -> Result<(), BlockErr
/// Returns the penalty free zone /// Returns the penalty free zone
/// ///
/// https://cuprate.github.io/monero-book/consensus_rules/blocks/weight_limit.html#penalty-free-zone /// <https://cuprate.github.io/monero-book/consensus_rules/blocks/weight_limit.html#penalty-free-zone>
pub fn penalty_free_zone(hf: &HardFork) -> usize { pub fn penalty_free_zone(hf: &HardFork) -> usize {
if hf == &HardFork::V1 { if hf == &HardFork::V1 {
PENALTY_FREE_ZONE_1 PENALTY_FREE_ZONE_1
@ -131,7 +131,7 @@ pub fn penalty_free_zone(hf: &HardFork) -> usize {
/// Sanity check on the block blob size. /// Sanity check on the block blob size.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#block-weight-and-size /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#block-weight-and-size>
fn block_size_sanity_check( fn block_size_sanity_check(
block_blob_len: usize, block_blob_len: usize,
effective_median: usize, effective_median: usize,
@ -145,7 +145,7 @@ fn block_size_sanity_check(
/// Sanity check on the block weight. /// Sanity check on the block weight.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#block-weight-and-size /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#block-weight-and-size>
fn check_block_weight( fn check_block_weight(
block_weight: usize, block_weight: usize,
median_for_block_reward: usize, median_for_block_reward: usize,
@ -159,7 +159,7 @@ fn check_block_weight(
/// Sanity check on number of txs in the block. /// Sanity check on number of txs in the block.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#amount-of-transactions /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#amount-of-transactions>
fn check_amount_txs(number_none_miner_txs: usize) -> Result<(), BlockError> { fn check_amount_txs(number_none_miner_txs: usize) -> Result<(), BlockError> {
if number_none_miner_txs + 1 > 0x10000000 { if number_none_miner_txs + 1 > 0x10000000 {
Err(BlockError::TooManyTxs) Err(BlockError::TooManyTxs)
@ -170,7 +170,7 @@ fn check_amount_txs(number_none_miner_txs: usize) -> Result<(), BlockError> {
/// Verifies the previous id is the last blocks hash /// Verifies the previous id is the last blocks hash
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#previous-id /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#previous-id>
fn check_prev_id(block: &Block, top_hash: &[u8; 32]) -> Result<(), BlockError> { fn check_prev_id(block: &Block, top_hash: &[u8; 32]) -> Result<(), BlockError> {
if &block.header.previous != top_hash { if &block.header.previous != top_hash {
Err(BlockError::PreviousIDIncorrect) Err(BlockError::PreviousIDIncorrect)
@ -181,7 +181,7 @@ fn check_prev_id(block: &Block, top_hash: &[u8; 32]) -> Result<(), BlockError> {
/// Checks the blocks timestamp is in the valid range. /// Checks the blocks timestamp is in the valid range.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#timestamp /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#timestamp>
fn check_timestamp(block: &Block, median_timestamp: u64) -> Result<(), BlockError> { fn check_timestamp(block: &Block, median_timestamp: u64) -> Result<(), BlockError> {
if block.header.timestamp < median_timestamp if block.header.timestamp < median_timestamp
|| block.header.timestamp > current_unix_timestamp() + BLOCK_FUTURE_TIME_LIMIT || block.header.timestamp > current_unix_timestamp() + BLOCK_FUTURE_TIME_LIMIT
@ -194,7 +194,7 @@ fn check_timestamp(block: &Block, median_timestamp: u64) -> Result<(), BlockErro
/// Checks that all txs in the block have a unique hash. /// Checks that all txs in the block have a unique hash.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks.html#no-duplicate-transactions /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks.html#no-duplicate-transactions>
fn check_txs_unique(txs: &[[u8; 32]]) -> Result<(), BlockError> { fn check_txs_unique(txs: &[[u8; 32]]) -> Result<(), BlockError> {
txs.windows(2).try_for_each(|window| { txs.windows(2).try_for_each(|window| {
if window[0] == window[1] { if window[0] == window[1] {
@ -208,9 +208,9 @@ fn check_txs_unique(txs: &[[u8; 32]]) -> Result<(), BlockError> {
/// the data in this struct is calculated correctly. /// the data in this struct is calculated correctly.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct ContextToVerifyBlock { pub struct ContextToVerifyBlock {
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/weights.html#median-weight-for-coinbase-checks /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/weights.html#median-weight-for-coinbase-checks>
pub median_weight_for_block_reward: usize, pub median_weight_for_block_reward: usize,
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/weights.html#effective-median-weight /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/weights.html#effective-median-weight>
pub effective_median_weight: usize, pub effective_median_weight: usize,
/// The top hash of the blockchain, aka the block hash of the previous block to the one we are verifying. /// The top hash of the blockchain, aka the block hash of the previous block to the one we are verifying.
pub top_hash: [u8; 32], pub top_hash: [u8; 32],
@ -220,7 +220,7 @@ pub struct ContextToVerifyBlock {
pub chain_height: u64, pub chain_height: u64,
/// The current hard-fork. /// The current hard-fork.
pub current_hf: HardFork, pub current_hf: HardFork,
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#calculating-difficulty /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#calculating-difficulty>
pub next_difficulty: u128, pub next_difficulty: u128,
/// The amount of coins already minted. /// The amount of coins already minted.
pub already_generated_coins: u64, pub already_generated_coins: u64,
@ -234,8 +234,8 @@ pub struct ContextToVerifyBlock {
/// ///
/// Missed block checks in this function: /// Missed block checks in this function:
/// ///
/// https://monero-book.cuprate.org/consensus_rules/blocks.html#key-images /// <https://monero-book.cuprate.org/consensus_rules/blocks.html#key-images>
/// https://monero-book.cuprate.org/consensus_rules/blocks.html#checking-pow-hash /// <https://monero-book.cuprate.org/consensus_rules/blocks.html#checking-pow-hash>
/// ///
/// ///
pub fn check_block( pub fn check_block(

4
consensus/rules/src/decomposed_amount.rs
View file

@ -36,8 +36,8 @@ pub fn decomposed_amounts() -> &'static [u64; 172] {
/// ///
/// This is also used during miner tx verification. /// This is also used during miner tx verification.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#output-amount /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#output-amount>
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#output-amounts /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#output-amounts>
#[inline] #[inline]
pub fn is_decomposed_amount(amount: &u64) -> bool { pub fn is_decomposed_amount(amount: &u64) -> bool {
decomposed_amounts().binary_search(amount).is_ok() decomposed_amounts().binary_search(amount).is_ok()

2
consensus/rules/src/genesis.rs
View file

@ -25,7 +25,7 @@ fn genesis_miner_tx(network: &Network) -> Transaction {
/// Generates the Monero genesis block. /// Generates the Monero genesis block.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/genesis_block.html /// ref: <https://monero-book.cuprate.org/consensus_rules/genesis_block.html>
pub fn generate_genesis_block(network: &Network) -> Block { pub fn generate_genesis_block(network: &Network) -> Block {
Block { Block {
header: BlockHeader { header: BlockHeader {

24
consensus/rules/src/hard_forks.rs
View file

@ -18,11 +18,11 @@ mod tests;
/// Target block time for hf 1. /// Target block time for hf 1.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#target-seconds /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#target-seconds>
const BLOCK_TIME_V1: Duration = Duration::from_secs(60); const BLOCK_TIME_V1: Duration = Duration::from_secs(60);
/// Target block time from v2. /// Target block time from v2.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#target-seconds /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#target-seconds>
const BLOCK_TIME_V2: Duration = Duration::from_secs(120); const BLOCK_TIME_V2: Duration = Duration::from_secs(120);
pub const NUMB_OF_HARD_FORKS: usize = 16; pub const NUMB_OF_HARD_FORKS: usize = 16;
@ -64,7 +64,7 @@ impl HFsInfo {
/// Returns the main-net hard-fork information. /// Returns the main-net hard-fork information.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#Mainnet-Hard-Forks /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#Mainnet-Hard-Forks>
pub const fn main_net() -> HFsInfo { pub const fn main_net() -> HFsInfo {
Self([ Self([
HFInfo::new(0, 0), HFInfo::new(0, 0),
@ -88,7 +88,7 @@ impl HFsInfo {
/// Returns the test-net hard-fork information. /// Returns the test-net hard-fork information.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#Testnet-Hard-Forks /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#Testnet-Hard-Forks>
pub const fn test_net() -> HFsInfo { pub const fn test_net() -> HFsInfo {
Self([ Self([
HFInfo::new(0, 0), HFInfo::new(0, 0),
@ -112,7 +112,7 @@ impl HFsInfo {
/// Returns the test-net hard-fork information. /// Returns the test-net hard-fork information.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#Stagenet-Hard-Forks /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#Stagenet-Hard-Forks>
pub const fn stage_net() -> HFsInfo { pub const fn stage_net() -> HFsInfo {
Self([ Self([
HFInfo::new(0, 0), HFInfo::new(0, 0),
@ -162,7 +162,7 @@ pub enum HardFork {
impl HardFork { impl HardFork {
/// Returns the hard-fork for a blocks `major_version` field. /// Returns the hard-fork for a blocks `major_version` field.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/hardforks.html#blocks-version-and-vote /// <https://monero-book.cuprate.org/consensus_rules/hardforks.html#blocks-version-and-vote>
pub fn from_version(version: u8) -> Result<HardFork, HardForkError> { pub fn from_version(version: u8) -> Result<HardFork, HardForkError> {
Ok(match version { Ok(match version {
1 => HardFork::V1, 1 => HardFork::V1,
@ -187,7 +187,7 @@ impl HardFork {
/// Returns the hard-fork for a blocks `minor_version` (vote) field. /// Returns the hard-fork for a blocks `minor_version` (vote) field.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/hardforks.html#blocks-version-and-vote /// <https://monero-book.cuprate.org/consensus_rules/hardforks.html#blocks-version-and-vote>
pub fn from_vote(vote: u8) -> HardFork { pub fn from_vote(vote: u8) -> HardFork {
if vote == 0 { if vote == 0 {
// A vote of 0 is interpreted as 1 as that's what Monero used to default to. // A vote of 0 is interpreted as 1 as that's what Monero used to default to.
@ -211,7 +211,7 @@ impl HardFork {
/// Returns the target block time for this hardfork. /// Returns the target block time for this hardfork.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#target-seconds /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/difficulty.html#target-seconds>
pub fn block_time(&self) -> Duration { pub fn block_time(&self) -> Duration {
match self { match self {
HardFork::V1 => BLOCK_TIME_V1, HardFork::V1 => BLOCK_TIME_V1,
@ -221,7 +221,7 @@ impl HardFork {
/// Checks a blocks version and vote, assuming that `self` is the current hard-fork. /// Checks a blocks version and vote, assuming that `self` is the current hard-fork.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#blocks-version-and-vote /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#blocks-version-and-vote>
pub fn check_block_version_vote( pub fn check_block_version_vote(
&self, &self,
version: &HardFork, version: &HardFork,
@ -292,7 +292,7 @@ impl HFVotes {
/// Returns the total votes for a hard-fork. /// Returns the total votes for a hard-fork.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#accepting-a-fork /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#accepting-a-fork>
pub fn votes_for_hf(&self, hf: &HardFork) -> u64 { pub fn votes_for_hf(&self, hf: &HardFork) -> u64 {
self.votes[*hf as usize - 1..].iter().sum() self.votes[*hf as usize - 1..].iter().sum()
} }
@ -305,7 +305,7 @@ impl HFVotes {
/// Checks if a future hard fork should be activated, returning the next hard-fork that should be /// Checks if a future hard fork should be activated, returning the next hard-fork that should be
/// activated. /// activated.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#accepting-a-fork /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#accepting-a-fork>
pub fn current_fork( pub fn current_fork(
&self, &self,
current_hf: &HardFork, current_hf: &HardFork,
@ -335,7 +335,7 @@ impl HFVotes {
/// Returns the votes needed for a hard-fork. /// Returns the votes needed for a hard-fork.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/hardforks.html#accepting-a-fork /// ref: <https://monero-book.cuprate.org/consensus_rules/hardforks.html#accepting-a-fork>
pub fn votes_needed(threshold: u64, window: u64) -> u64 { pub fn votes_needed(threshold: u64, window: u64) -> u64 {
(threshold * window).div_ceil(100) (threshold * window).div_ceil(100)
} }

2
consensus/rules/src/lib.rs
View file

@ -21,7 +21,7 @@ pub enum ConsensusError {
/// Checks that a point is canonically encoded. /// Checks that a point is canonically encoded.
/// ///
/// https://github.com/dalek-cryptography/curve25519-dalek/issues/380 /// <https://github.com/dalek-cryptography/curve25519-dalek/issues/380>
fn check_point_canonically_encoded(point: &curve25519_dalek::edwards::CompressedEdwardsY) -> bool { fn check_point_canonically_encoded(point: &curve25519_dalek::edwards::CompressedEdwardsY) -> bool {
let bytes = point.as_bytes(); let bytes = point.as_bytes();

20
consensus/rules/src/miner_tx.rs
View file

@ -40,7 +40,7 @@ const MINER_TX_TIME_LOCKED_BLOCKS: u64 = 60;
/// Calculates the base block reward without taking away the penalty for expanding /// Calculates the base block reward without taking away the penalty for expanding
/// the block. /// the block.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/reward.html#calculating-base-block-reward /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/reward.html#calculating-base-block-reward>
fn calculate_base_reward(already_generated_coins: u64, hf: &HardFork) -> u64 { fn calculate_base_reward(already_generated_coins: u64, hf: &HardFork) -> u64 {
let target_mins = hf.block_time().as_secs() / 60; let target_mins = hf.block_time().as_secs() / 60;
let emission_speed_factor = 20 - (target_mins - 1); let emission_speed_factor = 20 - (target_mins - 1);
@ -50,7 +50,7 @@ fn calculate_base_reward(already_generated_coins: u64, hf: &HardFork) -> u64 {
/// Calculates the miner reward for this block. /// Calculates the miner reward for this block.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/reward.html#calculating-block-reward /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/reward.html#calculating-block-reward>
pub fn calculate_block_reward( pub fn calculate_block_reward(
block_weight: usize, block_weight: usize,
median_bw: usize, median_bw: usize,
@ -75,7 +75,7 @@ pub fn calculate_block_reward(
/// Checks the miner transactions version. /// Checks the miner transactions version.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#version /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#version>
fn check_miner_tx_version(tx_version: &TxVersion, hf: &HardFork) -> Result<(), MinerTxError> { fn check_miner_tx_version(tx_version: &TxVersion, hf: &HardFork) -> Result<(), MinerTxError> {
// The TxVersion enum checks if the version is not 1 or 2 // The TxVersion enum checks if the version is not 1 or 2
if hf >= &HardFork::V12 && tx_version != &TxVersion::RingCT { if hf >= &HardFork::V12 && tx_version != &TxVersion::RingCT {
@ -87,7 +87,7 @@ fn check_miner_tx_version(tx_version: &TxVersion, hf: &HardFork) -> Result<(), M
/// Checks the miner transactions inputs. /// Checks the miner transactions inputs.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#input /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#input>
fn check_inputs(inputs: &[Input], chain_height: u64) -> Result<(), MinerTxError> { fn check_inputs(inputs: &[Input], chain_height: u64) -> Result<(), MinerTxError> {
if inputs.len() != 1 { if inputs.len() != 1 {
return Err(MinerTxError::IncorrectNumbOfInputs); return Err(MinerTxError::IncorrectNumbOfInputs);
@ -107,7 +107,7 @@ fn check_inputs(inputs: &[Input], chain_height: u64) -> Result<(), MinerTxError>
/// Checks the miner transaction has a correct time lock. /// Checks the miner transaction has a correct time lock.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#unlock-time /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#unlock-time>
fn check_time_lock(time_lock: &Timelock, chain_height: u64) -> Result<(), MinerTxError> { fn check_time_lock(time_lock: &Timelock, chain_height: u64) -> Result<(), MinerTxError> {
match time_lock { match time_lock {
Timelock::Block(till_height) => { Timelock::Block(till_height) => {
@ -128,8 +128,8 @@ fn check_time_lock(time_lock: &Timelock, chain_height: u64) -> Result<(), MinerT
/// Sums the outputs checking for overflow. /// Sums the outputs checking for overflow.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#output-amounts /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#output-amounts>
/// && https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#zero-amount-v1-output /// && <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#zero-amount-v1-output>
fn sum_outputs( fn sum_outputs(
outputs: &[Output], outputs: &[Output],
hf: &HardFork, hf: &HardFork,
@ -153,7 +153,7 @@ fn sum_outputs(
/// Checks the total outputs amount is correct returning the amount of coins collected by the miner. /// Checks the total outputs amount is correct returning the amount of coins collected by the miner.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#total-outputs /// ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#total-outputs>
fn check_total_output_amt( fn check_total_output_amt(
total_output: u64, total_output: u64,
reward: u64, reward: u64,
@ -176,7 +176,7 @@ fn check_total_output_amt(
/// Checks all miner transactions rules. /// Checks all miner transactions rules.
/// ///
/// Excluding: /// Excluding:
/// https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#v2-output-pool /// <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#v2-output-pool>
/// ///
/// as this needs to be done in a database. /// as this needs to be done in a database.
pub fn check_miner_tx( pub fn check_miner_tx(
@ -191,7 +191,7 @@ pub fn check_miner_tx(
let tx_version = TxVersion::from_raw(tx.prefix.version).ok_or(MinerTxError::VersionInvalid)?; let tx_version = TxVersion::from_raw(tx.prefix.version).ok_or(MinerTxError::VersionInvalid)?;
check_miner_tx_version(&tx_version, hf)?; check_miner_tx_version(&tx_version, hf)?;
// ref: https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#ringct-type // ref: <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#ringct-type>
if hf >= &HardFork::V12 && tx.rct_signatures.rct_type() != RctType::Null { if hf >= &HardFork::V12 && tx.rct_signatures.rct_type() != RctType::Null {
return Err(MinerTxError::RCTTypeNotNULL); return Err(MinerTxError::RCTTypeNotNULL);
} }

70
consensus/rules/src/transactions.rs
View file

@ -86,8 +86,8 @@ impl TxVersion {
/// ///
/// This will return `None` on invalid values. /// This will return `None` on invalid values.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions.html#version /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions.html#version>
/// && https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#version /// && <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#version>
pub fn from_raw(version: u64) -> Option<TxVersion> { pub fn from_raw(version: u64) -> Option<TxVersion> {
Some(match version { Some(match version {
1 => TxVersion::RingSignatures, 1 => TxVersion::RingSignatures,
@ -101,7 +101,7 @@ impl TxVersion {
/// Checks the output keys are canonically encoded points. /// Checks the output keys are canonically encoded points.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-keys-canonical /// <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-keys-canonical>
fn check_output_keys(outputs: &[Output]) -> Result<(), TransactionError> { fn check_output_keys(outputs: &[Output]) -> Result<(), TransactionError> {
for out in outputs { for out in outputs {
if !check_point_canonically_encoded(&out.key) { if !check_point_canonically_encoded(&out.key) {
@ -116,8 +116,8 @@ fn check_output_keys(outputs: &[Output]) -> Result<(), TransactionError> {
/// ///
/// This is also used during miner-tx verification. /// This is also used during miner-tx verification.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-type /// <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-type>
/// https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#output-type /// <https://monero-book.cuprate.org/consensus_rules/blocks/miner_tx.html#output-type>
pub(crate) fn check_output_types( pub(crate) fn check_output_types(
outputs: &[Output], outputs: &[Output],
hf: &HardFork, hf: &HardFork,
@ -143,7 +143,7 @@ pub(crate) fn check_output_types(
/// Checks the individual outputs amount for version 1 txs. /// Checks the individual outputs amount for version 1 txs.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-amount /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-amount>
fn check_output_amount_v1(amount: u64, hf: &HardFork) -> Result<(), TransactionError> { fn check_output_amount_v1(amount: u64, hf: &HardFork) -> Result<(), TransactionError> {
if amount == 0 { if amount == 0 {
return Err(TransactionError::ZeroOutputForV1); return Err(TransactionError::ZeroOutputForV1);
@ -158,7 +158,7 @@ fn check_output_amount_v1(amount: u64, hf: &HardFork) -> Result<(), TransactionE
/// Checks the individual outputs amount for version 2 txs. /// Checks the individual outputs amount for version 2 txs.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-amount /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-amount>
fn check_output_amount_v2(amount: u64) -> Result<(), TransactionError> { fn check_output_amount_v2(amount: u64) -> Result<(), TransactionError> {
if amount == 0 { if amount == 0 {
Ok(()) Ok(())
@ -169,8 +169,8 @@ fn check_output_amount_v2(amount: u64) -> Result<(), TransactionError> {
/// Sums the outputs, checking for overflow and other consensus rules. /// Sums the outputs, checking for overflow and other consensus rules.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-amount /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#output-amount>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#outputs-must-not-overflow /// && <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#outputs-must-not-overflow>
fn sum_outputs( fn sum_outputs(
outputs: &[Output], outputs: &[Output],
hf: &HardFork, hf: &HardFork,
@ -195,9 +195,9 @@ fn sum_outputs(
/// Checks the number of outputs is allowed. /// Checks the number of outputs is allowed.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#2-outputs /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html#2-outputs>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs.html#max-outputs /// && <https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs.html#max-outputs>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs+.html#max-outputs /// && <https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs+.html#max-outputs>
fn check_number_of_outputs( fn check_number_of_outputs(
outputs: usize, outputs: usize,
hf: &HardFork, hf: &HardFork,
@ -226,9 +226,9 @@ fn check_number_of_outputs(
/// Checks the outputs against all output consensus rules, returning the sum of the output amounts. /// Checks the outputs against all output consensus rules, returning the sum of the output amounts.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/outputs.html>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs.html#max-outputs /// && <https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs.html#max-outputs>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs+.html#max-outputs /// && <https://monero-book.cuprate.org/consensus_rules/transactions/ring_ct/bulletproofs+.html#max-outputs>
fn check_outputs_semantics( fn check_outputs_semantics(
outputs: &[Output], outputs: &[Output],
hf: &HardFork, hf: &HardFork,
@ -246,7 +246,7 @@ fn check_outputs_semantics(
/// Checks if an outputs unlock time has passed. /// Checks if an outputs unlock time has passed.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html /// <https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html>
fn output_unlocked( fn output_unlocked(
time_lock: &Timelock, time_lock: &Timelock,
current_chain_height: u64, current_chain_height: u64,
@ -266,7 +266,7 @@ fn output_unlocked(
/// Returns if a locked output, which uses a block height, can be spent. /// Returns if a locked output, which uses a block height, can be spent.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#block-height /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#block-height>
fn check_block_time_lock(unlock_height: u64, current_chain_height: u64) -> bool { fn check_block_time_lock(unlock_height: u64, current_chain_height: u64) -> bool {
// current_chain_height = 1 + top height // current_chain_height = 1 + top height
unlock_height <= current_chain_height unlock_height <= current_chain_height
@ -274,7 +274,7 @@ fn check_block_time_lock(unlock_height: u64, current_chain_height: u64) -> bool
/// Returns if a locked output, which uses a block height, can be spend. /// Returns if a locked output, which uses a block height, can be spend.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#timestamp /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#timestamp>
fn check_timestamp_time_lock( fn check_timestamp_time_lock(
unlock_timestamp: u64, unlock_timestamp: u64,
current_time_lock_timestamp: u64, current_time_lock_timestamp: u64,
@ -285,10 +285,10 @@ fn check_timestamp_time_lock(
/// Checks all the time locks are unlocked. /// Checks all the time locks are unlocked.
/// ///
/// `current_time_lock_timestamp` must be: https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#getting-the-current-time /// `current_time_lock_timestamp` must be: <https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#getting-the-current-time>
/// ///
/// https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html /// <https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html>
/// https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#the-output-must-not-be-locked /// <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#the-output-must-not-be-locked>
fn check_all_time_locks( fn check_all_time_locks(
time_locks: &[Timelock], time_locks: &[Timelock],
current_chain_height: u64, current_chain_height: u64,
@ -313,8 +313,8 @@ fn check_all_time_locks(
/// Checks the decoys are allowed. /// Checks the decoys are allowed.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#minimum-decoys /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#minimum-decoys>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#equal-number-of-decoys /// && <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#equal-number-of-decoys>
fn check_decoy_info(decoy_info: &DecoyInfo, hf: &HardFork) -> Result<(), TransactionError> { fn check_decoy_info(decoy_info: &DecoyInfo, hf: &HardFork) -> Result<(), TransactionError> {
if hf == &HardFork::V15 { if hf == &HardFork::V15 {
// Hard-fork 15 allows both v14 and v16 rules // Hard-fork 15 allows both v14 and v16 rules
@ -351,8 +351,8 @@ fn check_decoy_info(decoy_info: &DecoyInfo, hf: &HardFork) -> Result<(), Transac
/// The `spent_kis` parameter is not meant to be a complete list of key images, just a list of related transactions /// The `spent_kis` parameter is not meant to be a complete list of key images, just a list of related transactions
/// key images, for example transactions in a block. The chain will be checked for duplicates later. /// key images, for example transactions in a block. The chain will be checked for duplicates later.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#unique-key-image /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#unique-key-image>
/// && https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#torsion-free-key-image /// && <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#torsion-free-key-image>
fn check_key_images( fn check_key_images(
input: &Input, input: &Input,
spent_kis: &mut HashSet<[u8; 32]>, spent_kis: &mut HashSet<[u8; 32]>,
@ -375,7 +375,7 @@ fn check_key_images(
/// Checks that the input is of type [`Input::ToKey`] aka txin_to_key. /// Checks that the input is of type [`Input::ToKey`] aka txin_to_key.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#input-type /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#input-type>
fn check_input_type(input: &Input) -> Result<(), TransactionError> { fn check_input_type(input: &Input) -> Result<(), TransactionError> {
match input { match input {
Input::ToKey { .. } => Ok(()), Input::ToKey { .. } => Ok(()),
@ -385,7 +385,7 @@ fn check_input_type(input: &Input) -> Result<(), TransactionError> {
/// Checks that the input has decoys. /// Checks that the input has decoys.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#no-empty-decoys /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#no-empty-decoys>
fn check_input_has_decoys(input: &Input) -> Result<(), TransactionError> { fn check_input_has_decoys(input: &Input) -> Result<(), TransactionError> {
match input { match input {
Input::ToKey { key_offsets, .. } => { Input::ToKey { key_offsets, .. } => {
@ -401,7 +401,7 @@ fn check_input_has_decoys(input: &Input) -> Result<(), TransactionError> {
/// Checks that the ring members for the input are unique after hard-fork 6. /// Checks that the ring members for the input are unique after hard-fork 6.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#unique-ring-members /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#unique-ring-members>
fn check_ring_members_unique(input: &Input, hf: &HardFork) -> Result<(), TransactionError> { fn check_ring_members_unique(input: &Input, hf: &HardFork) -> Result<(), TransactionError> {
if hf >= &HardFork::V6 { if hf >= &HardFork::V6 {
match input { match input {
@ -421,7 +421,7 @@ fn check_ring_members_unique(input: &Input, hf: &HardFork) -> Result<(), Transac
/// Checks that from hf 7 the inputs are sorted by key image. /// Checks that from hf 7 the inputs are sorted by key image.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#sorted-inputs /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#sorted-inputs>
fn check_inputs_sorted(inputs: &[Input], hf: &HardFork) -> Result<(), TransactionError> { fn check_inputs_sorted(inputs: &[Input], hf: &HardFork) -> Result<(), TransactionError> {
let get_ki = |inp: &Input| match inp { let get_ki = |inp: &Input| match inp {
Input::ToKey { key_image, .. } => Ok(key_image.compress().to_bytes()), Input::ToKey { key_image, .. } => Ok(key_image.compress().to_bytes()),
@ -443,7 +443,7 @@ fn check_inputs_sorted(inputs: &[Input], hf: &HardFork) -> Result<(), Transactio
/// Checks the youngest output is at least 10 blocks old. /// Checks the youngest output is at least 10 blocks old.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#10-block-lock /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#10-block-lock>
fn check_10_block_lock( fn check_10_block_lock(
youngest_used_out_height: u64, youngest_used_out_height: u64,
current_chain_height: u64, current_chain_height: u64,
@ -462,7 +462,7 @@ fn check_10_block_lock(
/// Sums the inputs checking for overflow. /// Sums the inputs checking for overflow.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#inputs-must-not-overflow /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#inputs-must-not-overflow>
fn sum_inputs_check_overflow(inputs: &[Input]) -> Result<u64, TransactionError> { fn sum_inputs_check_overflow(inputs: &[Input]) -> Result<u64, TransactionError> {
let mut sum: u64 = 0; let mut sum: u64 = 0;
for inp in inputs { for inp in inputs {
@ -485,7 +485,7 @@ fn sum_inputs_check_overflow(inputs: &[Input]) -> Result<u64, TransactionError>
/// - The tx-pool will use the current hard-fork /// - The tx-pool will use the current hard-fork
/// - When syncing the hard-fork is in the block header. /// - When syncing the hard-fork is in the block header.
fn check_inputs_semantics(inputs: &[Input], hf: &HardFork) -> Result<u64, TransactionError> { fn check_inputs_semantics(inputs: &[Input], hf: &HardFork) -> Result<u64, TransactionError> {
// https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#no-empty-inputs // <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#no-empty-inputs>
if inputs.is_empty() { if inputs.is_empty() {
return Err(TransactionError::NoInputs); return Err(TransactionError::NoInputs);
} }
@ -542,7 +542,7 @@ fn check_inputs_contextual(
/// Checks the version is in the allowed range. /// Checks the version is in the allowed range.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/transactions.html#version /// <https://monero-book.cuprate.org/consensus_rules/transactions.html#version>
fn check_tx_version( fn check_tx_version(
decoy_info: &Option<DecoyInfo>, decoy_info: &Option<DecoyInfo>,
version: &TxVersion, version: &TxVersion,
@ -606,7 +606,7 @@ pub fn check_transaction_semantic(
hf: &HardFork, hf: &HardFork,
verifier: &mut BatchVerifier<(), dalek_ff_group::EdwardsPoint>, verifier: &mut BatchVerifier<(), dalek_ff_group::EdwardsPoint>,
) -> Result<u64, TransactionError> { ) -> Result<u64, TransactionError> {
// https://monero-book.cuprate.org/consensus_rules/transactions.html#transaction-size // <https://monero-book.cuprate.org/consensus_rules/transactions.html#transaction-size>
if tx_blob_size > MAX_TX_BLOB_SIZE if tx_blob_size > MAX_TX_BLOB_SIZE
|| (hf >= &HardFork::V8 && tx_weight > transaction_weight_limit(hf)) || (hf >= &HardFork::V8 && tx_weight > transaction_weight_limit(hf))
{ {
@ -645,7 +645,7 @@ pub fn check_transaction_semantic(
/// ///
/// To fully verify a transaction this must be accompanied with [`check_transaction_semantic`] /// To fully verify a transaction this must be accompanied with [`check_transaction_semantic`]
/// ///
/// `current_time_lock_timestamp` must be: https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#getting-the-current-time /// `current_time_lock_timestamp` must be: <https://monero-book.cuprate.org/consensus_rules/transactions/unlock_time.html#getting-the-current-time>
pub fn check_transaction_contextual( pub fn check_transaction_contextual(
tx: &Transaction, tx: &Transaction,

12
consensus/rules/src/transactions/contextual_data.rs
View file

@ -20,7 +20,7 @@ pub struct OutputOnChain {
/// Gets the absolute offsets from the relative offsets. /// Gets the absolute offsets from the relative offsets.
/// ///
/// This function will return an error if the relative offsets are empty. /// This function will return an error if the relative offsets are empty.
/// https://cuprate.github.io/monero-book/consensus_rules/transactions.html#inputs-must-have-decoys /// <https://cuprate.github.io/monero-book/consensus_rules/transactions.html#inputs-must-have-decoys>
fn get_absolute_offsets(relative_offsets: &[u64]) -> Result<Vec<u64>, TransactionError> { fn get_absolute_offsets(relative_offsets: &[u64]) -> Result<Vec<u64>, TransactionError> {
if relative_offsets.is_empty() { if relative_offsets.is_empty() {
return Err(TransactionError::InputDoesNotHaveExpectedNumbDecoys); return Err(TransactionError::InputDoesNotHaveExpectedNumbDecoys);
@ -38,7 +38,7 @@ fn get_absolute_offsets(relative_offsets: &[u64]) -> Result<Vec<u64>, Transactio
/// Inserts the output IDs that are needed to verify the transaction inputs into the provided HashMap. /// Inserts the output IDs that are needed to verify the transaction inputs into the provided HashMap.
/// ///
/// This will error if the inputs are empty /// This will error if the inputs are empty
/// https://cuprate.github.io/monero-book/consensus_rules/transactions.html#no-empty-inputs /// <https://cuprate.github.io/monero-book/consensus_rules/transactions.html#no-empty-inputs>
/// ///
pub fn insert_ring_member_ids( pub fn insert_ring_member_ids(
inputs: &[Input], inputs: &[Input],
@ -191,7 +191,7 @@ impl TxRingMembersInfo {
/// - The input amounts are *ALL* 0 (RCT) /// - The input amounts are *ALL* 0 (RCT)
/// - The top block hash is the same as when this data was retrieved (the blockchain state is unchanged). /// - The top block hash is the same as when this data was retrieved (the blockchain state is unchanged).
/// ///
/// https://cuprate.github.io/monero-book/consensus_rules/transactions/decoys.html /// <https://cuprate.github.io/monero-book/consensus_rules/transactions/decoys.html>
#[derive(Debug)] #[derive(Debug)]
pub struct DecoyInfo { pub struct DecoyInfo {
/// The number of inputs that have enough outputs on the chain to mix with. /// The number of inputs that have enough outputs on the chain to mix with.
@ -241,7 +241,7 @@ impl DecoyInfo {
.get(amount) .get(amount)
.expect("outputs_with_amount does not include needed amount."); .expect("outputs_with_amount does not include needed amount.");
// https://cuprate.github.io/monero-book/consensus_rules/transactions/decoys.html#mixable-and-unmixable-inputs // <https://cuprate.github.io/monero-book/consensus_rules/transactions/decoys.html#mixable-and-unmixable-inputs>
if outs_with_amt <= minimum_decoys { if outs_with_amt <= minimum_decoys {
not_mixable += 1; not_mixable += 1;
} else { } else {
@ -257,7 +257,7 @@ impl DecoyInfo {
.checked_sub(1) .checked_sub(1)
.ok_or(TransactionError::InputDoesNotHaveExpectedNumbDecoys)?; .ok_or(TransactionError::InputDoesNotHaveExpectedNumbDecoys)?;
// https://cuprate.github.io/monero-book/consensus_rules/transactions/decoys.html#minimum-and-maximum-decoys-used // <https://cuprate.github.io/monero-book/consensus_rules/transactions/decoys.html#minimum-and-maximum-decoys-used>
min_decoys = min(min_decoys, numb_decoys); min_decoys = min(min_decoys, numb_decoys);
max_decoys = max(max_decoys, numb_decoys); max_decoys = max(max_decoys, numb_decoys);
} }
@ -277,7 +277,7 @@ impl DecoyInfo {
/// Returns the default minimum amount of decoys for a hard-fork. /// Returns the default minimum amount of decoys for a hard-fork.
/// **There are exceptions to this always being the minimum decoys** /// **There are exceptions to this always being the minimum decoys**
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#default-minimum-decoys /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/inputs.html#default-minimum-decoys>
pub(crate) fn minimum_decoys(hf: &HardFork) -> usize { pub(crate) fn minimum_decoys(hf: &HardFork) -> usize {
use HardFork as HF; use HardFork as HF;
match hf { match hf {

14
consensus/rules/src/transactions/ring_ct.rs
View file

@ -43,7 +43,7 @@ pub enum RingCTError {
/// Checks the RingCT type is allowed for the current hard fork. /// Checks the RingCT type is allowed for the current hard fork.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/ring_ct.html#type /// <https://monero-book.cuprate.org/consensus_rules/ring_ct.html#type>
fn check_rct_type(ty: &RctType, hf: HardFork, tx_hash: &[u8; 32]) -> Result<(), RingCTError> { fn check_rct_type(ty: &RctType, hf: HardFork, tx_hash: &[u8; 32]) -> Result<(), RingCTError> {
use HardFork as F; use HardFork as F;
use RctType as T; use RctType as T;
@ -61,7 +61,7 @@ fn check_rct_type(ty: &RctType, hf: HardFork, tx_hash: &[u8; 32]) -> Result<(),
/// Checks that the pseudo-outs sum to the same point as the output commitments. /// Checks that the pseudo-outs sum to the same point as the output commitments.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/ring_ct.html#pseudo-outs-outpks-balance /// <https://monero-book.cuprate.org/consensus_rules/ring_ct.html#pseudo-outs-outpks-balance>
fn simple_type_balances(rct_sig: &RctSignatures) -> Result<(), RingCTError> { fn simple_type_balances(rct_sig: &RctSignatures) -> Result<(), RingCTError> {
let pseudo_outs = if rct_sig.rct_type() == RctType::MlsagIndividual { let pseudo_outs = if rct_sig.rct_type() == RctType::MlsagIndividual {
&rct_sig.base.pseudo_outs &rct_sig.base.pseudo_outs
@ -86,9 +86,9 @@ fn simple_type_balances(rct_sig: &RctSignatures) -> Result<(), RingCTError> {
/// Checks the outputs range proof(s) /// Checks the outputs range proof(s)
/// ///
/// https://monero-book.cuprate.org/consensus_rules/ring_ct/borromean.html /// <https://monero-book.cuprate.org/consensus_rules/ring_ct/borromean.html>
/// https://monero-book.cuprate.org/consensus_rules/ring_ct/bulletproofs.html /// <https://monero-book.cuprate.org/consensus_rules/ring_ct/bulletproofs.html>
/// https://monero-book.cuprate.org/consensus_rules/ring_ct/bulletproofs+.html /// <https://monero-book.cuprate.org/consensus_rules/ring_ct/bulletproofs+.html>
fn check_output_range_proofs( fn check_output_range_proofs(
rct_sig: &RctSignatures, rct_sig: &RctSignatures,
verifier: &mut BatchVerifier<(), dalek_ff_group::EdwardsPoint>, verifier: &mut BatchVerifier<(), dalek_ff_group::EdwardsPoint>,
@ -138,8 +138,8 @@ pub(crate) fn ring_ct_semantic_checks(
/// Check the input signatures: MLSAG, CLSAG. /// Check the input signatures: MLSAG, CLSAG.
/// ///
/// https://monero-book.cuprate.org/consensus_rules/ring_ct/mlsag.html /// <https://monero-book.cuprate.org/consensus_rules/ring_ct/mlsag.html>
/// https://monero-book.cuprate.org/consensus_rules/ring_ct/clsag.html /// <https://monero-book.cuprate.org/consensus_rules/ring_ct/clsag.html>
pub(crate) fn check_input_signatures( pub(crate) fn check_input_signatures(
msg: &[u8; 32], msg: &[u8; 32],
inputs: &[Input], inputs: &[Input],

8
consensus/rules/src/transactions/ring_signatures.rs
View file

@ -1,9 +1,9 @@
//! Version 1 ring signature verification. //! Version 1 ring signature verification.
//! //!
//! Some checks have to be done at deserialization or with data we don't have so we can't do them here, those checks are: //! Some checks have to be done at deserialization or with data we don't have so we can't do them here, those checks are:
//! https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#signatures-must-be-canonical //! <https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#signatures-must-be-canonical>
//! this happens at deserialization in monero-serai. //! this happens at deserialization in monero-serai.
//! https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#amount-of-signatures-in-a-ring //! <https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#amount-of-signatures-in-a-ring>
//! and this happens during ring signature verification in monero-serai. //! and this happens during ring signature verification in monero-serai.
//! //!
use monero_serai::{ring_signatures::RingSignature, transaction::Input}; use monero_serai::{ring_signatures::RingSignature, transaction::Input};
@ -16,7 +16,7 @@ use crate::try_par_iter;
/// Verifies the ring signature. /// Verifies the ring signature.
/// ///
/// ref: https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html /// ref: <https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html>
pub fn check_input_signatures( pub fn check_input_signatures(
inputs: &[Input], inputs: &[Input],
signatures: &[RingSignature], signatures: &[RingSignature],
@ -25,7 +25,7 @@ pub fn check_input_signatures(
) -> Result<(), TransactionError> { ) -> Result<(), TransactionError> {
match rings { match rings {
Rings::Legacy(rings) => { Rings::Legacy(rings) => {
// https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#amount-of-ring-signatures // <https://monero-book.cuprate.org/consensus_rules/transactions/ring_signatures.html#amount-of-ring-signatures>
// rings.len() != inputs.len() can't happen but check any way. // rings.len() != inputs.len() can't happen but check any way.
if signatures.len() != inputs.len() || rings.len() != inputs.len() { if signatures.len() != inputs.len() || rings.len() != inputs.len() {
return Err(TransactionError::RingSignatureIncorrect); return Err(TransactionError::RingSignatureIncorrect);

2
consensus/src/context.rs
View file

@ -183,7 +183,7 @@ impl std::ops::Deref for RawBlockChainContext {
impl RawBlockChainContext { impl RawBlockChainContext {
/// Returns the timestamp the should be used when checking locked outputs. /// Returns the timestamp the should be used when checking locked outputs.
/// ///
/// https://cuprate.github.io/monero-book/consensus_rules/transactions/unlock_time.html#getting-the-current-time /// <https://cuprate.github.io/monero-book/consensus_rules/transactions/unlock_time.html#getting-the-current-time>
pub fn current_adjusted_timestamp_for_time_lock(&self) -> u64 { pub fn current_adjusted_timestamp_for_time_lock(&self) -> u64 {
if self.current_hf < HardFork::V13 || self.median_block_timestamp.is_none() { if self.current_hf < HardFork::V13 || self.median_block_timestamp.is_none() {
current_unix_timestamp() current_unix_timestamp()

40
helper/src/atomic.rs
View file

@ -18,8 +18,8 @@ use core::sync::atomic::{AtomicU32, AtomicU64, Ordering};
// Using `UnsafeCell<float>` is also viable, // Using `UnsafeCell<float>` is also viable,
// and would allow for a `const fn new(f: float) -> Self` // and would allow for a `const fn new(f: float) -> Self`
// except that becomes problematic with NaN's and infinites: // except that becomes problematic with NaN's and infinites:
// - https://github.com/rust-lang/rust/issues/73328 // - <https://github.com/rust-lang/rust/issues/73328>
// - https://github.com/rust-lang/rfcs/pull/3514 // - <https://github.com/rust-lang/rfcs/pull/3514>
// //
// This is most likely safe(?) but... instead of risking UB, // This is most likely safe(?) but... instead of risking UB,
// this just uses the Atomic unsigned integer as the inner // this just uses the Atomic unsigned integer as the inner
@ -30,7 +30,7 @@ use core::sync::atomic::{AtomicU32, AtomicU64, Ordering};
// - `AtomicF64` // - `AtomicF64`
// //
// Originally taken from: // Originally taken from:
// https://github.com/hinto-janai/sansan/blob/1f6680b2d08ff5fbf4f090178ea5233d4cf9056f/src/atomic.rs // <https://github.com/hinto-janai/sansan/blob/1f6680b2d08ff5fbf4f090178ea5233d4cf9056f/src/atomic.rs>
macro_rules! impl_atomic_f { macro_rules! impl_atomic_f {
( (
$atomic_float:ident, // Name of the new float type $atomic_float:ident, // Name of the new float type
@ -47,7 +47,7 @@ macro_rules! impl_atomic_f {
/// An atomic float. /// An atomic float.
/// ///
/// ## Portability /// ## Portability
/// [Quoting the std library: ](https://doc.rust-lang.org/1.70.0/std/primitive.f32.html#method.to_bits) /// [Quoting the std library: ](<https://doc.rust-lang.org/1.70.0/std/primitive.f32.html#method.to_bits)>
/// "See from_bits for some discussion of the portability of this operation (there are almost no issues)." /// "See from_bits for some discussion of the portability of this operation (there are almost no issues)."
/// ///
/// ## Compile-time failure /// ## Compile-time failure
@ -75,7 +75,7 @@ macro_rules! impl_atomic_f {
// FIXME: // FIXME:
// Seems like `std` internals has some unstable cfg options that // Seems like `std` internals has some unstable cfg options that
// allow interior mutable consts to be defined without clippy complaining: // allow interior mutable consts to be defined without clippy complaining:
// https://doc.rust-lang.org/1.70.0/src/core/sync/atomic.rs.html#3013. // <https://doc.rust-lang.org/1.70.0/src/core/sync/atomic.rs.html#3013>.
// //
/// `0.0`, returned by [`Self::default`]. /// `0.0`, returned by [`Self::default`].
pub const DEFAULT: Self = Self($atomic_unsigned::new($bits_0)); pub const DEFAULT: Self = Self($atomic_unsigned::new($bits_0));
@ -83,10 +83,10 @@ macro_rules! impl_atomic_f {
#[inline] #[inline]
/// Create a new atomic float. /// Create a new atomic float.
/// ///
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.new /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.new>
pub fn new(f: $float) -> Self { pub fn new(f: $float) -> Self {
// FIXME: Update to const when available. // FIXME: Update to const when available.
// https://doc.rust-lang.org/1.70.0/src/core/num/f32.rs.html#998 // <https://doc.rust-lang.org/1.70.0/src/core/num/f32.rs.html#998>
// //
// `transmute()` here would be safe (`to_bits()` is doing this) // `transmute()` here would be safe (`to_bits()` is doing this)
// although checking for NaN's and infinites are non-`const`... // although checking for NaN's and infinites are non-`const`...
@ -96,7 +96,7 @@ macro_rules! impl_atomic_f {
} }
#[inline] #[inline]
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.into_inner /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.into_inner>
pub fn into_inner(self) -> $float { pub fn into_inner(self) -> $float {
$float::from_bits(self.0.into_inner()) $float::from_bits(self.0.into_inner())
} }
@ -110,7 +110,7 @@ macro_rules! impl_atomic_f {
#[inline] #[inline]
/// Store a float inside the atomic. /// Store a float inside the atomic.
/// ///
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.store /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.store>
pub fn store(&self, f: $float, ordering: Ordering) { pub fn store(&self, f: $float, ordering: Ordering) {
self.0.store(f.to_bits(), ordering); self.0.store(f.to_bits(), ordering);
} }
@ -124,10 +124,10 @@ macro_rules! impl_atomic_f {
#[inline] #[inline]
/// Load the internal float from the atomic. /// Load the internal float from the atomic.
/// ///
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.load /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.load>
pub fn load(&self, ordering: Ordering) -> $float { pub fn load(&self, ordering: Ordering) -> $float {
// FIXME: Update to const when available. // FIXME: Update to const when available.
// https://doc.rust-lang.org/1.70.0/src/core/num/f32.rs.html#1088 // <https://doc.rust-lang.org/1.70.0/src/core/num/f32.rs.html#1088>
$float::from_bits(self.0.load(ordering)) $float::from_bits(self.0.load(ordering))
} }
@ -138,13 +138,13 @@ macro_rules! impl_atomic_f {
} }
#[inline] #[inline]
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.swap /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.swap>
pub fn swap(&self, val: $float, ordering: Ordering) -> $float { pub fn swap(&self, val: $float, ordering: Ordering) -> $float {
$float::from_bits(self.0.swap($float::to_bits(val), ordering)) $float::from_bits(self.0.swap($float::to_bits(val), ordering))
} }
#[inline] #[inline]
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.compare_exchange /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.compare_exchange>
pub fn compare_exchange( pub fn compare_exchange(
&self, &self,
current: $float, current: $float,
@ -162,7 +162,7 @@ macro_rules! impl_atomic_f {
} }
#[inline] #[inline]
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.compare_exchange_weak /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.compare_exchange_weak>
pub fn compare_exchange_weak( pub fn compare_exchange_weak(
&self, &self,
current: $float, current: $float,
@ -211,14 +211,14 @@ macro_rules! impl_atomic_f {
// if the closure we pass it returns `None`. // if the closure we pass it returns `None`.
// As seen below, we're passing a `Some`. // As seen below, we're passing a `Some`.
// //
// https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update // <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update>
self.fetch_update(ordering, second_order, |f| Some(update(f))) self.fetch_update(ordering, second_order, |f| Some(update(f)))
.unwrap() .unwrap()
} }
#[inline] #[inline]
/// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to /// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to
/// https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_add. /// <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_add>.
/// ///
/// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem). /// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem).
/// ///
@ -229,7 +229,7 @@ macro_rules! impl_atomic_f {
#[inline] #[inline]
/// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to /// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to
/// https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_sub. /// <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_sub>.
/// ///
/// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem). /// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem).
/// ///
@ -240,7 +240,7 @@ macro_rules! impl_atomic_f {
#[inline] #[inline]
/// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to /// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to
/// https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_max. /// <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_max>.
/// ///
/// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem). /// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem).
/// ///
@ -251,7 +251,7 @@ macro_rules! impl_atomic_f {
#[inline] #[inline]
/// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to /// This function is implemented with [`Self::fetch_update`], and is not 100% equivalent to
/// https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_min. /// <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_min>.
/// ///
/// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem). /// In particular, this method will not circumvent the [ABA Problem](https://en.wikipedia.org/wiki/ABA_problem).
/// ///
@ -261,7 +261,7 @@ macro_rules! impl_atomic_f {
} }
#[inline] #[inline]
/// Equivalent to https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update /// Equivalent to <https://doc.rust-lang.org/1.70.0/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update>
pub fn fetch_update<F>( pub fn fetch_update<F>(
&self, &self,
set_order: Ordering, set_order: Ordering,

2
helper/src/thread.rs
View file

@ -62,7 +62,7 @@ impl_thread_percent! {
/// ///
/// Sets the calling thread’s priority to the lowest platform-specific value possible. /// Sets the calling thread’s priority to the lowest platform-specific value possible.
/// ///
/// https://docs.rs/lpt /// Originally from <https://docs.rs/lpt>.
/// ///
/// # Windows /// # Windows
/// Uses SetThreadPriority() with THREAD_PRIORITY_IDLE (-15). /// Uses SetThreadPriority() with THREAD_PRIORITY_IDLE (-15).