Convert pool difficulty to exact share targets
next-build / build (push) Successful in 11s

This commit is contained in:
2026-10-15 01:00:53 -06:00
parent e7a23faa5a
commit 5cd77eb5de
7 changed files with 218 additions and 8 deletions
+1 -1
View File
@@ -9,7 +9,7 @@ description = "Portable mining and tuning core for Alkane control boards"
name = "alkane_os"
[dependencies]
serde_json = "=1.0.154"
serde_json = { version = "=1.0.154", features = ["arbitrary_precision"] }
[profile.release]
lto = true
+120
View File
@@ -0,0 +1,120 @@
// SPDX-License-Identifier: MIT
//! Exact Bitcoin Stratum share target conversion; no floating point or nonce search.
use serde_json::Number;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DifficultyError {
Invalid,
OutOfRange,
}
/// A positive decimal difficulty represented exactly as numerator/denominator.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PoolDifficulty {
numerator: u64,
denominator: u64,
}
impl PoolDifficulty {
pub fn from_json_number(number: &Number) -> Result<Self, DifficultyError> {
let text = number.as_str();
if text.len() > 128 || text.starts_with('-') {
return Err(DifficultyError::OutOfRange);
}
let (mantissa, exponent) = match text.split_once(['e', 'E']) {
Some((base, exponent)) => (
base,
exponent
.parse::<i32>()
.map_err(|_| DifficultyError::OutOfRange)?,
),
None => (text, 0),
};
let mut digits = Vec::with_capacity(mantissa.len());
let mut fractional = 0_i32;
let mut after_dot = false;
for byte in mantissa.bytes() {
match byte {
b'.' if !after_dot => after_dot = true,
b'0'..=b'9' => {
digits.push(byte - b'0');
if after_dot {
fractional += 1;
}
}
_ => return Err(DifficultyError::Invalid),
}
}
let first = digits
.iter()
.position(|digit| *digit != 0)
.ok_or(DifficultyError::Invalid)?;
let last = digits
.iter()
.rposition(|digit| *digit != 0)
.expect("nonzero digit");
let trailing = (digits.len() - last - 1) as i32;
let mut numerator = 0_u64;
for digit in &digits[first..=last] {
numerator = numerator
.checked_mul(10)
.and_then(|value| value.checked_add(u64::from(*digit)))
.ok_or(DifficultyError::OutOfRange)?;
}
let shift = exponent
.checked_sub(fractional)
.and_then(|value| value.checked_add(trailing))
.ok_or(DifficultyError::OutOfRange)?;
if !(-19..=19).contains(&shift) {
return Err(DifficultyError::OutOfRange);
}
let mut denominator = 1_u64;
if shift >= 0 {
for _ in 0..shift {
numerator = numerator
.checked_mul(10)
.ok_or(DifficultyError::OutOfRange)?;
}
} else {
for _ in 0..-shift {
denominator = denominator
.checked_mul(10)
.ok_or(DifficultyError::OutOfRange)?;
}
}
Ok(Self {
numerator,
denominator,
})
}
/// floor((0xFFFF << 208) / difficulty), capped at the 256-bit maximum.
/// The 320-bit intermediate permits all supported decimal denominators.
pub fn target_le(self) -> [u8; 32] {
let mut product = [0_u8; 40];
let mut carry = 0_u128;
for (index, byte) in product.iter_mut().enumerate() {
let diff_one_byte = if index == 26 || index == 27 { 0xff } else { 0 };
let value = (diff_one_byte as u128) * u128::from(self.denominator) + carry;
*byte = value as u8;
carry = value >> 8;
}
debug_assert_eq!(carry, 0);
let mut quotient = [0_u8; 40];
let mut remainder = 0_u128;
for index in (0..320).rev() {
let bit = (product[index / 8] >> (index % 8)) & 1;
remainder = (remainder << 1) | u128::from(bit);
if remainder >= u128::from(self.numerator) {
remainder -= u128::from(self.numerator);
quotient[index / 8] |= 1 << (index % 8);
}
}
if quotient[32..].iter().any(|byte| *byte != 0) {
return [0xff; 32];
}
quotient[..32].try_into().expect("256-bit quotient")
}
}
+1
View File
@@ -4,6 +4,7 @@
//! the pairing already mines. Hardware backends are supplied by SDK images.
pub mod bm1366;
pub mod difficulty;
pub mod hal_wire;
pub mod miner;
pub mod pow;
+8 -6
View File
@@ -2,6 +2,7 @@
//! Bounded decoding of Bitcoin Stratum V1 subscription and job messages.
//! The network client must enforce a line limit before passing data here.
use crate::difficulty::PoolDifficulty;
use crate::pow::VersionMask;
use crate::stratum_work::{JobError, Sha256Job};
use serde_json::Value;
@@ -25,9 +26,9 @@ pub struct Subscription {
pub extranonce2_size: usize,
}
#[derive(Debug, PartialEq)]
#[derive(Debug, Eq, PartialEq)]
pub enum PoolNotification {
SetDifficulty(f64),
SetDifficulty(PoolDifficulty),
SetExtranonce(Subscription),
SetVersionMask(VersionMask),
}
@@ -169,10 +170,11 @@ pub fn parse_control_notification(
.ok_or(PoolMessageError::InvalidField)?;
match method {
"mining.set_difficulty" if params.len() == 1 => {
let difficulty = params[0].as_f64().ok_or(PoolMessageError::InvalidField)?;
if !difficulty.is_finite() || difficulty <= 0.0 {
return Err(PoolMessageError::InvalidField);
}
let number = params[0]
.as_number()
.ok_or(PoolMessageError::InvalidField)?;
let difficulty = PoolDifficulty::from_json_number(number)
.map_err(|_| PoolMessageError::InvalidField)?;
Ok(PoolNotification::SetDifficulty(difficulty))
}
"mining.set_version_mask" if params.len() == 1 => {
+11
View File
@@ -1,4 +1,5 @@
use alkane_os::bm1366::{decode_nonce_report, encode_work};
use alkane_os::difficulty::PoolDifficulty;
use alkane_os::miner::Bm1366Miner;
use alkane_os::pow::verify_sha256_report;
use alkane_os::pow::VersionMask;
@@ -145,6 +146,16 @@ fn bench_stratum_control_parse() {
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_difficulty_target() {
let number = serde_json::from_str("2048.5").unwrap();
let difficulty = PoolDifficulty::from_json_number(&number).unwrap();
measure("difficulty_target", 20_000, || {
black_box(black_box(difficulty).target_le());
});
}
struct BenchBackend;
impl HardwareBackend for BenchBackend {
+73
View File
@@ -0,0 +1,73 @@
// SPDX-License-Identifier: MIT
use alkane_os::difficulty::{DifficultyError, PoolDifficulty};
fn target(decimal: &str) -> String {
let number = serde_json::from_str(decimal).unwrap();
PoolDifficulty::from_json_number(&number)
.unwrap()
.target_le()
.iter()
.rev()
.map(|byte| format!("{byte:02x}"))
.collect()
}
#[test]
fn exact_share_targets_match_integer_reference() {
for (difficulty, expected) in [
(
"1",
"00000000ffff0000000000000000000000000000000000000000000000000000",
),
(
"2",
"000000007fff8000000000000000000000000000000000000000000000000000",
),
(
"0.5",
"00000001fffe0000000000000000000000000000000000000000000000000000",
),
(
"1.25",
"00000000cccc0000000000000000000000000000000000000000000000000000",
),
(
"2048.5",
"00000000001ffde021fde021fde021fde021fde021fde021fde021fde021fde0",
),
(
"0.000001",
"000f4230bdc00000000000000000000000000000000000000000000000000000",
),
(
"1000000000000000000",
"000000000000000000000012724b5f7471d95d3bbefee5e602a7b17261180d8e",
),
] {
assert_eq!(target(difficulty), expected, "difficulty {difficulty}");
}
assert_eq!(target("1.2e3"), target("1200"));
assert_eq!(target("1e-19"), "ff".repeat(32));
}
#[test]
fn invalid_or_unrepresentable_difficulty_is_rejected() {
let zero = serde_json::from_str("0").unwrap();
assert_eq!(
PoolDifficulty::from_json_number(&zero),
Err(DifficultyError::Invalid)
);
let negative = serde_json::from_str("-1").unwrap();
assert_eq!(
PoolDifficulty::from_json_number(&negative),
Err(DifficultyError::OutOfRange)
);
for value in ["1e20", "1e-20", "1.00000000000000000001"] {
let number = serde_json::from_str(value).unwrap();
assert_eq!(
PoolDifficulty::from_json_number(&number),
Err(DifficultyError::OutOfRange),
"difficulty {value}"
);
}
}
+4 -1
View File
@@ -1,4 +1,5 @@
// SPDX-License-Identifier: MIT
use alkane_os::difficulty::PoolDifficulty;
use alkane_os::stratum_v1::{
parse_configure_response, parse_control_notification, parse_notify, parse_subscription,
PoolMessageError, PoolNotification, Subscription,
@@ -109,7 +110,9 @@ fn difficulty_and_extranonce_notifications_validate_shape_and_negotiation() {
let difficulty = br#"{"id":null,"method":"mining.set_difficulty","params":[2048.5]}"#;
assert_eq!(
parse_control_notification(difficulty, false, false),
Ok(PoolNotification::SetDifficulty(2048.5))
Ok(PoolNotification::SetDifficulty(
PoolDifficulty::from_json_number(&serde_json::from_str("2048.5").unwrap()).unwrap()
))
);
let extranonce = br#"{"id":null,"method":"mining.set_extranonce","params":["aabbccdd",4]}"#;
assert_eq!(