Any one figure out the actual formula to bring one of these into a modern pool with diff and hashrate accuracy?

[Sledge0001]

I see the first job seems to align with pool_diff * (pool_target_32 / first_32) / 5 however job 2 just scales on some random unknown scale.

Any insight as to what that scale might be so a pool can be developed that matches up with the miners UI data with respects to diff reported and hashrate?

[skot]

The bitaxe will "suggest" a difficulty to the pool, but the actual pool difficulty used and any changes are entirely up to the pool.

When you say "match the UI" do you mean the hashrate plot? For this you would need the pool difficulty to match the bitaxe chip difficulty (256, iirc) and use the same averaging window.

[Sledge0001]

There is a diff calculation and hashrate calculation that must occur when the miner gets a job. The miner runs the calc and then sends back the job to the pool. I can confirm that the 1st job sent back to the pool always seems to use pool_diff * (pool_target_32 / first_32) / 5 but then the 2nd , 3rd , 4rth job and so on there is no consistency or pattern to the calc that the miner seems to run. It appears to be on a scale of some sort or uses some other equation or is creating an alternate hash on its own..

For some reason I am not getting these to report accurately and was hoping someone could shed light on the possible calcs needed.

I've tried different versions of this but still came up empty:

`
def calculate_bitaxe_difficulty(block_hash_hex):
"""Calculate share difficulty for BitAxe display"""

# Method 1: Using pdiff with full hash
hash_bytes = bytes.fromhex(block_hash_hex)
hash_int = int.from_bytes(hash_bytes[::-1], 'big')  # little-endian

if hash_int == 0:
    return 0.0

# Pool difficulty target (all F's after 32 bits of zeros)
max_target = 0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

# Calculate difficulty
pdiff = max_target / hash_int

return pdiff

OR

def calculate_bitaxe_difficulty_method2(block_hash_hex):
"""Alternative calculation using bdiff with multiplier"""

hash_bytes = bytes.fromhex(block_hash_hex)
hash_int = int.from_bytes(hash_bytes[::-1], 'big')

if hash_int == 0:
    return 0.0

# Bitcoin's max target
max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

# Calculate bdiff and multiply by common factor
bdiff = max_target / hash_int
share_diff = bdiff * 65536  # or another multiplier

return share_diff
`

[Sledge0001]

I have the pool code honoring the Bitaxe stratum handshake and the miner is getting work at its suggested1000 as requested. I should mention I do have the bitaxe working and sending back jobs its just returning diff numbers that don't appear to be 100% what the returned job should be showing (which of course throws hashrate off) So need to get the two to match up between the UI and what I am seeing on the pool side of things. My focus is specifically with miner returned work diff. Once I nail that down hashrate will fall inline.

[skot]

When esp-miner gets a nonce returned from the ASIC, the difficulty of the hash produced with that nonce is computed with test_nonce_value()

ESP-Miner/components/stratum/mining.c

Lines 126 to 163 in d0fc23d

	///////cgminer nonce testing
	/* truediffone == 0x00000000FFFF0000000000000000000000000000000000000000000000000000
	*/
	static const double truediffone = 26959535291011309493156476344723991336010898738574164086137773096960.0;
	/* testing a nonce and return the diff - 0 means invalid */
	double test_nonce_value(const bm_job *job, const uint32_t nonce, const uint32_t rolled_version)
	{
	double d64, s64, ds;
	unsigned char header[80];
	// // TODO: use the midstate hash instead of hashing the whole header
	// uint32_t rolled_version = job->version;
	// for (int i = 0; i < midstate_index; i++) {
	// rolled_version = increment_bitmask(rolled_version, job->version_mask);
	// }
	// copy data from job to header
	memcpy(header, &rolled_version, 4);
	memcpy(header + 4, job->prev_block_hash, 32);
	memcpy(header + 36, job->merkle_root, 32);
	memcpy(header + 68, &job->ntime, 4);
	memcpy(header + 72, &job->target, 4);
	memcpy(header + 76, &nonce, 4);
	unsigned char hash_buffer[32];
	unsigned char hash_result[32];
	// double hash the header
	mbedtls_sha256(header, 80, hash_buffer, 0);
	mbedtls_sha256(hash_buffer, 32, hash_result, 0);
	d64 = truediffone;
	s64 = le256todouble(hash_result);
	ds = d64 / s64;
	return ds;
	}

The hashrate (and a few other things) are computed in SYSTEM_notify_found_nonce()

ESP-Miner/main/system.c

Lines 187 to 228 in d0fc23d

	void SYSTEM_notify_found_nonce(GlobalState * GLOBAL_STATE, double found_diff, uint8_t job_id)
	{
	SystemModule * module = &GLOBAL_STATE->SYSTEM_MODULE;
	// Calculate the time difference in seconds with sub-second precision
	// hashrate = (nonce_difficulty * 2^32) / time_to_find
	module->historical_hashrate[module->historical_hashrate_rolling_index] = GLOBAL_STATE->DEVICE_CONFIG.family.asic.difficulty;
	module->historical_hashrate_time_stamps[module->historical_hashrate_rolling_index] = esp_timer_get_time();
	module->historical_hashrate_rolling_index = (module->historical_hashrate_rolling_index + 1) % HISTORY_LENGTH;
	// ESP_LOGI(TAG, "nonce_diff %.1f, ttf %.1f, res %.1f", nonce_diff, duration,
	// historical_hashrate[historical_hashrate_rolling_index]);
	if (module->historical_hashrate_init < HISTORY_LENGTH) {
	module->historical_hashrate_init++;
	} else {
	module->duration_start =
	module->historical_hashrate_time_stamps[(module->historical_hashrate_rolling_index + 1) % HISTORY_LENGTH];
	}
	double sum = 0;
	for (int i = 0; i < module->historical_hashrate_init; i++) {
	sum += module->historical_hashrate[i];
	}
	double duration = (double) (esp_timer_get_time() - module->duration_start) / 1000000;
	double rolling_rate = (sum * 4294967296) / (duration * 1000000000);
	if (module->historical_hashrate_init < HISTORY_LENGTH) {
	module->current_hashrate = rolling_rate;
	} else {
	// More smoothing
	module->current_hashrate = ((module->current_hashrate * 9) + rolling_rate) / 10;
	}
	// logArrayContents(historical_hashrate, HISTORY_LENGTH);
	// logArrayContents(historical_hashrate_time_stamps, HISTORY_LENGTH);
	_check_for_best_diff(GLOBAL_STATE, found_diff, job_id);
	}

note the hashrate is computed using the ASIC diff, not pool diff.

[Sledge0001]

I think this is actually what I needed to get the correct calcs to work:

ESP-Miner/components/stratum/utils.c

Line 266 in d0fc23d

double le256todouble(const void *target)

`double le256todouble(const void *target)
{
uint64_t *data64;
double dcut64;

data64 = (uint64_t *)(target + 24);
dcut64 = *data64 * bits192;

data64 = (uint64_t *)(target + 16);
dcut64 += *data64 * bits128;

data64 = (uint64_t *)(target + 8);
dcut64 += *data64 * bits64;

data64 = (uint64_t *)(target);
dcut64 += *data64;

return dcut64;

}
`

Now to test further! :)