Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 112. (Read 215611 times)

1443055276A7E82809D3E6A908BF7526FB1117F982B80ECFA63C69D55521D420
13KV6Z8vFfLb2CTe5AVCtgED3LsUrcw7H4
1Bkv3sr5gbyWqBoTBRHQZ2T9tmmRugxi5Y
3GVGg5M8W1QLeCJmCZT1329XiSQ34oRFke
D442ECB8C5586A74BF5D759A7461C829BEC147A7F12C6471435D7DFCAFF397B0
16DjFiGAo5QDsP6CALUfnYRAbH3pGHMKsT
1PRrbzwby5HBw9fWzSiNRVkug5GMiq58q3
3FgrzeQf2wWLm6icnQUQVAi3NAAUS843qd
0D7428579AA850FB8D9C0A6DFE2937AAD69B8C82698E67EFF37ABB835E0849CF
1L86hRDF4JYKFqh29chG6GEYQ1P1dPYzwu
1BcjcHaghdaNER3YMXzBFhPfeZrKEnQLQq
34GwRv3Tdn76SkdJCnZpVnKy5RZPXu5TxQ
1C2CCAF7CE9D7CAAF35D56B6AE24413F00B61E47A238A92591B22516EB1090D5
13JZKYbcLsqBRfcqVHLBgfkoM8ua3bFQck
1AJLoZGPK9h6Wiz6jK1EJU8VJ4hHA74gaR
31tVk4AUuuXuonYBpFjLuWJ5PndWwqLuJk
2F159321E656202AA6D615F8350E150FBE8E8386097305D57CA3824BBFAA95B2
1LBzzam2ARkfs5Uk1169taTcGDA9FGGXLi
1Np75PFcPD2ZEfpH6CGWvpJysUg3zC343j
33FpvbYDHszEupihAdewpY6Tooxpa1bYus

//is Y odd or even ?
//int qy0x = 0;
//if (qy[0] % 2) { qy0x = 1; };

//int qy1x = 0;
//if (qy2[0] % 2) { qy1x = 1; };

//int qy2x = 0;
//if (qy3[0] % 2) { qy2x = 1; };

            //we take the result and calculate hash160
            // changes 1
            // uint8_t isOdd = (uint8_t)(py[0] & 1) // bit operations are enclosed in parentheses
            _GetHash160Comp(qx, (uint8_t)(qy[0] & 1), hash160);// _GetHash160Comp(qx, (uint8_t)(qy0x), hash160);
            _GetHash160Comp(qx2, (uint8_t)(qy2[0] & 1), hash1602);// _GetHash160Comp(qx2, (uint8_t)(qy1x), hash1602);
            _GetHash160Comp(qx3, (uint8_t)(qy3[0] & 1), hash1603);// _GetHash160Comp(qx3, (uint8_t)(qy2x), hash1603);

#include 
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include 
#include 
#include 
#include 

#include 

#include 
#include 
#include 
#include 

   
#include "Vanity.h"
#include "Base58.h"
#include "Bech32.h"
#include "hash/sha256.h"
#include "hash/sha512.h"
#include "IntGroup.h"
#include "Wildcard.h"
#include "Timer.h"
#include "hash/ripemd160.h"
#include 
#include 
#include "SECP256K1.cpp"

#include "GPUGroup.h"
#include "GPUMath.h"
#include "GPUHash.h"
#include "GPUBase58.h"
#include "GPUWildcard.h"
#include "GPUCompute.h"
#include "GPUEngine.h"
  
#define BLOCKS 256
#define THREADS_PER_BLOCK 256
     


__device__ unsigned long long int totThr2 = 0;

__global__ void keyFinderKernel(uint8_t* gTableXCPU, uint8_t* gTableYCPU)
{

//we use atomicadd to verify how many threads are alive, this number is used to define the starting and end ranges for each thread   
atomicAdd(&totThr2, 1);

   //how many threads ?
    __int128_t index = blockIdx.x * blockDim.x + threadIdx.x;
    
	//initial definitions, change your search ranges here. here we are searching for #20
    __int128_t start = 0xD0000;
    __int128_t end =   0xDFFFF;
    __int128_t range =  end - start;
    __int128_t rangeend;
    __int128_t rangestart;

     //calculate the range for each thread	
     rangeend =  (((range / (totThr2 * 1)) * (index + 1)) + start);
     rangestart = (((range / (totThr2 * 1)) * index) + start);
	 
 
//some hashes to search, comment the actual line and uncomment the hash you need to search, don't forget to change start and end ranges above. in this case whe are searching for #20

//     uint8_t aa[20] = { 0x95, 0xa1, 0x56, 0xcd, 0x21, 0xb4, 0xa6, 0x9d, 0xe9, 0x69, 0xeb, 0x67, 0x16, 0x86, 0x4f, 0x4c, 0x8b, 0x82, 0xa8, 0x2a }; //address HASH160 40 bit 
//   uint8_t aa[20] = { 0x68, 0x13, 0x3e, 0x19, 0xb2, 0xdf, 0xb9, 0x03, 0x4e, 0xdf, 0x98, 0x30, 0xa2, 0x00, 0xcf, 0xdf, 0x38, 0xc9, 0x0c, 0xbd }; //address HASH160 61 bit
 //  uint8_t aa[20] = { 0x9a, 0x01, 0x22, 0x60, 0xd0, 0x1c, 0x51, 0x13, 0xdf, 0x66, 0xc8, 0xa8, 0x43, 0x8c, 0x9f, 0x7a, 0x1e, 0x3d, 0x5d, 0xac }; //address HASH160 46 bit
 //  uint8_t aa[20] = { 0x36, 0xaf, 0x65, 0x9e, 0xdb, 0xe9, 0x44, 0x53, 0xf6, 0x34, 0x4e, 0x92, 0x0d, 0x14, 0x3f, 0x17, 0x78, 0x65, 0x3a, 0xe7 }; //address HASH160 52 bit    
//   uint8_t aa[20] = { 0xf0, 0x22, 0x5b, 0xfc, 0x68, 0xa6, 0xe1, 0x7e, 0x87, 0xcd, 0x8b, 0x5e, 0x60, 0xae, 0x3b, 0xe1, 0x8f, 0x12, 0x07, 0x53 }; //address HASH160 45 bit    
//   uint8_t aa[20] = { 0xd1, 0x56, 0x2e, 0xb3, 0x73, 0x57, 0xf9, 0xe6, 0xfc, 0x41, 0xcb, 0x23, 0x59, 0xf4, 0xd3, 0xed, 0xa4, 0x03, 0x23, 0x29 }; //address HASH160 41 bit
//   uint8_t aa[20] = { 0xf6, 0xd6, 0x7d, 0x79, 0x83, 0xbf, 0x70, 0x45, 0x0f, 0x29, 0x5c, 0x9c, 0xb8, 0x28, 0xda, 0xab, 0x26, 0x5f, 0x1b, 0xfa }; //address HASH160 35 bit
//   uint8_t aa[20] = { 0xd3, 0x9c, 0x47, 0x04, 0x66, 0x4e, 0x1d, 0xeb, 0x76, 0xc9, 0x33, 0x1e, 0x63, 0x75, 0x64, 0xc2, 0x57, 0xd6, 0x8a, 0x08 }; //address HASH160 30 bit

    uint8_t aa[20] = { 0xb9, 0x07, 0xc3, 0xa2, 0xa3, 0xb2, 0x77, 0x89, 0xdf, 0xb5, 0x09, 0xb7, 0x30, 0xdd, 0x47, 0x70, 0x3c, 0x27, 0x28, 0x68 }; //address HASH160 20 bit
	 
//   uint8_t aa[20] = { 0x20, 0xd4, 0x5a, 0x6a, 0x76, 0x25, 0x35, 0x70, 0x0c, 0xe9, 0xe0, 0xb2, 0x16, 0xe3, 0x19, 0x94, 0x33, 0x5d, 0xb8, 0xa5 }; //address HASH160 66 bit
//   uint8_t aa[20] = { 0x73, 0x94, 0x37, 0xbb, 0x3d, 0xd6, 0xd1, 0x98, 0x3e, 0x66, 0x62, 0x9c, 0x5f, 0x08, 0xc7, 0x0e, 0x52, 0x76, 0x93, 0x71 }; //address HASH160 67 bit
//   uint8_t aa[20] = { 0xe0, 0xb8, 0xa2, 0xba, 0xee, 0x1b, 0x77, 0xfc, 0x70, 0x34, 0x55, 0xf3, 0x9d, 0x51, 0x47, 0x74, 0x51, 0xfc, 0x8c, 0xfc }; //address HASH160 68 bit 
//   uint8_t aa[20] = { 0x95, 0xa1, 0x56, 0xcd, 0x21, 0xb4, 0xa6, 0x9d, 0xe9, 0x69, 0xeb, 0x67, 0x16, 0x86, 0x4f, 0x4c, 0x8b, 0x82, 0xa8, 0x2a }; //address HASH160 40 bit 
//	 uint8_t aa[20] = { 0x52, 0xe7, 0x63, 0xa7, 0xdd, 0xc1, 0xaa, 0x4f, 0xa8, 0x11, 0x57, 0x8c, 0x49, 0x1c, 0x1b, 0xc7, 0xfd, 0x57, 0x01, 0x37 }; //address HASH160 65 bit 
	
	
	//we will take and compare only the last 8 bytes of hash160
	
    uint64_t hash160Last8Bytesa;
    uint64_t hash160Last8Bytesb;
    uint64_t hash160Last8Bytesb2;
    uint64_t hash160Last8Bytesb3;
 	
    GET_HASH_LAST_8_BYTES(hash160Last8Bytesa, aa);
	
	uint64_t x,y,x1,y1,x2,y2;
	
//the loop, we will test 3 variations of the key (x, x+1, x-1)
while (true) {
    __int128_t ii;
	
    for (ii = rangestart; ii < rangeend; ii++) {

  uint64_t  qx[4]= { 0x000000000000000, 0x000000000000000,0x000000000000000,0x000000000000000 };
  uint64_t  qy[4]= { 0x000000000000000, 0x000000000000000,0x000000000000000,0x000000000000000 };

  uint64_t   qx2[4]= { 0x000000000000000, 0x000000000000000,0x000000000000000,0x000000000000000 };
  uint64_t   qy2[4]= { 0x000000000000000, 0x000000000000000,0x000000000000000,0x000000000000000 };
 
  uint64_t  qx3[4]= { 0x000000000000000, 0x000000000000000,0x000000000000000,0x000000000000000 };
  uint64_t   qy3[4]= { 0x000000000000000, 0x000000000000000,0x000000000000000,0x000000000000000 };

//empty the actual hash160 bytes
    uint64_t hash160Last8Bytesb = 0;
    uint64_t hash160Last8Bytesb2 = 0;
    uint64_t hash160Last8Bytesb3 = 0;
	
//we take the 128 bit integer and split it in two 64 bit numbers to work with uint64 array
y = static_cast(ii >> 64);
x = static_cast(ii);

y1 = y;
x1 = x + 1;

y2 = y;
x2 = x - 1;

          //the priv keys
          uint64_t curi1[4] = { x, y, 0x000000000000000, 0x000000000000000 };
          uint64_t curi2[4] = { x1, y1, 0x000000000000000, 0x000000000000000 };
          uint64_t curi3[4] = { x2, y2, 0x000000000000000, 0x000000000000000 };

            //we take the array and turn into uint16 to work with point multiplication
            uint16_t* pv = (uint16_t*)(&curi1);
            uint16_t* pv1 = (uint16_t*)(&curi2);
            uint16_t* pv2 = (uint16_t*)(&curi3);
			
			//point multiplication, we take the integer and multiply by G 
            _PointMultiSecp256k1(qx, qy, pv, gTableXCPU, gTableYCPU);
            _PointMultiSecp256k1(qx2, qy2, pv1, gTableXCPU, gTableYCPU);
            _PointMultiSecp256k1(qx3, qy3, pv2, gTableXCPU, gTableYCPU);

			uint8_t hash160[SIZE_HASH160];
            uint8_t hash1602[SIZE_HASH160];
            uint8_t hash1603[SIZE_HASH160];
			
//is Y odd or even ?
int qy0x = 0;
if (qy[0] % 2) { qy0x = 1; };

int qy1x = 0;
if (qy2[0] % 2) { qy1x = 1; };

int qy2x = 0;
if (qy3[0] % 2) { qy2x = 1; };

            //we take the result and calculate hash160
            _GetHash160Comp(qx, (uint8_t)(qy0x), hash160);
            _GetHash160Comp(qx2, (uint8_t)(qy1x), hash1602);
            _GetHash160Comp(qx3, (uint8_t)(qy2x), hash1603);

            //last 8 bytes
            GET_HASH_LAST_8_BYTES(hash160Last8Bytesb, hash160);
            GET_HASH_LAST_8_BYTES(hash160Last8Bytesb2, hash1602);
            GET_HASH_LAST_8_BYTES(hash160Last8Bytesb3, hash1603);

            //and finally we compare with our hash160, if found the program stops
			
            if (hash160Last8Bytesb == hash160Last8Bytesa) {
                uint64_t xx;
                char foo[20];
                printf("FOUND PRIVKEY 0x%" PRIx64 " 0x%" PRIx64 " 0x % " PRIx64 " \n", (uint64_t)curi1[2], (uint64_t)curi1[1], (uint64_t)curi1[0]);
                asm("trap;");
            }
			
            if (hash160Last8Bytesb2 == hash160Last8Bytesa) {
                uint64_t xx;
                char foo[20];
                printf("FOUND PRIVKEY 0x%" PRIx64 " 0x%" PRIx64 " 0x % " PRIx64 " \n", (uint64_t)curi2[2], (uint64_t)curi2[1], (uint64_t)curi2[0]);
                asm("trap;");
            }

            if (hash160Last8Bytesb3 == hash160Last8Bytesa) {
                uint64_t xx;
                char foo[20];
                printf("FOUND PRIVKEY 0x%" PRIx64 " 0x%" PRIx64 " 0x % " PRIx64 " \n", (uint64_t)curi3[2], (uint64_t)curi3[1], (uint64_t)curi3[0]);
                asm("trap;");
            }


    }
}
            }

#define NUM_GTABLE_CHUNK 16    // Number of GTable chunks that are pre-computed and stored in global memory
#define NUM_GTABLE_VALUE 65536 // Number of GTable values per chunk (all possible states) (2 ^ NUM_GTABLE_CHUNK)
#define SIZE_GTABLE_POINT 32   // Each Point in GTable consists of two 32-byte coordinates (X and Y)
#define COUNT_GTABLE_POINTS (NUM_GTABLE_CHUNK * NUM_GTABLE_VALUE)

void loadGTable(uint8_t* gTableX, uint8_t* gTableY) {
    std::cout << "loadGTable started" << std::endl;
   
    Secp256K1 *secp = new Secp256K1();
    secp->Init2(); 
   
    for (int i = 0; i < NUM_GTABLE_CHUNK; i++)
    {
        for (int j = 0; j < NUM_GTABLE_VALUE - 1; j++)
        {
            int element = (i * NUM_GTABLE_VALUE) + j;
            Point p = secp->GTable2[element];
            for (int b = 0; b < 32; b++) {
                gTableX[(element * SIZE_GTABLE_POINT) + b] = p.x.GetByte64(b);
                gTableY[(element * SIZE_GTABLE_POINT) + b] = p.y.GetByte64(b);
            }
        }
    }

    std::cout << "loadGTable finished!" << std::endl;
}
int main()
{
    printf("MoonWalker YABF v0.2 beta\n");
  curandState *d_state;
  cudaMalloc(&d_state, sizeof(curandState));

    uint8_t* gTableXCPU = new uint8_t[COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT];
    uint8_t* gTableYCPU = new uint8_t[COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT];
    uint8_t* gTableXGPU;
    uint8_t* gTableYGPU;
    loadGTable(gTableXCPU, gTableYCPU);


   printf("Allocating gTableX \n");
   
    cudaMalloc((void**)&gTableXGPU, COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT);
    cudaMemset(gTableXGPU, 0, COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT);
    cudaMemcpy(gTableXGPU, gTableXCPU, COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT, cudaMemcpyHostToDevice);
    printf("Allocating gTableY \n");
    cudaMalloc((void**)&gTableYGPU, COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT);
    cudaMemset(gTableYGPU, 0, COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT);
    cudaMemcpy(gTableYGPU, gTableYCPU, COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT, cudaMemcpyHostToDevice);
	
     printf("Go ! \n");
	 
    keyFinderKernel << > > (gTableXGPU, gTableYGPU);
	
cudaError_t errSync  = cudaGetLastError();
cudaError_t errAsync = cudaDeviceSynchronize();
if (errSync != cudaSuccess) 
  printf("Sync kernel error: %s\n", cudaGetErrorString(errSync));
if (errAsync != cudaSuccess)
  printf("Async kernel error: %s\n", cudaGetErrorString(errAsync));

}

MoonWalker YABF v0.2 beta
loadGTable started
loadGTable finished!
Allocating gTableX
Allocating gTableY
Go !
FOUND PRIVKEY 0x0 0x0 0x d2c55

make

./clock 

import multiprocessing
import base58
import secrets
from bitcoin import * # from bitcoin import privtopub, pubtoaddr

def vint():
    puzzle_66 = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"
    btc = ""
    base58Str = "" # ?
    pubKey = "" # ?

    while btc != puzzle_66: #while btc[:len(puzzle_66)] != puzzle_66:
        alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
        untext = "".join(secrets.choice(alphabet) for i in range (11))
        #text = '11111111111111111111111' + 'C' + untext                  #23 1's  'C' is the parameter you can change.
        text =  '11111111111111111111111' + '3' + untext
        base58Str = base58.b58decode(text).hex()
        pubKey = privtopub(base58Str)
        pubKey = encode_pubkey(pubKey, 'hex_compressed') # !!!!!!!! ADD THE !!!!!!!!
        btc = pubtoaddr(pubKey)
        #print (base58Str)
        #print (btc)
        #print (btc[:len(puzzle_66)])
        print (pubKey)
    
    f = open("keys.txt", "a")
    f.write(base58Str + "\n")
    f.close()
    b = open("btc.txt", "a")
    b.write(btc + "\n")
    b.close()

    print(base58Str)
    print(pubKey)
    print(btc)


if __name__ == '__main__':
    
    th = 2
    processes = []
    for _ in range(th):
        p1 = multiprocessing.Process(target=vint)
        p1.start()
        processes.append(p1)
        print ('Start thread: ', _)
    for process in processes:
        process.join()
    

import secp256k1 as ice

#1361129467683753853853498429727072845823
       #100000000000000000000000000000000

target_public_key = "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"
target = ice.pub2upub(target_public_key)
num = 13611294 # number of times.
sustract= 100000000000000000000000000000000 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= (res[t*65:t*65+65]).hex()
    hc= ice.to_cpub(h)
    data = open("data-base.txt","a")
    data.write(str(hc)+"\n")
    data.close()