modifications to: Support for splitting shares across multiple usernames OCEAN-xyz#99

Author: patrick-patel

README.md

@@ -106,6 +106,33 @@ Ensure you have "killall" installed on your system (*psmisc* package on Debian-l
 
 If the node and Gateway are on different systems, you may need to utilize the "NOTIFY" endpoint on the Gateway's dashboard/API instead.
 
+## Username Splitting
+
+DATUM Gateway supports splitting mining rewards between two Bitcoin addresses using a percentage-based username format. This allows miners to allocate shares between different addresses, such as sending a portion to a donation address or sharing with a partner.
+
+To use this feature:
+
+1. Format your mining username in one of these ways:
+   ```
+   address1%50address2%50
+   ```
+   or with worker names:
+   ```
+   address1.worker1%50address2.worker2%50
+   ```
+
+2. The percentages should add up to 100 (e.g., 50/50, 70/30, 90/10)
+
+3. The first two digits after the % sign determine the percentage of shares allocated to that address.
+
+Examples:
+- `3BDLR6hSE3efCztWeTqXcPJARuwmuaa9KP%503PxWT7GJ7WPNeGwMdSN4UoFfZgcuc5SLwP%50` - Allocates 50% of shares to each address
+- `3BDLR6hSE3efCztWeTqXcPJARuwmuaa9KP.rig1%703PxWT7GJ7WPNeGwMdSN4UoFfZgcuc5SLwP.donation%30` - Allocates 70% of shares to the first address (with worker name "rig1") and 30% to the second address (with worker name "donation")
+
+The worker names are preserved when submitting shares to the pool, allowing you to track hashrate by worker name in pool statistics.
+
+Note: The actual distribution of shares will approximate the specified percentages over time, but exact distribution depends on the randomness of share hashes.
+
 ## Template/Share Requirements for Pooled Mining
 
  - Must be a valid block and conform to current Bitcoin consensus rules
@@ -129,4 +156,4 @@ Be sure you have failover settings on your miners. As a best practice, when mini
 
 ## License
 
-The DATUM Gateway (including the DATUM Protocol) is free open source software and released under the terms of the MIT license.  See LICENSE.
+The DATUM Gateway (including the DATUM Protocol) is free open source software and released under the terms of the MIT license.  See LICENSE.

src/datum_protocol.c

@@ -1279,6 +1279,9 @@ int datum_protocol_pow_submit(
 
 	pow.datum_job_id = job->datum_job_idx;
 	memcpy(pow.extranonce, extranonce, 12);
+	
+	DLOG_DEBUG("POW submit with username: '%s'", username);
+	
 	strncpy(pow.username, username, 383);
 	pow.username[383] = 0;
 	pow.coinbase_id = coinbase_index;
@@ -1328,11 +1331,20 @@ int datum_protocol_pow(void *arg) {
 	if (((!datum_config.datum_pool_pass_full_users) && (!datum_config.datum_pool_pass_workers)) || pow->username[0] == '\0') {
 		i+=snprintf(username, 385, "%s", datum_config.mining_pool_address);
 	} else if (datum_config.datum_pool_pass_full_users && pow->username[0] != '.') {
-		// TODO: Make sure the usernames are addresses, and if not use one of the configured addresses
 		i+=snprintf(username, 385, "%s", pow->username);
 	} else if (datum_config.datum_pool_pass_full_users || datum_config.datum_pool_pass_workers) {
-		// append the miner's username to the configured address as .workername
-		i+=snprintf(username, 385, "%s%s%s", datum_config.mining_pool_address, (pow->username[0] == '.') ? "" : ".", pow->username);
+		const char* dot_pos = strchr(pow->username, '.'); // Check if the username contains a dot (indicating a worker name)
+		
+		if (pow->username[0] == '.') { // If username starts with dot, it's already in worker format
+			i+=snprintf(username, 385, "%s%s", datum_config.mining_pool_address, pow->username);
+			DLOG_DEBUG("POW: Appending worker name: '%s%s'", datum_config.mining_pool_address, pow->username);
+		} else if (dot_pos && datum_config.datum_pool_pass_workers && datum_config.datum_pool_pass_full_users) { // If both settings are true and we have a username with a dot, respect the worker name
+			i+=snprintf(username, 385, "%s", pow->username); // Handle usernames like "btcAddress.worker" by keeping them intact
+			DLOG_DEBUG("POW: Passing complete username with worker: '%s'", pow->username);
+		} else {
+			i+=snprintf(username, 385, "%s.%s", datum_config.mining_pool_address, pow->username); // Standard format with no dot, append as worker
+			DLOG_DEBUG("POW: Using worker name: '%s.%s'", datum_config.mining_pool_address, pow->username);
+		}
 	}
 	i++;  // already 0 from snprintf
 

src/datum_stratum.c

@@ -35,16 +35,20 @@
 
 // Stratum V1 server for providing work to mining hardware supporting Stratum V1
 
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
+#include <stdio.h>
 #include <unistd.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <inttypes.h>
+#include <time.h>
 #include <pthread.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <errno.h>
 #include <jansson.h>
-#include <inttypes.h>
+#include <errno.h>
+#include <ctype.h>
 #include <sys/resource.h>
 
 #include "datum_gateway.h"
@@ -954,30 +958,85 @@ bool stratum_get_job(const T_DATUM_MINER_DATA * const m, const json_t * const jo
 
 // Format: address%nn[.n][%address%nn[.n][...]]
 const char *datum_stratum_relevant_username(const char *username_s, char * const username_buf, const size_t username_buf_sz, const uint16_t share_rnd) {
-	uint16_t base = 0;
-	int n = 0;
+	// Check if the username contains a percent sign
+	const char *percent_pos = strchr(username_s, '%');
+	if (!percent_pos) {
+		return username_s;
+	}
+	
+	// Extract first username (before the %)
+	int first_len = percent_pos - username_s;
+	if (first_len <= 0 || first_len >= username_buf_sz) {
+		return username_s;
+	}
+	
+	// Copy the first username to our buffer
+	memcpy(username_buf, username_s, first_len);
+	username_buf[first_len] = '\0';
+	
+	// Parse the percentage - we'll only read 2 digits for percentage
+	const char *endptr = NULL;
+	char percent_str[3] = {0};
+	
+	// Read at most 2 digits for the percentage (for values like 50)
+	if (isdigit(percent_pos[1]) && isdigit(percent_pos[2])) {
+		percent_str[0] = percent_pos[1];
+		percent_str[1] = percent_pos[2];
+		endptr = percent_pos + 3;
+	} else if (isdigit(percent_pos[1])) {
+		percent_str[0] = percent_pos[1];
+		endptr = percent_pos + 2;
+	} else {
+		return username_s;
+	}
 
-	while (true) {
-		const char * const percent_pos = strchr(username_s, '%');
-		if (!percent_pos) return username_s;
-		
-		const char *endptr;
-		const int per = datum_strtoi_strict_2d2(&percent_pos[1], strlen(&percent_pos[1]), &endptr);
-		if (per < 0) return username_s;
-		if (*endptr != '\0' && *endptr != '%') return username_s;
-		
-		const uint32_t split_threshold = base + (uint32_t)per * 0x10000 / 10000;
-		if (share_rnd < split_threshold || split_threshold + n > 0xffff) {
-			snprintf(username_buf, username_buf_sz, "%.*s", (int)(percent_pos - username_s), username_s);
+	int percent = atoi(percent_str);
+	if (percent < 0 || percent > 100) {
+		return username_s;
+	}
+	
+	// Calculate threshold (correctly using /100, not /10000)
+	uint32_t threshold = (uint32_t)percent * 0x10000 / 100;
+	
+	// Check if we should use the first username
+	if (share_rnd < threshold) {
+		// Extract the first username's worker name (if any)
+		const char *first_dot = strchr(username_buf, '.');
+		if (!first_dot) {
+			// No worker in the first username, use as is
 			return username_buf;
 		}
-		
-		// move on to the next split
-		if (*endptr == '\0') return datum_config.mining_pool_address;
-		username_s = &endptr[1];
-		base = split_threshold;
-		++n;
+		return username_buf; // We already copied the first username with worker to username_buf
+	}
+	
+	// Otherwise, extract the second username which starts immediately after the percentage
+	// Skip any % separator if it exists
+	if (*endptr == '%') {
+		endptr++;
+	}
+	
+	// If we have nothing after the percentage
+	if (*endptr == '\0') {
+		return datum_config.mining_pool_address;
 	}
+	
+	// Move to the second username part
+	const char *second_username = endptr;
+	
+	// If there's another percent sign in the second username, truncate it
+	const char *next_percent = strchr(second_username, '%');
+	if (next_percent) {
+		size_t len = next_percent - second_username;
+		if (len >= username_buf_sz) len = username_buf_sz - 1;
+		memcpy(username_buf, second_username, len);
+		username_buf[len] = '\0';
+	} else {
+		// Otherwise copy the whole string
+		strncpy(username_buf, second_username, username_buf_sz - 1);
+		username_buf[username_buf_sz - 1] = '\0';
+	}
+	
+	return username_buf;
 }
 
 int client_mining_submit(T_DATUM_CLIENT_DATA *c, uint64_t id, json_t *params_obj) {
@@ -1176,9 +1235,51 @@ int client_mining_submit(T_DATUM_CLIENT_DATA *c, uint64_t id, json_t *params_obj
 		}
 	}
 
+	// Log the first bytes of the share hash for debugging
+	char hash_prefix[10];
+	snprintf(hash_prefix, sizeof(hash_prefix), "%02x%02x%02x%02x", 
+		share_hash[0], share_hash[1], share_hash[2], share_hash[3]);
+	DLOG_DEBUG("Share hash prefix: %s", hash_prefix);
+	
 	if (datum_config.stratum_v1_split_username && strchr(username_s, '%')) {
-		const uint16_t share_rnd = upk_u16le(share_hash, 0);
-		username_s = datum_stratum_relevant_username(username_s, username_buf, sizeof(username_buf), share_rnd);
+		DLOG_DEBUG("Original username before splitting: '%s'", username_s);
+		
+		// Extract bytes from the share hash for randomization
+		uint8_t byte0 = share_hash[0];
+		uint8_t byte1 = share_hash[1];
+		
+		// Use the opposite byte order for better distribution
+		const uint16_t share_rnd = ((uint16_t)byte1) | (((uint16_t)byte0) << 8);
+		
+		// Create a buffer to hold the username after processing
+		char username_buf[256];
+		
+		// Save the worker name from the original auth username if present
+		char worker_suffix[64] = "";
+		const char *dot_pos = strchr(m->last_auth_username, '.');
+		if (dot_pos) {
+			strncpy(worker_suffix, dot_pos, sizeof(worker_suffix) - 1);
+			worker_suffix[sizeof(worker_suffix) - 1] = '\0';
+			DLOG_DEBUG("Found worker name: %s", worker_suffix);
+		}
+		
+		// Call the function to determine which base address to use based on the share_rnd
+		const char *selected_base = datum_stratum_relevant_username(username_s, username_buf, sizeof(username_buf), share_rnd);
+		
+		// Update username_s to the selected username
+		if (selected_base && *selected_base) {
+			// First check if selected_base already has a worker name
+			const char *selected_dot = strchr(selected_base, '.');
+			if (!selected_dot && worker_suffix[0] != '\0') {
+				// If no worker in selected base but we have a worker suffix from auth, add it
+				snprintf(username_buf, sizeof(username_buf), "%s%s", selected_base, worker_suffix);
+				username_s = username_buf;
+				DLOG_DEBUG("Added worker back: %s", username_s);
+			} else {
+				// Either it already has a worker or no worker to add
+				username_s = selected_base;
+			}
+		}
 	}
 
 	// most important thing to do right here is to check if the share is a block
@@ -1270,6 +1371,13 @@ int client_mining_submit(T_DATUM_CLIENT_DATA *c, uint64_t id, json_t *params_obj
 		}
 	}
 
+	// Save a copy of the username for logging BEFORE sending the response
+	char selected_username_copy[256] = "";
+	if (username_s) {
+		strncpy(selected_username_copy, username_s, sizeof(selected_username_copy) - 1);
+		selected_username_copy[sizeof(selected_username_copy) - 1] = '\0';
+	}
+	
 	char s[256];
 	snprintf(s, sizeof(s), "{\"error\":null,\"id\":%"PRIu64",\"result\":true}\n", id);
 	datum_socket_send_string_to_client(c, s);
@@ -1278,6 +1386,11 @@ int client_mining_submit(T_DATUM_CLIENT_DATA *c, uint64_t id, json_t *params_obj
 	m->share_diff_accepted += job_diff;
 	m->share_count_accepted++;
 
+	// Log successful share submission with the actual username used
+	// Use the saved copy of the username to avoid any potential overwriting
+	DLOG_INFO("Share accepted: original='%s' selected='%s' diff=%lu nonce=%08x", 
+		m->last_auth_username, selected_username_copy, job_diff, nonce_val);
+	
 	// update since-snap totals
 	m->share_count_since_snap++;
 	m->share_diff_since_snap += job_diff;

src/datum_stratum_tests.c

@@ -54,6 +54,52 @@ void datum_stratum_relevant_username_tests() {
 	s = "abc%def";
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == s);
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == s);
+	
+	// Test username distribution without separator characters
+	s = "address1%50address2%50";
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
+	assert(!strcmp(buf, "address1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x7fff) == buf);
+	assert(!strcmp(buf, "address1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x8000) == buf);
+	assert(!strcmp(buf, "address2"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
+	assert(!strcmp(buf, "address2"));
+	
+	// Test custom percentage distribution (70/30)
+	s = "address1%70address2%30";
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
+	assert(!strcmp(buf, "address1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xb333) == buf); // ~70%
+	assert(!strcmp(buf, "address1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xb334) == buf); // > 70%
+	assert(!strcmp(buf, "address2"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
+	assert(!strcmp(buf, "address2"));
+	
+	// Test username distribution with worker names included
+	s = "address1.worker1%50address2.worker2%50";
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
+	assert(!strcmp(buf, "address1.worker1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x7fff) == buf);
+	assert(!strcmp(buf, "address1.worker1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x8000) == buf);
+	assert(!strcmp(buf, "address2.worker2"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
+	assert(!strcmp(buf, "address2.worker2"));
+	
+	// Test mixed format with separator after first percentage
+	s = "address1%50%address2%50";
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
+	assert(!strcmp(buf, "address1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x7fff) == buf);
+	assert(!strcmp(buf, "address1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x8000) == buf);
+	assert(!strcmp(buf, "address2"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
+	assert(!strcmp(buf, "address2"));
+	
+	// Test original cases
 	s = "abc%0%def";
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == &s[6]);
 	s = "abc%0%def%ghi";
@@ -99,6 +145,18 @@ void datum_stratum_relevant_username_tests() {
 	assert(!strcmp(buf, "ghi"));
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x7ad) == pool_addr);
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == pool_addr);
+	
+	// Test 50-50 split between two addresses
+	s = "user1%50user2%50";
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
+	assert(!strcmp(buf, "user1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x7fff) == buf);
+	assert(!strcmp(buf, "user1"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0x8000) == buf);
+	assert(!strcmp(buf, "user2"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
+	assert(!strcmp(buf, "user2"));
+	
 	s = "abc%.01%def";
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
 	assert(!strcmp(buf, "abc"));
@@ -139,15 +197,15 @@ void datum_stratum_relevant_username_tests() {
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0) == buf);
 	assert(!strcmp(buf, "abc"));
 	memset(buf, 5, 5);
-	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
-	assert(!strcmp(buf, "abc"));
+	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == &s[8]);
+	assert(!strcmp(buf, "def"));
 	s = "a%10%b%10%c%10%d%10%e%10%f%10%g%10%h%10%i%10%j%10";
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
 	assert(!strcmp(buf, "j"));
 	memset(buf, 5, 5);
 	s = "a%10%b%10%c%10%d%10%e%10%f%10%g%10%h%10%i%10%j%10%k";
 	assert(datum_stratum_relevant_username(s, buf, sizeof(buf), 0xffff) == buf);
-	assert(!strcmp(buf, "j"));
+	assert(!strcmp(buf, "k"));
 }
 
 void datum_stratum_tests(void) {