Quote from: WanderingPhilospher on Today at 02:46:47 PM

Quote from: HardwareCollector on Today at 02:25:41 PM

Quote from: WanderingPhilospher on Today at 01:38:44 PM

Quote from: HardwareCollector on Today at 01:24:57 PM

Quote from: WanderingPhilospher on June 03, 2020, 03:14:48 PM

Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.

Without knowing how the data is encoded/decoded, the lines by themselves are not very useful. A link to the source code would be very useful in this case.

was the export done by patatasfritas where he stated:

Quote

The X-coord is 128+18 bits and distance 126bits. The X-coordinate could be re-generated from the distance if necessary.

source code:

Code:

// Read DP
for(uint32_t h = 0; h < HASH_SIZE; h++) {

fread(&items,sizeof(uint32_t),1,f1);
fread(&maxItems,sizeof(uint32_t),1,f1);

for(uint32_t i = 0; i < items; i++) {
fread(&x,16,1,f1);
fread(&d,16,1,f1);
sign = (d.i64[1] & 0x8000000000000000);
htype = (d.i64[1] & 0x4000000000000000);

if(htype==0) {
::fprintf(ft,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
::fprintf(ft,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numTame++;
} else {
::fprintf(fw,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
if(sign)
::fprintf(fw,"-");
::fprintf(fw,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numWild++;

ft = tame; fw= wild.

I found and compiled the above source code and my exported data validates while yours do not.

The first column is the least significant bits (LSB) of the x-coordinate, and the second column is the traveled_distance to multiply secp256k1_generator_point with.

Tame:
[distinguished_point] = (tame_traveled_distance)*(secp256k1_generator_point)

Wild:
[working_public_key] = [(original_public_key) - (beginning_range)*(secp256k1_generator_point)].
[distinguished_point] = [(+-wild_traveled_distance)*(secp256k1_generator_point)] + [working_public key]
[private_key] = (beginning_range) + (tame_traveled_distance) +- (wild_traveled_distance)

Thank you! Great explanation.

When you say your export data validates while mine did not, what do you mean? I just copied and pasted the first two lines from each file that were generated from the export option.

For the private key; can it be solved via the data you get from the export source code I listed above? Sounds like it's missing a piece of data?

So, in order for the server to solve the private key, all it needs is x coord and distance?

Code:

// Send DP to server
for(int g = 0; g < CPU_GRP_SIZE; g++) {
if(IsDP(ph->px[g].bits64[3])) {
ITEM it;
it.x.Set(&ph->px[g]);
it.d.Set(&ph->distance[g]);
it.kIdx = g;
dps.push_back(it);

The server takes in all the DPs, compares all the x coords and distances, to see if a collision has been made/the key is solved?