Search content
Sort by
Showing 20 of 39 results by cnk1220
Re: The bitaxeSupra: Open source Bitcoin miner based on the BM1368 ASIC
Hi everyone.
Can you help me to disable the version rollling feature on bm1368.
https://github.com/skot/BM1397/blob/master/bm1366_registers.md#version-rolling
https://github.com/skot/BM1397/blob/master/bm1366_protocol.md#send-job
Can you help me to disable the version rollling feature on bm1368.
https://github.com/skot/BM1397/blob/master/bm1366_registers.md#version-rolling
https://github.com/skot/BM1397/blob/master/bm1366_protocol.md#send-job
Hi everyone.
I need a help to disable the version rollling feature on bm1368.
https://github.com/skot/BM1397/blob/master/bm1366_registers.md#version-rolling
https://github.com/skot/BM1397/blob/master/bm1366_protocol.md#send-job
I need a help to disable the version rollling feature on bm1368.
https://github.com/skot/BM1397/blob/master/bm1366_registers.md#version-rolling
https://github.com/skot/BM1397/blob/master/bm1366_protocol.md#send-job
Because this thread https://bitcointalk.org/index.php?topic=5537312.0
Hi everyone.
I need a help to disable the version rollling feature on bm1368.
https://github.com/skot/BM1397/blob/master/bm1366_registers.md#version-rolling
https://github.com/skot/BM1397/blob/master/bm1366_protocol.md#send-job
I need a help to disable the version rollling feature on bm1368.
https://github.com/skot/BM1397/blob/master/bm1366_registers.md#version-rolling
https://github.com/skot/BM1397/blob/master/bm1366_protocol.md#send-job
*** I post it at https://github.com/skot/bitaxe/discussions before yesterday and it was answered ( no sucess, by 404 panda user) but yesterday, I' reanswered him but all section "discussion" was gone from skot/bitaxe.. ***
Hi, good morning.
I need a help with something.
I have a Bitaxe Supra. I have a full node too, and for learning I make a python script that takes block data with "bitcoin-cli getblocktemplate", mount the block and try to mine this block.
So I trying to do samething with my Bitaxe, but, trying/testing how to process the block I get trouble and stuck.
I don't know if I mounting the merkle root in wrong order or what, but the nonce returned is never right.
For tests I get the block 850253:
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
With dumping the block data I get that prev block hash is in diferent order:
FROM THIS: 00 00 00 00 00 00 00 00 00 01 21 C6 C2 FB 09 1C 8F 23 19 2B 23 CC B9 78 31 3A 12 1E 67 3E E9 4E
TO THIS: 00 00 00 00 00 00 00 00 C6 21 01 00 1C 09 FB C2 2B 19 23 8F 78 B9 CC 23 1E 12 3A 31 4E E9 3E 67
Nonce, bits, timestamp and version I think is ok, but the merkle root I don't know how to calculate from stratum data, so I don't able to compare o dump like i did with prev block hash.
I was thinking about the asic diff or asic mask, but if someone get um hash above current difficult he in fact find the block so I realize that was not the problem, although I don't realy understand how it works (bitmask, verison mask, etc.)
Before someone try me to install a local stratum, I'm not interesting, that will be easy, I just want make it work.
Thankful for your help!
My code:
Hi, good morning.
I need a help with something.
I have a Bitaxe Supra. I have a full node too, and for learning I make a python script that takes block data with "bitcoin-cli getblocktemplate", mount the block and try to mine this block.
So I trying to do samething with my Bitaxe, but, trying/testing how to process the block I get trouble and stuck.
I don't know if I mounting the merkle root in wrong order or what, but the nonce returned is never right.
For tests I get the block 850253:
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
With dumping the block data I get that prev block hash is in diferent order:
FROM THIS: 00 00 00 00 00 00 00 00 00 01 21 C6 C2 FB 09 1C 8F 23 19 2B 23 CC B9 78 31 3A 12 1E 67 3E E9 4E
TO THIS: 00 00 00 00 00 00 00 00 C6 21 01 00 1C 09 FB C2 2B 19 23 8F 78 B9 CC 23 1E 12 3A 31 4E E9 3E 67
Nonce, bits, timestamp and version I think is ok, but the merkle root I don't know how to calculate from stratum data, so I don't able to compare o dump like i did with prev block hash.
I was thinking about the asic diff or asic mask, but if someone get um hash above current difficult he in fact find the block so I realize that was not the problem, although I don't realy understand how it works (bitmask, verison mask, etc.)
Before someone try me to install a local stratum, I'm not interesting, that will be easy, I just want make it work.
Thankful for your help!
My code:
Code:
void test_case(){
uint8_t prev_block_hash_raw[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0xc6, 0xc2, 0xfb, 0x09, 0x1c, 0x8f, 0x23, 0x19, 0x2b, 0x23, 0xcc, 0xb9, 0x78, 0x31, 0x3a, 0x12, 0x1e, 0x67, 0x3e, 0xe9, 0x4e};
uint8_t merkle_root_raw[32] = {0xfa, 0xb9, 0x47, 0xd4, 0xde, 0x52, 0x40, 0x2c, 0x7b, 0x71, 0xd6, 0x4c, 0x24, 0xeb, 0xf9, 0xe8, 0x91, 0x27, 0x42, 0x35, 0x8b, 0x4f, 0x84, 0x1b, 0x3e, 0xdc, 0xdf, 0x1a, 0x62, 0xce, 0x5a, 0x62};
BM1368_job test_job = {
.job_id = 0x10,
.num_midstates = 0x01, // Exemplo, ajuste conforme necessário
// .starting_nonce = {0x3F, 0x61, 0x25, 0x43}, // 0x4325613F → Little-endian
.starting_nonce = {0x01, 0x00, 0x00, 0x00}, // 0x00000001 → Little-endian
.nbits = {0x25, 0x5D, 0x03, 0x17}, // 0x17035D25 → Little-endian
.ntime = {0xFA, 0xD0, 0x82, 0x66}, // 0x6682D0FA → Little-endian
.version = {0x00, 0x00, 0xA0, 0x20}, // 0x20a00000
};
// reverse_bytes(test_job.merkle_root, 32);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
printf("\nPREV HASH:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// reverse_bytes(test_job.prev_block_hash, 32);
printf("\nPREV HASH BE:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
convert_hash_my(prev_block_hash_raw);
// convert_hash_my(merkle_root_raw);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
memcpy(test_job.merkle_root, merkle_root_raw, 32);
printf("\nPREV HASH V:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// uint8_t job_id;
// uint8_t num_midstates;
// uint8_t starting_nonce[4];
// uint8_t nbits[4];
// uint8_t ntime[4];
// uint8_t merkle_root[32];
// uint8_t prev_block_hash[32];
// uint8_t version[4];
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
// 44fe0174 that response is get by increasing the 'BM1368_ASIC_DIFFICULTY' parameter.
// AA 55 74 01 FE 44 04 29 80 D9 92
printf("\nIH: 1368 JOB CONSTRUIDO\n");
hexdump_my(&test_job, sizeof(test_job));
uint8_t buf[1024];
memset(buf, 0, 1024);
// BM1397_send_work_my(&test_job);
_send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&test_job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
// free_bm_job(test_job.job_id);
// sleep(2);
// wait for a response
int received = SERIAL_rx(buf, 11, BM1368_TIMEOUT_MS);
printf("\nIH: 1368 HEX BUF 1\n");
hexdump_my(&buf, 24);
asic_result nonce;
memcpy((void *)&nonce, buf, sizeof(asic_result));
printf("\nIH: NONCE RECUPERADO\n");
hexdump_my(&nonce, sizeof(nonce));
printf("\nIH: RESULT NONCE: %lx", nonce.nonce);
// Response:
// uint8_t preamble[2];
// uint32_t nonce;
// uint8_t midstate_num;
// uint8_t job_id;
// uint16_t version;
// uint8_t crc;
uint8_t job_id = (nonce.job_id & 0xf0) >> 1;
uint8_t core_id = (uint8_t)((reverse_uint32(nonce.nonce) >> 25) & 0x7f);
uint8_t small_core_id = nonce.job_id & 0x0f;
uint32_t version_bits = (reverse_uint16(nonce.version) << 13);
printf("\nJob ID: %02X, Nonce: %lx, Core: %d/%d, Ver: %08" PRIX32, job_id, nonce.nonce, core_id, small_core_id, version_bits);
vTaskDelete(NULL);
}
uint8_t prev_block_hash_raw[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0xc6, 0xc2, 0xfb, 0x09, 0x1c, 0x8f, 0x23, 0x19, 0x2b, 0x23, 0xcc, 0xb9, 0x78, 0x31, 0x3a, 0x12, 0x1e, 0x67, 0x3e, 0xe9, 0x4e};
uint8_t merkle_root_raw[32] = {0xfa, 0xb9, 0x47, 0xd4, 0xde, 0x52, 0x40, 0x2c, 0x7b, 0x71, 0xd6, 0x4c, 0x24, 0xeb, 0xf9, 0xe8, 0x91, 0x27, 0x42, 0x35, 0x8b, 0x4f, 0x84, 0x1b, 0x3e, 0xdc, 0xdf, 0x1a, 0x62, 0xce, 0x5a, 0x62};
BM1368_job test_job = {
.job_id = 0x10,
.num_midstates = 0x01, // Exemplo, ajuste conforme necessário
// .starting_nonce = {0x3F, 0x61, 0x25, 0x43}, // 0x4325613F → Little-endian
.starting_nonce = {0x01, 0x00, 0x00, 0x00}, // 0x00000001 → Little-endian
.nbits = {0x25, 0x5D, 0x03, 0x17}, // 0x17035D25 → Little-endian
.ntime = {0xFA, 0xD0, 0x82, 0x66}, // 0x6682D0FA → Little-endian
.version = {0x00, 0x00, 0xA0, 0x20}, // 0x20a00000
};
// reverse_bytes(test_job.merkle_root, 32);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
printf("\nPREV HASH:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// reverse_bytes(test_job.prev_block_hash, 32);
printf("\nPREV HASH BE:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
convert_hash_my(prev_block_hash_raw);
// convert_hash_my(merkle_root_raw);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
memcpy(test_job.merkle_root, merkle_root_raw, 32);
printf("\nPREV HASH V:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// uint8_t job_id;
// uint8_t num_midstates;
// uint8_t starting_nonce[4];
// uint8_t nbits[4];
// uint8_t ntime[4];
// uint8_t merkle_root[32];
// uint8_t prev_block_hash[32];
// uint8_t version[4];
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
// 44fe0174 that response is get by increasing the 'BM1368_ASIC_DIFFICULTY' parameter.
// AA 55 74 01 FE 44 04 29 80 D9 92
printf("\nIH: 1368 JOB CONSTRUIDO\n");
hexdump_my(&test_job, sizeof(test_job));
uint8_t buf[1024];
memset(buf, 0, 1024);
// BM1397_send_work_my(&test_job);
_send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&test_job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
// free_bm_job(test_job.job_id);
// sleep(2);
// wait for a response
int received = SERIAL_rx(buf, 11, BM1368_TIMEOUT_MS);
printf("\nIH: 1368 HEX BUF 1\n");
hexdump_my(&buf, 24);
asic_result nonce;
memcpy((void *)&nonce, buf, sizeof(asic_result));
printf("\nIH: NONCE RECUPERADO\n");
hexdump_my(&nonce, sizeof(nonce));
printf("\nIH: RESULT NONCE: %lx", nonce.nonce);
// Response:
// uint8_t preamble[2];
// uint32_t nonce;
// uint8_t midstate_num;
// uint8_t job_id;
// uint16_t version;
// uint8_t crc;
uint8_t job_id = (nonce.job_id & 0xf0) >> 1;
uint8_t core_id = (uint8_t)((reverse_uint32(nonce.nonce) >> 25) & 0x7f);
uint8_t small_core_id = nonce.job_id & 0x0f;
uint32_t version_bits = (reverse_uint16(nonce.version) << 13);
printf("\nJob ID: %02X, Nonce: %lx, Core: %d/%d, Ver: %08" PRIX32, job_id, nonce.nonce, core_id, small_core_id, version_bits);
vTaskDelete(NULL);
}
Re: The bitaxeSupra: Open source Bitcoin miner based on the BM1368 ASIC
*** I post it at https://github.com/skot/bitaxe/discussions before yesterday and it was answered ( no sucess, by 404 panda user) but yesterday, I' reanswered him but all section "discussion" was gone from skot/bitaxe.. ***
Hi, good morning.
I need a help with something.
I have a Bitaxe Supra. I have a full node too, and for learning I make a python script that takes block data with "bitcoin-cli getblocktemplate", mount the block and try to mine this block.
So I trying to do samething with my Bitaxe, but, trying/testing how to process the block I get trouble and stuck.
I don't know if I mounting the merkle root in wrong order or what, but the nonce returned is never right.
For tests I get the block 850253:
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
With dumping the block data I get that prev block hash is in diferent order:
FROM THIS: 00 00 00 00 00 00 00 00 00 01 21 C6 C2 FB 09 1C 8F 23 19 2B 23 CC B9 78 31 3A 12 1E 67 3E E9 4E
TO THIS: 00 00 00 00 00 00 00 00 C6 21 01 00 1C 09 FB C2 2B 19 23 8F 78 B9 CC 23 1E 12 3A 31 4E E9 3E 67
Nonce, bits, timestamp and version I think is ok, but the merkle root I don't know how to calculate from stratum data, so I don't able to compare o dump like i did with prev block hash.
I was thinking about the asic diff or asic mask, but if someone get um hash above current difficult he in fact find the block so I realize that was not the problem, although I don't realy understand how it works (bitmask, verison mask, etc.)
Before someone try me to install a local stratum, I'm not interesting, that will be easy, I just want make it work.
Thankful for your help!
My code:
Hi, good morning.
I need a help with something.
I have a Bitaxe Supra. I have a full node too, and for learning I make a python script that takes block data with "bitcoin-cli getblocktemplate", mount the block and try to mine this block.
So I trying to do samething with my Bitaxe, but, trying/testing how to process the block I get trouble and stuck.
I don't know if I mounting the merkle root in wrong order or what, but the nonce returned is never right.
For tests I get the block 850253:
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
With dumping the block data I get that prev block hash is in diferent order:
FROM THIS: 00 00 00 00 00 00 00 00 00 01 21 C6 C2 FB 09 1C 8F 23 19 2B 23 CC B9 78 31 3A 12 1E 67 3E E9 4E
TO THIS: 00 00 00 00 00 00 00 00 C6 21 01 00 1C 09 FB C2 2B 19 23 8F 78 B9 CC 23 1E 12 3A 31 4E E9 3E 67
Nonce, bits, timestamp and version I think is ok, but the merkle root I don't know how to calculate from stratum data, so I don't able to compare o dump like i did with prev block hash.
I was thinking about the asic diff or asic mask, but if someone get um hash above current difficult he in fact find the block so I realize that was not the problem, although I don't realy understand how it works (bitmask, verison mask, etc.)
Before someone try me to install a local stratum, I'm not interesting, that will be easy, I just want make it work.
Thankful for your help!
My code:
Code:
void test_case(){
uint8_t prev_block_hash_raw[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0xc6, 0xc2, 0xfb, 0x09, 0x1c, 0x8f, 0x23, 0x19, 0x2b, 0x23, 0xcc, 0xb9, 0x78, 0x31, 0x3a, 0x12, 0x1e, 0x67, 0x3e, 0xe9, 0x4e};
uint8_t merkle_root_raw[32] = {0xfa, 0xb9, 0x47, 0xd4, 0xde, 0x52, 0x40, 0x2c, 0x7b, 0x71, 0xd6, 0x4c, 0x24, 0xeb, 0xf9, 0xe8, 0x91, 0x27, 0x42, 0x35, 0x8b, 0x4f, 0x84, 0x1b, 0x3e, 0xdc, 0xdf, 0x1a, 0x62, 0xce, 0x5a, 0x62};
BM1368_job test_job = {
.job_id = 0x10,
.num_midstates = 0x01, // Exemplo, ajuste conforme necessário
// .starting_nonce = {0x3F, 0x61, 0x25, 0x43}, // 0x4325613F → Little-endian
.starting_nonce = {0x01, 0x00, 0x00, 0x00}, // 0x00000001 → Little-endian
.nbits = {0x25, 0x5D, 0x03, 0x17}, // 0x17035D25 → Little-endian
.ntime = {0xFA, 0xD0, 0x82, 0x66}, // 0x6682D0FA → Little-endian
.version = {0x00, 0x00, 0xA0, 0x20}, // 0x20a00000
};
// reverse_bytes(test_job.merkle_root, 32);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
printf("\nPREV HASH:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// reverse_bytes(test_job.prev_block_hash, 32);
printf("\nPREV HASH BE:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
convert_hash_my(prev_block_hash_raw);
// convert_hash_my(merkle_root_raw);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
memcpy(test_job.merkle_root, merkle_root_raw, 32);
printf("\nPREV HASH V:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// uint8_t job_id;
// uint8_t num_midstates;
// uint8_t starting_nonce[4];
// uint8_t nbits[4];
// uint8_t ntime[4];
// uint8_t merkle_root[32];
// uint8_t prev_block_hash[32];
// uint8_t version[4];
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
// 44fe0174 that response is get by increasing the 'BM1368_ASIC_DIFFICULTY' parameter.
// AA 55 74 01 FE 44 04 29 80 D9 92
printf("\nIH: 1368 JOB CONSTRUIDO\n");
hexdump_my(&test_job, sizeof(test_job));
uint8_t buf[1024];
memset(buf, 0, 1024);
// BM1397_send_work_my(&test_job);
_send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&test_job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
// free_bm_job(test_job.job_id);
// sleep(2);
// wait for a response
int received = SERIAL_rx(buf, 11, BM1368_TIMEOUT_MS);
printf("\nIH: 1368 HEX BUF 1\n");
hexdump_my(&buf, 24);
asic_result nonce;
memcpy((void *)&nonce, buf, sizeof(asic_result));
printf("\nIH: NONCE RECUPERADO\n");
hexdump_my(&nonce, sizeof(nonce));
printf("\nIH: RESULT NONCE: %lx", nonce.nonce);
// Response:
// uint8_t preamble[2];
// uint32_t nonce;
// uint8_t midstate_num;
// uint8_t job_id;
// uint16_t version;
// uint8_t crc;
uint8_t job_id = (nonce.job_id & 0xf0) >> 1;
uint8_t core_id = (uint8_t)((reverse_uint32(nonce.nonce) >> 25) & 0x7f);
uint8_t small_core_id = nonce.job_id & 0x0f;
uint32_t version_bits = (reverse_uint16(nonce.version) << 13);
printf("\nJob ID: %02X, Nonce: %lx, Core: %d/%d, Ver: %08" PRIX32, job_id, nonce.nonce, core_id, small_core_id, version_bits);
vTaskDelete(NULL);
}
uint8_t prev_block_hash_raw[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0xc6, 0xc2, 0xfb, 0x09, 0x1c, 0x8f, 0x23, 0x19, 0x2b, 0x23, 0xcc, 0xb9, 0x78, 0x31, 0x3a, 0x12, 0x1e, 0x67, 0x3e, 0xe9, 0x4e};
uint8_t merkle_root_raw[32] = {0xfa, 0xb9, 0x47, 0xd4, 0xde, 0x52, 0x40, 0x2c, 0x7b, 0x71, 0xd6, 0x4c, 0x24, 0xeb, 0xf9, 0xe8, 0x91, 0x27, 0x42, 0x35, 0x8b, 0x4f, 0x84, 0x1b, 0x3e, 0xdc, 0xdf, 0x1a, 0x62, 0xce, 0x5a, 0x62};
BM1368_job test_job = {
.job_id = 0x10,
.num_midstates = 0x01, // Exemplo, ajuste conforme necessário
// .starting_nonce = {0x3F, 0x61, 0x25, 0x43}, // 0x4325613F → Little-endian
.starting_nonce = {0x01, 0x00, 0x00, 0x00}, // 0x00000001 → Little-endian
.nbits = {0x25, 0x5D, 0x03, 0x17}, // 0x17035D25 → Little-endian
.ntime = {0xFA, 0xD0, 0x82, 0x66}, // 0x6682D0FA → Little-endian
.version = {0x00, 0x00, 0xA0, 0x20}, // 0x20a00000
};
// reverse_bytes(test_job.merkle_root, 32);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
printf("\nPREV HASH:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// reverse_bytes(test_job.prev_block_hash, 32);
printf("\nPREV HASH BE:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
convert_hash_my(prev_block_hash_raw);
// convert_hash_my(merkle_root_raw);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
memcpy(test_job.merkle_root, merkle_root_raw, 32);
printf("\nPREV HASH V:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// uint8_t job_id;
// uint8_t num_midstates;
// uint8_t starting_nonce[4];
// uint8_t nbits[4];
// uint8_t ntime[4];
// uint8_t merkle_root[32];
// uint8_t prev_block_hash[32];
// uint8_t version[4];
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
// 44fe0174 that response is get by increasing the 'BM1368_ASIC_DIFFICULTY' parameter.
// AA 55 74 01 FE 44 04 29 80 D9 92
printf("\nIH: 1368 JOB CONSTRUIDO\n");
hexdump_my(&test_job, sizeof(test_job));
uint8_t buf[1024];
memset(buf, 0, 1024);
// BM1397_send_work_my(&test_job);
_send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&test_job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
// free_bm_job(test_job.job_id);
// sleep(2);
// wait for a response
int received = SERIAL_rx(buf, 11, BM1368_TIMEOUT_MS);
printf("\nIH: 1368 HEX BUF 1\n");
hexdump_my(&buf, 24);
asic_result nonce;
memcpy((void *)&nonce, buf, sizeof(asic_result));
printf("\nIH: NONCE RECUPERADO\n");
hexdump_my(&nonce, sizeof(nonce));
printf("\nIH: RESULT NONCE: %lx", nonce.nonce);
// Response:
// uint8_t preamble[2];
// uint32_t nonce;
// uint8_t midstate_num;
// uint8_t job_id;
// uint16_t version;
// uint8_t crc;
uint8_t job_id = (nonce.job_id & 0xf0) >> 1;
uint8_t core_id = (uint8_t)((reverse_uint32(nonce.nonce) >> 25) & 0x7f);
uint8_t small_core_id = nonce.job_id & 0x0f;
uint32_t version_bits = (reverse_uint16(nonce.version) << 13);
printf("\nJob ID: %02X, Nonce: %lx, Core: %d/%d, Ver: %08" PRIX32, job_id, nonce.nonce, core_id, small_core_id, version_bits);
vTaskDelete(NULL);
}
*** I post it at https://github.com/skot/bitaxe/discussions yesterday and it was answered ( no sucess by 404 panda user) but right now, I' reanswered him but all section "discussion" was gone from skot/bitaxe.. ***
Hi, good night.
I need a help with something.
I have a Bitaxe Supra. I have a full node too, and for learning I make a python script that takes block data with "bitcoin-cli getblocktemplate", mount the block and try to mine this block.
So I trying to do samething with my Bitaxe, but, trying/testing how to process the block I get trouble and stuck.
I don't know if I mounting the merkle root in wrong order or what, but the nonce returned is never right.
For tests I get the block 850253:
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
With dumping the block data I get that prev block hash is in diferent order:
FROM THIS: 00 00 00 00 00 00 00 00 00 01 21 C6 C2 FB 09 1C 8F 23 19 2B 23 CC B9 78 31 3A 12 1E 67 3E E9 4E
TO THIS: 00 00 00 00 00 00 00 00 C6 21 01 00 1C 09 FB C2 2B 19 23 8F 78 B9 CC 23 1E 12 3A 31 4E E9 3E 67
Nonce, bits, timestamp and version I think is ok, but the merkle root I don't know how to calculate from stratum data, so I don't able to compare o dump like i did with prev block hash.
I was thinking about the asic diff or asic mask, but if someone get um hash above current difficult he in fact find the block so I realize that was not the problem, although I don't realy understand how it works (bitmask, verison mask, etc.)
Before someone try me to install a local stratum, I'm not interesting, that will be easy, I just want make it work.
Thankful for your help!
My code:
void test_case(){
uint8_t prev_block_hash_raw[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0xc6, 0xc2, 0xfb, 0x09, 0x1c, 0x8f, 0x23, 0x19, 0x2b, 0x23, 0xcc, 0xb9, 0x78, 0x31, 0x3a, 0x12, 0x1e, 0x67, 0x3e, 0xe9, 0x4e};
uint8_t merkle_root_raw[32] = {0xfa, 0xb9, 0x47, 0xd4, 0xde, 0x52, 0x40, 0x2c, 0x7b, 0x71, 0xd6, 0x4c, 0x24, 0xeb, 0xf9, 0xe8, 0x91, 0x27, 0x42, 0x35, 0x8b, 0x4f, 0x84, 0x1b, 0x3e, 0xdc, 0xdf, 0x1a, 0x62, 0xce, 0x5a, 0x62};
BM1368_job test_job = {
.job_id = 0x10,
.num_midstates = 0x01, // Exemplo, ajuste conforme necessário
// .starting_nonce = {0x3F, 0x61, 0x25, 0x43}, // 0x4325613F → Little-endian
.starting_nonce = {0x01, 0x00, 0x00, 0x00}, // 0x00000001 → Little-endian
.nbits = {0x25, 0x5D, 0x03, 0x17}, // 0x17035D25 → Little-endian
.ntime = {0xFA, 0xD0, 0x82, 0x66}, // 0x6682D0FA → Little-endian
.version = {0x00, 0x00, 0xA0, 0x20}, // 0x20a00000
};
// reverse_bytes(test_job.merkle_root, 32);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
printf("\nPREV HASH:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// reverse_bytes(test_job.prev_block_hash, 32);
printf("\nPREV HASH BE:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
convert_hash_my(prev_block_hash_raw);
// convert_hash_my(merkle_root_raw);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
memcpy(test_job.merkle_root, merkle_root_raw, 32);
printf("\nPREV HASH V:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// uint8_t job_id;
// uint8_t num_midstates;
// uint8_t starting_nonce[4];
// uint8_t nbits[4];
// uint8_t ntime[4];
// uint8_t merkle_root[32];
// uint8_t prev_block_hash[32];
// uint8_t version[4];
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
// 44fe0174 that response is get by increasing the 'BM1368_ASIC_DIFFICULTY' parameter.
// AA 55 74 01 FE 44 04 29 80 D9 92
printf("\nIH: 1368 JOB CONSTRUIDO\n");
hexdump_my(&test_job, sizeof(test_job));
uint8_t buf[1024];
memset(buf, 0, 1024);
// BM1397_send_work_my(&test_job);
_send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&test_job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
// free_bm_job(test_job.job_id);
// sleep(2);
// wait for a response
int received = SERIAL_rx(buf, 11, BM1368_TIMEOUT_MS);
printf("\nIH: 1368 HEX BUF 1\n");
hexdump_my(&buf, 24);
asic_result nonce;
memcpy((void *)&nonce, buf, sizeof(asic_result));
printf("\nIH: NONCE RECUPERADO\n");
hexdump_my(&nonce, sizeof(nonce));
printf("\nIH: RESULT NONCE: %lx", nonce.nonce);
// Response:
// uint8_t preamble[2];
// uint32_t nonce;
// uint8_t midstate_num;
// uint8_t job_id;
// uint16_t version;
// uint8_t crc;
uint8_t job_id = (nonce.job_id & 0xf0) >> 1;
uint8_t core_id = (uint8_t)((reverse_uint32(nonce.nonce) >> 25) & 0x7f);
uint8_t small_core_id = nonce.job_id & 0x0f;
uint32_t version_bits = (reverse_uint16(nonce.version) << 13);
printf("\nJob ID: %02X, Nonce: %lx, Core: %d/%d, Ver: %08" PRIX32, job_id, nonce.nonce, core_id, small_core_id, version_bits);
vTaskDelete(NULL);
}
Hi, good night.
I need a help with something.
I have a Bitaxe Supra. I have a full node too, and for learning I make a python script that takes block data with "bitcoin-cli getblocktemplate", mount the block and try to mine this block.
So I trying to do samething with my Bitaxe, but, trying/testing how to process the block I get trouble and stuck.
I don't know if I mounting the merkle root in wrong order or what, but the nonce returned is never right.
For tests I get the block 850253:
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
With dumping the block data I get that prev block hash is in diferent order:
FROM THIS: 00 00 00 00 00 00 00 00 00 01 21 C6 C2 FB 09 1C 8F 23 19 2B 23 CC B9 78 31 3A 12 1E 67 3E E9 4E
TO THIS: 00 00 00 00 00 00 00 00 C6 21 01 00 1C 09 FB C2 2B 19 23 8F 78 B9 CC 23 1E 12 3A 31 4E E9 3E 67
Nonce, bits, timestamp and version I think is ok, but the merkle root I don't know how to calculate from stratum data, so I don't able to compare o dump like i did with prev block hash.
I was thinking about the asic diff or asic mask, but if someone get um hash above current difficult he in fact find the block so I realize that was not the problem, although I don't realy understand how it works (bitmask, verison mask, etc.)
Before someone try me to install a local stratum, I'm not interesting, that will be easy, I just want make it work.
Thankful for your help!
My code:
void test_case(){
uint8_t prev_block_hash_raw[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0xc6, 0xc2, 0xfb, 0x09, 0x1c, 0x8f, 0x23, 0x19, 0x2b, 0x23, 0xcc, 0xb9, 0x78, 0x31, 0x3a, 0x12, 0x1e, 0x67, 0x3e, 0xe9, 0x4e};
uint8_t merkle_root_raw[32] = {0xfa, 0xb9, 0x47, 0xd4, 0xde, 0x52, 0x40, 0x2c, 0x7b, 0x71, 0xd6, 0x4c, 0x24, 0xeb, 0xf9, 0xe8, 0x91, 0x27, 0x42, 0x35, 0x8b, 0x4f, 0x84, 0x1b, 0x3e, 0xdc, 0xdf, 0x1a, 0x62, 0xce, 0x5a, 0x62};
BM1368_job test_job = {
.job_id = 0x10,
.num_midstates = 0x01, // Exemplo, ajuste conforme necessário
// .starting_nonce = {0x3F, 0x61, 0x25, 0x43}, // 0x4325613F → Little-endian
.starting_nonce = {0x01, 0x00, 0x00, 0x00}, // 0x00000001 → Little-endian
.nbits = {0x25, 0x5D, 0x03, 0x17}, // 0x17035D25 → Little-endian
.ntime = {0xFA, 0xD0, 0x82, 0x66}, // 0x6682D0FA → Little-endian
.version = {0x00, 0x00, 0xA0, 0x20}, // 0x20a00000
};
// reverse_bytes(test_job.merkle_root, 32);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
printf("\nPREV HASH:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// reverse_bytes(test_job.prev_block_hash, 32);
printf("\nPREV HASH BE:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
convert_hash_my(prev_block_hash_raw);
// convert_hash_my(merkle_root_raw);
memcpy(test_job.prev_block_hash, prev_block_hash_raw, 32);
memcpy(test_job.merkle_root, merkle_root_raw, 32);
printf("\nPREV HASH V:\t");
hexdump_my(&test_job.prev_block_hash, sizeof(test_job.prev_block_hash));
// uint8_t job_id;
// uint8_t num_midstates;
// uint8_t starting_nonce[4];
// uint8_t nbits[4];
// uint8_t ntime[4];
// uint8_t merkle_root[32];
// uint8_t prev_block_hash[32];
// uint8_t version[4];
// Cabeçalho do bloco:
// Versão: 0x20a00000
// Hash do bloco anterior: 0000000000000000000121c6c2fb091c8f23192b23ccb978313a121e673ee94e
// Hash da árvore de Merkle: fab947d4de52402c7b71d64c24ebf9e8912742358b4f841b3edcdf1a62ce5a62
// Timestamp: 0x6682d0fa
// Bits de dificuldade: 0x17035d25
// Nonce: 0x4325613f
// Hash do bloco: 000000000000000000018e6395574b2c177aa0033fb4736bb5a3b6d38a040f41
// Hash do midstate: c6aafbd036459eeb9267395191bed72439bd1724bbf5898355c65a0489f6f01
// 44fe0174 that response is get by increasing the 'BM1368_ASIC_DIFFICULTY' parameter.
// AA 55 74 01 FE 44 04 29 80 D9 92
printf("\nIH: 1368 JOB CONSTRUIDO\n");
hexdump_my(&test_job, sizeof(test_job));
uint8_t buf[1024];
memset(buf, 0, 1024);
// BM1397_send_work_my(&test_job);
_send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&test_job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
// free_bm_job(test_job.job_id);
// sleep(2);
// wait for a response
int received = SERIAL_rx(buf, 11, BM1368_TIMEOUT_MS);
printf("\nIH: 1368 HEX BUF 1\n");
hexdump_my(&buf, 24);
asic_result nonce;
memcpy((void *)&nonce, buf, sizeof(asic_result));
printf("\nIH: NONCE RECUPERADO\n");
hexdump_my(&nonce, sizeof(nonce));
printf("\nIH: RESULT NONCE: %lx", nonce.nonce);
// Response:
// uint8_t preamble[2];
// uint32_t nonce;
// uint8_t midstate_num;
// uint8_t job_id;
// uint16_t version;
// uint8_t crc;
uint8_t job_id = (nonce.job_id & 0xf0) >> 1;
uint8_t core_id = (uint8_t)((reverse_uint32(nonce.nonce) >> 25) & 0x7f);
uint8_t small_core_id = nonce.job_id & 0x0f;
uint32_t version_bits = (reverse_uint16(nonce.version) << 13);
printf("\nJob ID: %02X, Nonce: %lx, Core: %d/%d, Ver: %08" PRIX32, job_id, nonce.nonce, core_id, small_core_id, version_bits);
vTaskDelete(NULL);
}
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
This code will generate a random string.
Then it will adjust each column range(1, 16)
If column 1 is 0x2 then the next string is 0x3, 0x4, 0x5 - 0x1
It will do this for each column.
Then it will adjust each column range(1, 16)
If column 1 is 0x2 then the next string is 0x3, 0x4, 0x5 - 0x1
It will do this for each column.
Code:
from bitcoin import privtopub, pubtoaddr
import random
import string
import multiprocessing
import time
import os
import secrets
def create_random_slider_field(columns):
return [random.choice(string.hexdigits.lower()) for _ in range(columns)]
def adjust_slider(slider, column, direction):
hex_chars = string.hexdigits.lower()
current_index = hex_chars.index(slider[column])
new_index = (current_index + direction) % len(hex_chars)
slider[column] = hex_chars[new_index]
return slider
def check_address(private_key, target_address):
try:
address = pubtoaddr(privtopub(private_key))
return address == target_address
except Exception as e:
print(f"Error generating address: {e}")
return False
def search_process(target_address, process_attempts, result_queue):
byte_values = list(range(256))
random_bytes = [secrets.choice(byte_values) for _ in range(8)]
random.seed(int.from_bytes(random_bytes))
slider_columns = 19
attempts = 0
hex_chars = string.hexdigits.lower()
while attempts < process_attempts:
slider = create_random_slider_field(slider_columns)
for column in range(slider_columns):
original_value = slider[column]
original_index = hex_chars.index(original_value)
# Check original value
private_key = '0' * 46 + '1' + ''.join(slider) # Updated prefix, adjust leading zeros.
if check_address(private_key, target_address):
result_queue.put((private_key, attempts))
return
attempts += 1
# Optimized range checking
for i in range(1, 16):
# Check increasing values
new_index = (original_index + i) % 16
slider[column] = hex_chars[new_index]
private_key = '0' * 46 + '1' + ''.join(slider) # Updated prefix, adjust leading zeros.
if check_address(private_key, target_address):
result_queue.put((private_key, attempts))
return
attempts += 1
# Reset to original value before moving to next column
slider[column] = original_value
if attempts % 1000 == 0:
print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: {''.join(slider)}")
result_queue.put((None, attempts))
def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4): #max_attempts / 4 cores
processes = []
result_queue = multiprocessing.Queue()
attempts_per_process = max_attempts // num_processes
start_time = time.time()
for i in range(num_processes):
p = multiprocessing.Process(
target=search_process,
args=(target_address, attempts_per_process, result_queue)
)
processes.append(p)
p.start()
total_attempts = 0
for _ in range(num_processes):
result, attempts = result_queue.get()
total_attempts += attempts
if result:
# Stop all processes
for p in processes:
p.terminate()
return result, total_attempts
# Wait for all processes to complete
for p in processes:
p.join()
end_time = time.time()
print(f"Total time: {end_time - start_time:.2f} seconds")
return None, total_attempts
# Main program
if __name__ == "__main__":
target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG" # puzzle address
print(f"Target Bitcoin Address: {target_address}")
result, attempts = multiprocessing_search(target_address)
if result:
f = open("keys.txt", "a")
f.write(result + '\n')
f.close()
print(f"Matching private key found: {result}")
print(f"Total attempts: {attempts}")
f = open("keys.txt", "a")
f.write(result + '\n')
f.close()
else:
print(f"No match found after {attempts} attempts")
import random
import string
import multiprocessing
import time
import os
import secrets
def create_random_slider_field(columns):
return [random.choice(string.hexdigits.lower()) for _ in range(columns)]
def adjust_slider(slider, column, direction):
hex_chars = string.hexdigits.lower()
current_index = hex_chars.index(slider[column])
new_index = (current_index + direction) % len(hex_chars)
slider[column] = hex_chars[new_index]
return slider
def check_address(private_key, target_address):
try:
address = pubtoaddr(privtopub(private_key))
return address == target_address
except Exception as e:
print(f"Error generating address: {e}")
return False
def search_process(target_address, process_attempts, result_queue):
byte_values = list(range(256))
random_bytes = [secrets.choice(byte_values) for _ in range(8)]
random.seed(int.from_bytes(random_bytes))
slider_columns = 19
attempts = 0
hex_chars = string.hexdigits.lower()
while attempts < process_attempts:
slider = create_random_slider_field(slider_columns)
for column in range(slider_columns):
original_value = slider[column]
original_index = hex_chars.index(original_value)
# Check original value
private_key = '0' * 46 + '1' + ''.join(slider) # Updated prefix, adjust leading zeros.
if check_address(private_key, target_address):
result_queue.put((private_key, attempts))
return
attempts += 1
# Optimized range checking
for i in range(1, 16):
# Check increasing values
new_index = (original_index + i) % 16
slider[column] = hex_chars[new_index]
private_key = '0' * 46 + '1' + ''.join(slider) # Updated prefix, adjust leading zeros.
if check_address(private_key, target_address):
result_queue.put((private_key, attempts))
return
attempts += 1
# Reset to original value before moving to next column
slider[column] = original_value
if attempts % 1000 == 0:
print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: {''.join(slider)}")
result_queue.put((None, attempts))
def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4): #max_attempts / 4 cores
processes = []
result_queue = multiprocessing.Queue()
attempts_per_process = max_attempts // num_processes
start_time = time.time()
for i in range(num_processes):
p = multiprocessing.Process(
target=search_process,
args=(target_address, attempts_per_process, result_queue)
)
processes.append(p)
p.start()
total_attempts = 0
for _ in range(num_processes):
result, attempts = result_queue.get()
total_attempts += attempts
if result:
# Stop all processes
for p in processes:
p.terminate()
return result, total_attempts
# Wait for all processes to complete
for p in processes:
p.join()
end_time = time.time()
print(f"Total time: {end_time - start_time:.2f} seconds")
return None, total_attempts
# Main program
if __name__ == "__main__":
target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG" # puzzle address
print(f"Target Bitcoin Address: {target_address}")
result, attempts = multiprocessing_search(target_address)
if result:
f = open("keys.txt", "a")
f.write(result + '\n')
f.close()
print(f"Matching private key found: {result}")
print(f"Total attempts: {attempts}")
f = open("keys.txt", "a")
f.write(result + '\n')
f.close()
else:
print(f"No match found after {attempts} attempts")
Sorry, but did I lost something?
What is that about?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
My bot found the key and I send 3 Transactions all accepted by mempool, but they weren't mined.
Hello everybody. In 2019, I create my firt btc_miner, in python and C and bitcoincore (personal project).
With my RTX-3080 i got 1.3 GHhash/s not bad
some code to select transactions in pool.
I decide in my code 250~500 transactions with better fees and ~2500 with small fees and get ~4000transactions and try mine block. I think lucky your transaction faill
Hello everybody. In 2019, I create my firt btc_miner, in python and C and bitcoincore (personal project).
With my RTX-3080 i got 1.3 GHhash/s not bad
some code to select transactions in pool.
Code:
try:
pc_connection = AuthServiceProxy(serverURL)
mempool = rpc_connection.getrawmempool(True)
alltxs = [(txid, tx['fees'], tx['unbroadcast'],tx['bip125-replaceable']) for txid, tx in mempool.items()]
alltxs_sorted = sorted(alltxs, key=lambda x: x[1]['modified'], reverse=False)
except Exception as e:
time.sleep(10)
continue
# how many transactions i want (random)
nx = random.randint(3000, 5000)
tokens = alltxs_sorted[:nx]
Did you or did Alberto make the btc_miner?
txhashes = []
txs_hex = []
# fees
fees = 0
ntx1 = 0
pos_tx = 0
for txs in tokens:
pos_tx += 1
tx_hash = txs[0]
brod = txs[2]
taxa = txs[1]['modified']
repl = txs[3]
if brod == False:
try:
raw_tx = rpc_connection.getrawtransaction(tx_hash)
if repl == False and ntx1 < 4500:
....
pc_connection = AuthServiceProxy(serverURL)
mempool = rpc_connection.getrawmempool(True)
alltxs = [(txid, tx['fees'], tx['unbroadcast'],tx['bip125-replaceable']) for txid, tx in mempool.items()]
alltxs_sorted = sorted(alltxs, key=lambda x: x[1]['modified'], reverse=False)
except Exception as e:
time.sleep(10)
continue
# how many transactions i want (random)
nx = random.randint(3000, 5000)
tokens = alltxs_sorted[:nx]
Did you or did Alberto make the btc_miner?
txhashes = []
txs_hex = []
# fees
fees = 0
ntx1 = 0
pos_tx = 0
for txs in tokens:
pos_tx += 1
tx_hash = txs[0]
brod = txs[2]
taxa = txs[1]['modified']
repl = txs[3]
if brod == False:
try:
raw_tx = rpc_connection.getrawtransaction(tx_hash)
if repl == False and ntx1 < 4500:
....
I decide in my code 250~500 transactions with better fees and ~2500 with small fees and get ~4000transactions and try mine block. I think lucky your transaction faill
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
You can have your own mempool on your home machine. No one can block you in localhost. You can only DDoS Clearnet and Tor network.
I've already tweaked the number of connections a node can make.
I've already tweaked the number of connections a node can make.
So you've setup your own Bitcoin node, have 5 computers, are worried about how many seconds of advantage you have and how many IPs to use to not get blocked, use your own mempool, and after all of this struggle you still invoke some 3rd party process to create and send your faith-based bumped-up TX consisting of a few hundred bytes? Jesus.
At least my excuse was that I was out of electricity last night. Bot was running for days. Bad luck.
No one needs some gigantic setup to run a bot. 400 lines of Python and a working kangaroo binary is enough.
Good.
My script is wrong, it's returning "balance error".
My setup it's just my keyhunt on WSL, and my python loopping.. I'll fix that up and made some tests...
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Maybe it's mind game, all bot busy for find test , and newly bots maybe also block by ping many times, and in background they play real 66 bit puzzle transaction 
A professional bot definitely does not use mempool.space or similar APIs. It uses its own node, so blocking is only for inexperienced bots that use third-party APIs.You actually need full-node distro. And mempool in local network .You should use a separate machine just for that, and another very powerful machine for the Bot and BSGS/Keyhunt.
So, how many machines you have ?
Five just in my room.
What you talking about? I do it with just my Ryzen 9 3900x with VMs when needed.
I have UmbrelOS with a node and mempool on a separate machine, which can be a NUC or any small PC (with 1TB drive for node). I don't want to waste RAM with VMs on a machine with a BSGS server.
So, you host entire Bitcoin blocks—600 GB—locally?
My node have 721GB, is a VM with 4GB RAM.
It's light.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Maybe it's mind game, all bot busy for find test , and newly bots maybe also block by ping many times, and in background they play real 66 bit puzzle transaction
A professional bot definitely does not use mempool.space or similar APIs. It uses its own node, so blocking is only for inexperienced bots that use third-party APIs.You actually need full-node distro. And mempool in local network .You should use a separate machine just for that, and another very powerful machine for the Bot and BSGS/Keyhunt.
So, how many machines you have ?
Five just in my room.
What you talking about? I do it with just my Ryzen 9 3900x with VMs when needed.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I think that kangaroos that have been forked or modded from JLp's original kangaroo do not work. and I'm really asking about kangaroo running on 125 bit and above.
how do you know it doesn't work? in this last one there is no number 125 in the code. it's all 256...there is NO way to prove it doesn't work because it's impossible to solve puzzle 130.
So how do you know if it's working? Do you have proof?
Many people claim that they forked and modified the original JPL kangaroo 125-bit program and created new 256-bit kangaroo programs. So do these work? What happens if there is a code error? What if it was created incorrectly?
How would you feel if, after using it for months, someone told you that the program didn't really work?
Let me give an example: the keyhunt bsgs program definitely works.
So, is there anyone who has used the modded kangaroo program and can say this?
What you mean "works"?
How do YOU know keyhuntbsgs works?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Is there a new kangaroo program that actually works?
The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
Did you actually searched for one and nothing came up? You can use nomachine's Rust Kangaroo a few posts back, or write a Python script that does the job according to your requirements (e.g. "that actually works").The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
Too slow? Well, don't expect to find something that "actually works", is fast, and solves 130, sitting out there for you to snug up and inherit 13 BTC tomorrow.
My best (private) CUDA kangaroo is a few times faster than any JLP-based clone, and even so I still estimate the cost to break #130 around at least $100.000 with 6 months of processing on top-end Nvidia GPU renting, and this only to collect the DPs (e.g. ~2**65 group operations). It's by no means easy to write and optimize something like this, it requires a lot of time investigating resource limits and algorithmic bottlenecks to squeeze out close to 100% CUDA peak performance. If I break 130 I will publish the stuff on GitHub, until then I'm done with giving out clues about how I achieved these performance improvements. The only thing that can beat this would be a FPGA with lots of transistors.
I think you misunderstood the situation very much. I think that kangaroos that have been forked or modded from JLp's original kangaroo do not work. and I'm really asking about kangaroo running on 125 bit and above.
Think of a program that you have been running for months, but you have actually run it in vain due to code errors. How would you feel in this situation?
For example, the keyhunt bsgs program is a program that definitely works.
For example, Jlp kangaroo original version 125 works, it definitely works.
What I want is a perfectly updated kangaroo with no bugs.
But if you want to know if one program really works, just choose a private key in 130bits range, get the public key and run the program against that.. you will know if it works or not.
No, you are wrong, the 130 bits here are not the puzzle itself. 130 bits here is the scan width.
I'm not talking about Puzzle 130, choosing two spaces, scanning and finding it.
In JPL's original kangaroo program, the scanning width is limited to 125 bits. But it can even find 256 bit wallets.
I know about 130bits, and you know what i mean.
But sorry, I'don't get what you asking for, so.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Is there a new kangaroo program that actually works?
The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
Did you actually searched for one and nothing came up? You can use nomachine's Rust Kangaroo a few posts back, or write a Python script that does the job according to your requirements (e.g. "that actually works").The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
Too slow? Well, don't expect to find something that "actually works", is fast, and solves 130, sitting out there for you to snug up and inherit 13 BTC tomorrow.
My best (private) CUDA kangaroo is a few times faster than any JLP-based clone, and even so I still estimate the cost to break #130 around at least $100.000 with 6 months of processing on top-end Nvidia GPU renting, and this only to collect the DPs (e.g. ~2**65 group operations). It's by no means easy to write and optimize something like this, it requires a lot of time investigating resource limits and algorithmic bottlenecks to squeeze out close to 100% CUDA peak performance. If I break 130 I will publish the stuff on GitHub, until then I'm done with giving out clues about how I achieved these performance improvements. The only thing that can beat this would be a FPGA with lots of transistors.
I think you misunderstood the situation very much. I think that kangaroos that have been forked or modded from JLp's original kangaroo do not work. and I'm really asking about kangaroo running on 125 bit and above.
Think of a program that you have been running for months, but you have actually run it in vain due to code errors. How would you feel in this situation?
For example, the keyhunt bsgs program is a program that definitely works.
For example, Jlp kangaroo original version 125 works, it definitely works.
What I want is a perfectly updated kangaroo with no bugs.
But if you want to know if one program really works, just choose a private key in 130bits range, get the public key and run the program against that.. you will know if it works or not.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Is there a new kangaroo program that actually works?
The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
Did you actually searched for one and nothing came up? You can use nomachine's Rust Kangaroo a few posts back, or write a Python script that does the job according to your requirements (e.g. "that actually works").The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
Too slow? Well, don't expect to find something that "actually works", is fast, and solves 130, sitting out there for you to snug up and inherit 13 BTC tomorrow.
My best (private) CUDA kangaroo is a few times faster than any JLP-based clone, and even so I still estimate the cost to break #130 around at least $100.000 with 6 months of processing on top-end Nvidia GPU renting, and this only to collect the DPs (e.g. ~2**65 group operations). It's by no means easy to write and optimize something like this, it requires a lot of time investigating resource limits and algorithmic bottlenecks to squeeze out close to 100% CUDA peak performance. If I break 130 I will publish the stuff on GitHub, until then I'm done with giving out clues about how I achieved these performance improvements. The only thing that can beat this would be a FPGA with lots of transistors.
What is yours private tool benchmark?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Is there a new kangaroo program that actually works?
The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
The original is limited to 125 bits. Other modded kangaroos are mostly not working.
Is there a kangaroo that works for sure that we can use for puzzle 130 and above?
https://github.com/mikorist/Kangaroo-256-bit
he asked for a kangaroo program that actually works
Hahhahaha
Very good.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I understand about the probability, but you all say about that method how it's exactly, sure works. .. "in X seconds, the 66 will be cracked", "in Y seconds, the 67 will be cracked", and also I thought that method, bsgs, and this software was publicly on github, after all the method is known.
But thank you.
On a better CPU, 66 can be solved in X seconds on a kangaroo. There's no need to buy a fancy GPU for the bot.
Yes, but I saying about 130 and higher.. but ok.
I get It.