Bitcoin Forum

1971 	1974 	         pchMessageStart[1] = 0xc1;
1972 	1975 	         pchMessageStart[2] = 0xb7;
1973 	1976 	         pchMessageStart[3] = 0xdc;
1974 	  	-        hashGenesisBlock = uint256("0xf5ae71e26c74beacc88382716aced69cddf3dffff24f384e1808905e0188f68f");
  	1977 	+        hashGenesisBlock = uint256("0xa50faf35e1dddf4a076a907fbcef6d9d1595390cdb1c818a35dae53b67ad0aa8"); 

1992 	  	-
1993 	  	-        // Genesis Block:
1994 	  	-        // CBlock(hash=12a765e31ffd4059bada, PoW=0000050c34a64b415b6b, ver=1, hashPrevBlock=00000000000000000000, hashMerkleRoot=97ddfbbae6, nTime=1317972665, nBits=1e0ffff0, nNonce=2084524493, vtx=1)
1995 	  	-        //   CTransaction(hash=97ddfbbae6, ver=1, vin.size=1, vout.size=1, nLockTime=0)
1996 	  	-        //     CTxIn(COutPoint(0000000000, -1), coinbase 04ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536)
1997 	  	-        //     CTxOut(nValue=50.00000000, scriptPubKey=040184710fa689ad5023690c80f3a4)
1998 	  	-        //   vMerkleTree: 97ddfbbae6
1999 	  	-
  	1995 	+    
  	1996 	+  // Genesis block:
  	1997 	+  // block.nTime = 1366559428 
  	1998 	+  // block.nNonce = 2085386442 
  	1999 	+  // block.GetHash = 384b060671f4a93948e9c168216dadb0ca2fbc54aa11c86b0345b6af1c59b2f5
  	2000 	+  // CBlock(hash=384b060671f4a93948e9, PoW=00000951e146b0026411, ver=1,
  	2001 	+  //  hashPrevBlock=00000000000000000000, hashMerkleRoot=5a2e19825b,
  	2002 	+  //  nTime=1366559428, nBits=1e0ffff0, nNonce=2085386442, vtx=1)
  	2003 	+  // CTransaction(hash=5a2e19825b, ver=1, vin.size=1, vout.size=1, nLockTime=0)
  	2004 	+  // CTxIn(COutPoint(0000000000, -1), coinbase 04ffff001d010441746f646f3a207265706c616365207769746820736f6d657468696e67207468617420656e7375726573206e6f207072656d696e696e6720746f6f6b20706c616365)
  	2005 	+  // CTxOut(error)
  	2006 	+  // vMerkleTree: 5a2e19825b
  	2007 	+         

  // Genesis block
-        const char* pszTimestamp = "NY Times 05/Oct/2011 Steve Jobs, Apple’s Visionary, Dies at 56";
+        const char* pszTimestamp = "todo: replace with something that ensures no premining took place";
         CTransaction txNew;
         txNew.vin.resize(1);
         txNew.vout.resize(1);
         txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
-        txNew.vout[0].nValue = 50 * COIN;
-        txNew.vout[0].scriptPubKey = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
+        txNew.vout[0].nValue = 0;
+        txNew.vout[0].scriptPubKey = CScript() << 0x0 << OP_CHECKSIG; // a privkey for that 'vanity' pubkey would be interesting ;) 

2013 	  	-        block.nTime    = 1317972665;
  	2021 	+        block.nTime    = 1366559428;
2014 	2022 	         block.nBits    = 0x1e0ffff0;
2015 	  	-        block.nNonce   = 2084524493;
  	2023 	+        block.nNonce   = 2085386442;
2016 	2024 	 
2017 	2025 	         if (fTestNet)
2018 	2026 	         {
2019 	  	-            block.nTime    = 1317798646;
2020 	  	-            block.nNonce   = 385270584;
  	2027 	+            block.nTime    = 1366559428;
  	2028 	+            block.nNonce   = 386402991;
2021 	2029 	         }
2022 	2030 	 
2023 	2031 	         //// debug print
2024 	2032 	         printf("%s\n", block.GetHash().ToString().c_str());
2025 	2033 	         printf("%s\n", hashGenesisBlock.ToString().c_str());
2026 	2034 	         printf("%s\n", block.hashMerkleRoot.ToString().c_str());
2027 	  	-        assert(block.hashMerkleRoot == uint256("0x97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9"));
  	2035 	+        assert(block.hashMerkleRoot == uint256("0x5a2e19825b4162f68602039040f1e05d9f924ff00a3aff7327ca6abd6f3279bc"));
2028 	2036 	  

b115383690ee67ebeef9a7e754342638cd7bbf488561998e6d1bc1ed367484f6 // Block derived from pszTimestamp
b8fa883689f099d3942ff73439d9f55d60a5e257b0d69a8f0f6ab4572ecff415 // Genesisblock (invalid cuz its already coded wrong)
bd58bf217abb76059de07dc519f6c3dcdf5b1a7bb9219a66d24205e08f3716f9 // MerkleRoot (Valid because its newly calculated

        //// debug print
        printf("%s\n", block.GetHash().ToString().c_str());
        printf("%s\n", hashGenesisBlock.ToString().c_str());
        printf("%s\n", block.hashMerkleRoot.ToString().c_str());
        assert(block.hashMerkleRoot == uint256("0xbd58bf217abb76059de07dc519f6c3dcdf5b1a7bb9219a66d24205e08f3716f9"));

        // If genesis block hash does not match, then generate new genesis hash.
        if (true && block.GetHash() != hashGenesisBlock)

nonce 003C1000: hash = e8525d8ae8a74a33dbc4b06a64c97ced84dfd29628b3e9e4197c7030cc4a09d3 (target = 00000ffff0000000000000000000000000000000000000000000000000000000)
block.nTime = 1367704866
block.nNonce = 3939341
block.GetHash = fafdbfc957ea6867a0743ff80c4ae126c7dd9fa82057255228a4d58f6ccfdf33
CBlock(hash=fafdbfc957ea6867a074, PoW=000000b1398554a520b5, ver=1, hashPrevBlock=00000000000000000000, hashMerkleRoot=bd58bf217a, nTime=1367704866, nBits=1e0ffff0, nNonce=3939341, vtx=1)
  CTransaction(hash=bd58bf217a, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000, -1), coinbase 04ffff001d01043741442e6e6c20342f352042657672696a64696e6773646167207a6f6e6e69672c20646161726e61206f6f6b207a6f6d657273207761726d)
    CTxOut(error)
  vMerkleTree: bd58bf217a
xx: main.cpp:2070: bool LoadBlockIndex(bool): Assertion `block.GetHash() == hashGenesisBlock' failed.
Aborted (core dumped)

        CTransaction txNew;
        txNew.vin.resize(1);
        txNew.vout.resize(1);
        txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
        txNew.vout[0].nValue = 50 * COIN;
        txNew.vout[0].scriptPubKey = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
        CBlock block;

        CTransaction txNew;
        txNew.vin.resize(1);
        txNew.vout.resize(1);
        txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
        txNew.vout[0].nValue = 0;
        txNew.vout[0].scriptPubKey = CScript() << 0x0 << OP_CHECKSIG; // a privkey for that 'vanity' pubkey would be interesting ;)

CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;

    "tx" : [
        "d966cccce1ccfab008bac6ab9ef6c4c223b77847fb6924d837639997ef21d29f"
    ],

hashMerkleRoot=d966cccce1, nTime=1367758074, nBits=1e0ffff0, nNonce=924421, vtx=1)
  CTransaction(hash=d966cccce1, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000, -1), coinbase 04ffff001d01043d6e7974696d657320352d35204f66662d7468652d43756666204f62616d61204c696e652050757420552e532e20696e2042696e64206f6e205379726961)
    CTxOut(error)

error: {"code":-5,"message":"No information available about transaction"}

txNew.vout[0].scriptPubKey = CScript() << 0x0 << OP_CHECKSIG;

txNew.vout[0].scriptPubKey 

1 - Take a private key 
   0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D
2 - Add a 0x80 byte in front of it 
   800C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D
3 - Perform SHA-256 hash on the extended key 
   8147786C4D15106333BF278D71DADAF1079EF2D2440A4DDE37D747DED5403592
4 - Perform SHA-256 hash on result of SHA-256 hash 
   507A5B8DFED0FC6FE8801743720CEDEC06AA5C6FCA72B07C49964492FB98A714
5 - Take the first 4 bytes of the second SHA-256 hash, this is the checksum 
   507A5B8D
6 - Add the 4 checksum bytes from point 5 at the end of the extended key from point 2 
   800C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D507A5B8D
7 - Convert the result from a byte string into a base58 string using Base58Check encoding. This is the Wallet Import Format 
   5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ

import hashlib, binascii

t='123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

def numtowif(numpriv):
 # for bitcoin (80=128)
 # for testcoin (EF==239 == testnet)
 step1 = 'EF'+hex(numpriv)[2:].strip('L').zfill(64)
 step2 = hashlib.sha256(binascii.unhexlify(step1)).hexdigest()
 step3 = hashlib.sha256(binascii.unhexlify(step2)).hexdigest()
 step4 = int(step1 + step3[:8] , 16)
 return ''.join([t[step4/(58**l)%58] for l in range(100)])[::-1].lstrip('1')

def wiftonum(wifpriv):
 return sum([t.index(wifpriv[::-1][l])*(58**l) for l in range(len(wifpriv))])/(2**32)%(2**256)

def validwif(wifpriv):
 return numtowif(wiftonum(wifpriv))==wifpriv

def pubtoaddr(numpub):
 pubkey1=hex(numpub)[2:].strip('L').zfill(130)
 #print pubkey1
 pubkey2=hashlib.sha256(binascii.unhexlify(pubkey1)).hexdigest()
 #print pubkey2
 pubkey3=hashlib.new('ripemd160',binascii.unhexlify(pubkey2)).hexdigest()
 #print pubkey3
 # for bitcoin (0)
 #pubkey3b='00'+pubkey3
 # for testcoin (111)
 pubkey3b='6f'+pubkey3
 #print pubkey3b
 pubkey4=hashlib.sha256(binascii.unhexlify(pubkey3b)).hexdigest()
 #pubkey4=hashlib.sha256(binascii.unhexlify(pubkey3b)).hexdigest()
 #print pubkey4
 pubkey5=hashlib.sha256(binascii.unhexlify(pubkey4)).hexdigest()
 #print pubkey5
 pubkey5a=pubkey5[:8]
 #print pubkey5a
 pubkey6=pubkey3b+pubkey5a
 #print pubkey6
 #print pubkey6[:2]
 pubnum=int(pubkey6,16)
 #print pubnum
 pubnumlist=[]
 while pubnum!=0: pubnumlist.append(pubnum%58); pubnum/=58
 address=''
 for l in ['123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'[x] for x in pubnumlist]:
  address=l+address
 if pubkey6[:2]=='00':
  address='1'+address
 return address

print "wallet import format"
print numtowif(0x5e4a8229e81a434b0646dcdbeb4b03083e2bd05af26fcf2e4e4aa37eacb2913b)
print "wallet public address"
print pubtoaddr(0x04580e17442b4465fbf1eb8a039855343739f69f83222c3c6590c219dcd2d883bff96ebf6198ddb9a75baffffbc1be62f05261d7dfec58d8a06cf3809c6cefe620)

#!/usr/bin/env python
"""
Generate an ECDSA keypair and Bitcoin-compatible payment address.
Requires Brian Warner's excellent python-ecdsa library.


http://github.com/aristus/bitcoin-printer
"""
from ecdsa.ecdsa import Public_key, int_to_string
from ecdsa.ellipticcurve import CurveFp, Point
from binascii import hexlify
import hashlib
ripehash = hashlib.new('ripemd160')


# ***WARNING*** This is possibly insecure! ***WARNING***
from random import SystemRandom
randrange = SystemRandom().randrange


## Bitcoin has an adorable encoding scheme that includes numbers and letters
## but excludes letters which look like numbers, eg "l" and "O"
__b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
__b58base = len(__b58chars)
def b58encode(v):
  long_value = 0L
  for (i, c) in enumerate(v[::-1]):
    long_value += (256**i) * ord(c)
  result = ''
  while long_value >= __b58base:
    div, mod = divmod(long_value, __b58base)
    result = __b58chars[mod] + result
    long_value = div
  result = __b58chars[long_value] + result
  nPad = 0
  for c in v:
    if c == '\0': nPad += 1
    else: break
  return (__b58chars[0]*nPad) + result

def generate_btc_address():
    # secp256k1, not included in stock ecdsa
    _p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
    _r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
    _b = 0x0000000000000000000000000000000000000000000000000000000000000007L
    _a = 0x0000000000000000000000000000000000000000000000000000000000000000L
    _Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
    _Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L
    curve_256 = CurveFp(_p, _a, _b)
    generator = Point(curve_256, _Gx, _Gy, _r)

    secret = randrange(1, generator.order())
    pubkey = Public_key(generator, generator * secret)
    step1 = '\x04' + int_to_string(pubkey.point.x()) + \
        int_to_string(pubkey.point.y())
    step2 = hashlib.sha256(step1).digest()
    ripehash.update(step2)
    step4 = '\x00' + ripehash.digest()
    step5 = hashlib.sha256(step4).digest()
    step6 = hashlib.sha256(step5).digest()
    chksum = step6[:4]
    addr = step4 + chksum
    addr_58 = b58encode(addr)
    return (
        hex(secret)[2:-1],
        hexlify(step1),
        hexlify(addr),
        addr_58
    )


if __name__ == '__main__':
    secret, pubkey, addr, addr_58 = generate_btc_address()
    print 'secret: ', secret
    print 'pubkey: ', pubkey
    print 'address:', addr
    print 'addr_58:', addr_58

if (true && block.GetHash() != hashGenesisBlock)
            {
                  printf("Searching for genesis block...\n");
                  // This will figure out a valid hash and Nonce if you're
                  // creating a different genesis block:
                  uint256 hashTarget = CBigNum().SetCompact(block.nBits).getuint256();
                  uint256 thash;
                  char scratchpad[SCRYPT_SCRATCHPAD_SIZE];

                  loop
                  {
      #if defined(USE_SSE2)
                      // Detection would work, but in cases where we KNOW it always has SSE2,
                      // it is faster to use directly than to use a function pointer or conditional.
      #if defined(_M_X64) || defined(__x86_64__) || defined(_M_AMD64) || (defined(MAC_OSX) && defined(__i386__))
                      // Always SSE2: x86_64 or Intel MacOS X
                      scrypt_1024_1_1_256_sp_sse2(BEGIN(block.nVersion), BEGIN(thash), scratchpad);
      #else
                      // Detect SSE2: 32bit x86 Linux or Windows
                      scrypt_1024_1_1_256_sp(BEGIN(block.nVersion), BEGIN(thash), scratchpad);
      #endif
      #else
                      // Generic scrypt
                      scrypt_1024_1_1_256_sp_generic(BEGIN(block.nVersion), BEGIN(thash), scratchpad);
      #endif
                      if (thash <= hashTarget)
                          break;
                      if ((block.nNonce & 0xFFF) == 0)
                      {
                          printf("nonce %08X: hash = %s (target = %s)\n", block.nNonce, thash.ToString().c_str(), hashTarget.ToString().c_str());
                      }
                      ++block.nNonce;
                      if (block.nNonce == 0)
                      {
                          printf("NONCE WRAPPED, incrementing time\n");
                          ++block.nTime;
                      }
                  }

            printf("block.nTime = %u \n", block.nTime);
            printf("block.nNonce = %u \n", block.nNonce);
            printf("block.GetHash = %s\n", block.GetHash().ToString().c_str());


               }

http://pastebin.com/TSemSTkK

unsigned long int scrypt_scratpad_size_current_block = ((1 << (GetNfactor(pblock->nTime) + 1)) * 128 ) + 63;
            
char scratchpad[scrypt_scratpad_size_current_block];

import hashlib, binascii, struct, array, os, time, sys, optparse
import scrypt

from construct import *


def main():
  options = get_args()

  # https://en.bitcoin.it/wiki/Difficulty
  bits = get_bits(options)
  target = get_target(options)

  input_script = create_input_script(options.timestamp)
  output_script = create_output_script(options.pubkey)

  # hash merkle root is the double sha256 hash of the transaction(s)
  tx = create_transaction(input_script, output_script)
  hash_merkle_root = hashlib.sha256(hashlib.sha256(tx).digest()).digest()
  print_block_info(options, hash_merkle_root)

  block_header = create_block_header(hash_merkle_root, options.time, bits, options.nonce)
  genesis_hash, nonce = generate_hash(block_header, options.scrypt, options.nonce, target)
  announce_found_genesis(genesis_hash, nonce)


def get_args():
  parser = optparse.OptionParser()
  parser.add_option("-t", "--time", dest="time", default=int(time.time()),
                   type="int", help="the (unix) time when the genesisblock is created")
  parser.add_option("-z", "--timestamp", dest="timestamp", default="The Times 03/Jan/2009 Chancellor on brink of second bailout for banks",
                   type="string", help="the pszTimestamp found in the coinbase of the genesisblock")
  parser.add_option("-n", "--nonce", dest="nonce", default=0,
                   type="int", help="the first value of the nonce that will be incremented when searching the genesis hash")
  parser.add_option("-s", "--scrypt", dest="scrypt", default=False, action="store_true",
                    help="calculate genesis block using scrypt")
  parser.add_option("-p", "--pubkey", dest="pubkey", default="04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f",
                   type="string", help="the pubkey found in the output script")

  (options, args) = parser.parse_args()
  return options


def get_bits(options):
  return 0x1e0ffff0 if options.scrypt else 0x1d00ffff


def get_target(options):
  return 0x0ffff0 * 2**(8*(0x1e - 3)) if options.scrypt else 0x00ffff * 2**(8*(0x1d - 3))


def create_input_script(psz_timestamp):
  script_prefix = '04ffff001d0104' + chr(len(psz_timestamp)).encode('hex')
  return (script_prefix + psz_timestamp.encode('hex')).decode('hex')


def create_output_script(pubkey):
  script_len = '41'
  OP_CHECKSIG = 'ac'
  return (script_len + pubkey + OP_CHECKSIG).decode('hex')


def create_transaction(input_script, output_script):
  transaction = Struct("transaction",
    Bytes("version", 4),
    Byte("num_inputs"),
    StaticField("prev_output", 32),
    UBInt32('prev_out_idx'),
    Byte('input_script_len'),
    Bytes('input_script', len(input_script)),
    UBInt32('sequence'),
    Byte('num_outputs'),
    Bytes('out_value', 8),
    Byte('output_script_len'),
    Bytes('output_script', 0x43),
    UBInt32('locktime'))

  tx = transaction.parse('\x00'*(127 + len(input_script)))
  tx.version = struct.pack('<I', 1)
  tx.num_inputs = 1
  tx.prev_output = struct.pack('<qqqq', 0,0,0,0)
  tx.prev_out_idx = 0xFFFFFFFF
  tx.input_script_len = len(input_script)
  tx.input_script = input_script
  tx.sequence = 0xFFFFFFFF
  tx.num_outputs = 1
  tx.out_value = struct.pack('<q' ,0x000000012a05f200) #50 coins
  tx.output_script_len = 0x43
  tx.output_script = output_script
  tx.locktime = 0
  return transaction.build(tx)


def create_block_header(hash_merkle_root, time, bits, nonce):
  block_header = Struct("block_header",
    Bytes("version",4),
    Bytes("hash_prev_block", 32),
    Bytes("hash_merkle_root", 32),
    Bytes("time", 4),
    Bytes("bits", 4),
    Bytes("nonce", 4))

  genesisblock = block_header.parse('\x00'*80)
  genesisblock.version = struct.pack('<I', 1)
  genesisblock.hash_prev_block = struct.pack('<qqqq', 0,0,0,0)
  genesisblock.hash_merkle_root = hash_merkle_root
  genesisblock.time = struct.pack('<I', time)
  genesisblock.bits = struct.pack('<I', bits)
  genesisblock.nonce = struct.pack('<I', nonce)
  return block_header.build(genesisblock)


# https://en.bitcoin.it/wiki/Block_hashing_algorithm
def generate_hash(data_block, is_scrypt, start_nonce, target):
  print 'Searching for genesis hash..'
  nonce = start_nonce
  last_updated = time.time()
  difficulty = float(0xFFFF) * 2**208 / target
  update_interval = int(1000000 * difficulty)

  while True:
    sha256_hash, header_hash = generate_hashes_from_block(data_block, is_scrypt)
    last_updated = calculate_hashrate(nonce, update_interval, difficulty, last_updated)
    if is_genesis_hash(header_hash, target):
      return (sha256_hash, nonce)
    else:
     nonce = nonce + 1
     data_block = data_block[0:len(data_block) - 4] + struct.pack('<I', nonce)


def generate_hashes_from_block(data_block, is_scrypt):
  sha256_hash = hashlib.sha256(hashlib.sha256(data_block).digest()).digest()[::-1]
  header_hash = scrypt.hash(data_block,data_block,1024,1,1,32)[::-1] if is_scrypt else sha256_hash
  return sha256_hash, header_hash


def is_genesis_hash(header_hash, target):
  return int(header_hash.encode('hex_codec'), 16) < target


def calculate_hashrate(nonce, update_interval, difficulty, last_updated):
  if nonce % update_interval == update_interval - 1:
    now = time.time()
    hashrate = round(update_interval/(now - last_updated))
    generation_time = round(difficulty * pow(2, 32) / hashrate / 3600, 1)
    sys.stdout.write("\r%s hash/s, estimate: %s h"%(str(hashrate), str(generation_time)))
    sys.stdout.flush()
    return now
  else:
    return last_updated


def print_block_info(options, hash_merkle_root):
  print "algorithm: " + ("scrypt" if options.scrypt else "sha256")
  print "merkle hash: " + hash_merkle_root[::-1].encode('hex_codec')
  print "pszTimestamp: " + options.timestamp
  print "pubkey: " + options.pubkey
  print "time: " + str(options.time)
  print "bits: " + str(hex(get_bits(options)))


def announce_found_genesis(genesis_hash, nonce):
  print "genesis hash found!"
  print "nonce: " + str(nonce)
  print "genesis hash: " + genesis_hash.encode('hex_codec')


# GOGOGO!
main()

hash doesn't match nBits.

if (true && block.GetHash() != hashGenesisBlock)

if (true && block.GetHash() != hashGenesisBlock)
        {
            printf("Searching for genesis block...\n");
            uint256 hashTarget = CBigNum().SetCompact(block.nBits).getuint256();
            uint256 thash;

            loop
            {
                thash = block.GetHash();
                if (thash <= hashTarget)
                    break;
                if ((block.nNonce & 0xFFF) == 0)
                {
                    printf("nonce %08X: hash = %s (target = %s)\n", block.nNonce, thash.ToString().c_str(), hashTarget.ToString().c_str());
                }
                ++block.nNonce;
                if (block.nNonce == 0)
                {
                    printf("NONCE WRAPPED, incrementing time\n");
                    ++block.nTime;
                }
            }
            printf("block.nTime = %u \n", block.nTime);
            printf("block.nNonce = %u \n", block.nNonce);
            printf("block.nVersion = %u \n", block.nVersion);
            printf("block.GetHash = %s\n", block.GetHash().ToString().c_str());
        }
        //// debug print
        uint256 hash = block.GetHash();
        printf("%s\n", hash.ToString().c_str());
        printf("%s\n", hashGenesisBlock.ToString().c_str());
        printf("%s\n", block.hashMerkleRoot.ToString().c_str());
        assert(block.hashMerkleRoot == uint256("0x"));

              if (true &&block.GetHash() != hashGenesisBlock)
              {
                  printf("Searching for genesis block...\n");
                  // This will figure out a valid hash and Nonce if you're
                  // creating a different genesis block:
                  uint256 hashTarget = CBigNum().SetCompact(block.nBits).getuint256();
                  uint256 thash;

                  unsigned long int scrypt_scratpad_size_current_block = ((1 << (GetNfactor(block.nTime) + 1)) * 128 ) + 63;
                  char scratchpad[scrypt_scratpad_size_current_block];

                  loop
                  {
                 // Generic scrypt
                      scrypt_N_1_1_256_sp_generic(BEGIN(block.nVersion), BEGIN(thash), scratchpad, GetNfactor(block.nTime));

                      if (thash <= hashTarget)
                      {
                     printf ("found it!\n");
                          break;
                      }
                      if ((block.nNonce & 0xFFF) == 0)
                      {
                          printf("nonce %08X: hash = %s (target = %s)\n", block.nNonce, thash.ToString().c_str(), hashTarget.ToString().c_str());
                      }
                      ++block.nNonce;
                      if (block.nNonce == 0)
                      {
                          printf("NONCE WRAPPED, incrementing time\n");
                          ++block.nTime;
                      }
                  }
               }

Loading block index...
CBlock(hash=c18a2e48349763b42b90ac00881abee846203b789a2d86aacb2cd2aa5161c66f, ver=1, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000, hashMerkleRoot=25cc2e3283b86f225057d0eaa0eaa0003b891de79828f59bb4fc0b290ab897e2, nTime=1388419211, nBits=1f00ffff, nNonce=0, vtx=1, vchBlockSig=)
  Coinbase(hash=25cc2e3283, nTime=1375995262, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000, 4294967295), coinbase 04ffff001d020f272957687920776f756c6420796f75206e65656420426974207768656e20796f7520686176652053776167)
    CTxOut(empty)
  vMerkleTree: 25cc2e3283 
block.GetHash() == c18a2e48349763b42b90ac00881abee846203b789a2d86aacb2cd2aa5161c66f
block.hashMerkleRoot == 25cc2e3283b86f225057d0eaa0eaa0003b891de79828f59bb4fc0b290ab897e2
block.nTime = 1388419211 
block.nNonce = 0

        //// debug print
        uint256 hash = block.GetHash();
        printf("%s\n", hash.ToString().c_str());
        printf("%s\n", hashGenesisBlock.ToString().c_str());
        printf("%s\n", block.hashMerkleRoot.ToString().c_str());
        assert(block.hashMerkleRoot == uint256("0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7"));
        block.print();
        assert(hash == hashGenesisBlock);

Assertion `block.GetHash() == (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet)' failed.

Opened LevelDB successfully
CBlock(hash=000030b4df1fca238412d3acb536f920fb3fe4fc2b1255c40e78d54ac791e1ac, ver=1, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000,
hashMerkleRoot=00f5217426974f0aae85ef32ed69f99543993ebb8e995c4089febecd87f5e1b5, nTime=1401124588, nBits=1f00ffff, nNonce=29392, vtx=1, vchBlockSig=)
  Coinbase(hash=00f5217426, nTime=1401124588, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000, 4294967295), coinbase 00012a4154686973206973206f6e652070656173616e7473207265766f6c742074686174204272757373656c732063616e6e6f74206a757374206272757368206173696465)
    CTxOut(empty)
  vMerkleTree: 00f5217426
block.GetHash() == 000030b4df1fca238412d3acb536f920fb3fe4fc2b1255c40e78d54ac791e1ac
block.hashMerkleRoot == 00f5217426974f0aae85ef32ed69f99543993ebb8e995c4089febecd87f5e1b5
block.nTime = 1401124588
block.nNonce = 29392
CBlock(hash=000030b4df1fca238412d3acb536f920fb3fe4fc2b1255c40e78d54ac791e1ac, ver=1, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000,
hashMerkleRoot=00f5217426974f0aae85ef32ed69f99543993ebb8e995c4089febecd87f5e1b5, nTime=1401124588, nBits=1f00ffff, nNonce=29392, vtx=1, vchBlockSig=)
  Coinbase(hash=00f5217426, nTime=1401124588, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000, 4294967295), coinbase 00012a4154686973206973206f6e652070656173616e7473207265766f6c742074686174204272757373656c732063616e6e6f74206a757374206272757368206173696465)
    CTxOut(empty)
  vMerkleTree: 00f5217426

// Only add the genesis block if not reindexing (in which case we reuse the one already on disk)
    if (!fReindex) {
        // Genesis Block:
        // CBlock(hash=12a765e31ffd4059bada, PoW=0000050c34a64b415b6b, ver=1, hashPrevBlock=00000000000000000000, hashMerkleRoot=97ddfbbae6, nTime=1317972665, nBits=1e0ffff0, nNonce=2084524493, vtx=1)
        //   CTransaction(hash=97ddfbbae6, ver=1, vin.size=1, vout.size=1, nLockTime=0)
        //     CTxIn(COutPoint(0000000000, -1), coinbase 04ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536)
        //     CTxOut(nValue=50.00000000, scriptPubKey=040184710fa689ad5023690c80f3a4)
        //   vMerkleTree: 97ddfbbae6

        // Genesis block        
        const char* pszTimestamp = "Coindesk 27/May/2014 Facebook-Integrated Wallet Makes Sending Bitcoin as Easy as Messaging";
        CTransaction txNew;
        txNew.vin.resize(1);
        txNew.vout.resize(1);
        txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
        txNew.vout[0].nValue = 50 * COIN;
        txNew.vout[0].scriptPubKey = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
        CBlock block;
        block.vtx.push_back(txNew);
        block.hashPrevBlock = 0;
        block.hashMerkleRoot = block.BuildMerkleTree();
        block.nVersion = 1;
        block.nTime    = 1401181723;
        block.nBits    = 0x1e0ffff0;
        block.nNonce   = 0;

        if (fTestNet)
        {
            block.nTime    = 1401181723;
            block.nNonce   = 3861367235;
        }

        //// debug print
        uint256 hash = block.GetHash();
        printf("%s\n", hash.ToString().c_str());
        printf("%s\n", hashGenesisBlock.ToString().c_str());
        printf("%s\n", block.hashMerkleRoot.ToString().c_str());
        assert(block.hashMerkleRoot == uint256("0x25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e"));
        block.print();
        assert(hash == hashGenesisBlock);

        // Start new block file
        try {
            unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
            CDiskBlockPos blockPos;
            CValidationState state;
            if (!FindBlockPos(state, blockPos, nBlockSize+8, 0, block.nTime))
                return error("LoadBlockIndex() : FindBlockPos failed");
            if (!block.WriteToDisk(blockPos))
                return error("LoadBlockIndex() : writing genesis block to disk failed");
            if (!block.AddToBlockIndex(state, blockPos))
                return error("LoadBlockIndex() : genesis block not accepted");
        } catch(std::runtime_error &e) {
            return error("LoadBlockIndex() : failed to initialize block database: %s", e.what());
        }
    }

    return true;
}

2014-05-27 09:31:24 


2014-05-27 09:31:24 DarkCoin version v0.9.4.8-gd1aadc8-beta (Sun, 25 May 2014 14:08:31 -0700)
2014-05-27 09:31:24 Using OpenSSL version OpenSSL 1.0.1g 7 Apr 2014
2014-05-27 09:31:24 Default data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 09:31:24 Using data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 09:31:24 Using at most 125 connections (2048 file descriptors available)
2014-05-27 09:31:24 Using 4 threads for script verification
2014-05-27 09:31:24 init message: Verifying wallet...
2014-05-27 09:31:24 dbenv.open LogDir=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\database ErrorFile=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\db.log
2014-05-27 09:31:24 Bound to [::]:47258
2014-05-27 09:31:24 Bound to 0.0.0.0:47258
2014-05-27 09:31:24 init message: Loading block index...
2014-05-27 09:31:24 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\blocks\index
2014-05-27 09:31:24 Opened LevelDB successfully
2014-05-27 09:31:24 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\chainstate
2014-05-27 09:31:24 Opened LevelDB successfully
2014-05-27 09:31:24 LoadBlockIndexDB(): last block file = 0
2014-05-27 09:31:24 LoadBlockIndexDB(): transaction index disabled
2014-05-27 09:31:24 Initializing databases...
2014-05-27 09:31:24 39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7
2014-05-27 09:31:24 00000ffd590b1485b3caadc19b22e6379c733355108f107a430458cdf3407ab6
2014-05-27 09:31:24 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e
2014-05-27 09:46:05 




2014-05-27 09:46:05 DarkCoin version v0.9.4.8-gd1aadc8-beta (Sun, 25 May 2014 14:08:31 -0700)
2014-05-27 09:46:05 Using OpenSSL version OpenSSL 1.0.1g 7 Apr 2014
2014-05-27 09:46:05 Default data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 09:46:05 Using data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 09:46:05 Using at most 125 connections (2048 file descriptors available)
2014-05-27 09:46:05 Using 4 threads for script verification
2014-05-27 09:46:05 init message: Verifying wallet...
2014-05-27 09:46:05 dbenv.open LogDir=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\database ErrorFile=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\db.log
2014-05-27 09:46:05 Bound to [::]:47258
2014-05-27 09:46:05 Bound to 0.0.0.0:47258
2014-05-27 09:46:05 init message: Loading block index...
2014-05-27 09:46:05 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\blocks\index
2014-05-27 09:46:05 Opened LevelDB successfully
2014-05-27 09:46:05 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\chainstate
2014-05-27 09:46:05 Opened LevelDB successfully
2014-05-27 09:46:05 LoadBlockIndexDB(): last block file = 0
2014-05-27 09:46:05 LoadBlockIndexDB(): transaction index disabled
2014-05-27 09:46:05 Initializing databases...
2014-05-27 09:46:05 39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7
2014-05-27 09:46:05 00000ffd590b1485b3caadc19b22e6379c733355108f107a430458cdf3407ab6
2014-05-27 09:46:05 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e
2014-05-27 09:46:05 CBlock(hash=39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7, input=0100000000000000000000000000000000000000000000000000000000000000000000005e772513d42435d9871208955bb543a61e4e44f4e7ea0f99f8a3c237205a612526558453f0ff0f1e00000000, PoW=39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7, ver=1, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000, hashMerkleRoot=25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e, nTime=1401181478, nBits=1e0ffff0, nNonce=0, vtx=1)
2014-05-27 09:46:05   CTransaction(hash=25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000000000000000000000000000000000000000000000000000000000, 4294967295), coinbase 04ffff001d01044c5a436f696e6465736b2032372f4d61792f323031342046616365626f6f6b2d496e74656772617465642057616c6c6574204d616b65732053656e64696e6720426974636f696e2061732045617379206173204d6573736167696e67)
    CTxOut(nValue=50.00000000, scriptPubKey=040184710fa689ad5023690c80f3a4)
  vMerkleTree: 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e 
2014-05-27 10:04:49 




2014-05-27 10:04:49 DarkCoin version v0.9.4.8-gd1aadc8-beta (Sun, 25 May 2014 14:08:31 -0700)
2014-05-27 10:04:49 Using OpenSSL version OpenSSL 1.0.1g 7 Apr 2014
2014-05-27 10:04:49 Default data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 10:04:49 Using data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 10:04:49 Using at most 125 connections (2048 file descriptors available)
2014-05-27 10:04:49 Using 4 threads for script verification
2014-05-27 10:04:49 init message: Verifying wallet...
2014-05-27 10:04:49 dbenv.open LogDir=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\database ErrorFile=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\db.log
2014-05-27 10:04:49 Bound to [::]:47258
2014-05-27 10:04:49 Bound to 0.0.0.0:47258
2014-05-27 10:04:49 init message: Loading block index...
2014-05-27 10:04:49 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\blocks\index
2014-05-27 10:04:49 Opened LevelDB successfully
2014-05-27 10:04:49 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\chainstate
2014-05-27 10:04:49 Opened LevelDB successfully
2014-05-27 10:04:49 LoadBlockIndexDB(): last block file = 0
2014-05-27 10:04:49 LoadBlockIndexDB(): transaction index disabled
2014-05-27 10:04:49 Initializing databases...
2014-05-27 10:04:49 39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7
2014-05-27 10:04:49 00000ffd590b1485b3caadc19b22e6379c733355108f107a430458cdf3407ab6
2014-05-27 10:04:49 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e
2014-05-27 10:04:49 CBlock(hash=39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7, input=0100000000000000000000000000000000000000000000000000000000000000000000005e772513d42435d9871208955bb543a61e4e44f4e7ea0f99f8a3c237205a612526558453f0ff0f1e00000000, PoW=39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7, ver=1, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000, hashMerkleRoot=25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e, nTime=1401181478, nBits=1e0ffff0, nNonce=0, vtx=1)
2014-05-27 10:04:49   CTransaction(hash=25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000000000000000000000000000000000000000000000000000000000, 4294967295), coinbase 04ffff001d01044c5a436f696e6465736b2032372f4d61792f323031342046616365626f6f6b2d496e74656772617465642057616c6c6574204d616b65732053656e64696e6720426974636f696e2061732045617379206173204d6573736167696e67)
    CTxOut(nValue=50.00000000, scriptPubKey=040184710fa689ad5023690c80f3a4)
  vMerkleTree: 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e 
2014-05-27 10:09:53 


2014-05-27 10:09:53 DarkCoin version v0.9.4.8-gd1aadc8-beta (Sun, 25 May 2014 14:08:31 -0700)
2014-05-27 10:09:53 Using OpenSSL version OpenSSL 1.0.1g 7 Apr 2014
2014-05-27 10:09:53 Default data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 10:09:53 Using data directory C:\Users\hadixxx7\AppData\Roaming\DarkCoin
2014-05-27 10:09:53 Using at most 125 connections (2048 file descriptors available)
2014-05-27 10:09:53 Using 4 threads for script verification
2014-05-27 10:09:53 init message: Verifying wallet...
2014-05-27 10:09:53 dbenv.open LogDir=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\database ErrorFile=C:\Users\hadixxx7\AppData\Roaming\DarkCoin\db.log
2014-05-27 10:09:53 Bound to [::]:47258
2014-05-27 10:09:53 Bound to 0.0.0.0:47258
2014-05-27 10:09:53 init message: Loading block index...
2014-05-27 10:09:53 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\blocks\index
2014-05-27 10:09:53 Opened LevelDB successfully
2014-05-27 10:09:53 Opening LevelDB in C:\Users\hadixxx7\AppData\Roaming\DarkCoin\chainstate
2014-05-27 10:09:53 Opened LevelDB successfully
2014-05-27 10:09:53 LoadBlockIndexDB(): last block file = 0
2014-05-27 10:09:53 LoadBlockIndexDB(): transaction index disabled
2014-05-27 10:09:53 Initializing databases...
2014-05-27 10:09:53 39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7
2014-05-27 10:09:53 39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7
2014-05-27 10:09:53 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e
2014-05-27 10:09:53 CBlock(hash=39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7, input=0100000000000000000000000000000000000000000000000000000000000000000000005e772513d42435d9871208955bb543a61e4e44f4e7ea0f99f8a3c237205a612526558453f0ff0f1e00000000, PoW=39a05234cb649f06386c80fa1469b84d4e8fc806d2e91f3348cdaa6ef72e26d7, ver=1, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000, hashMerkleRoot=25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e, nTime=1401181478, nBits=1e0ffff0, nNonce=0, vtx=1)
2014-05-27 10:09:53   CTransaction(hash=25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000000000000000000000000000000000000000000000000000000000, 4294967295), coinbase 04ffff001d01044c5a436f696e6465736b2032372f4d61792f323031342046616365626f6f6b2d496e74656772617465642057616c6c6574204d616b65732053656e64696e6720426974636f696e2061732045617379206173204d6573736167696e67)
    CTxOut(nValue=50.00000000, scriptPubKey=040184710fa689ad5023690c80f3a4)
  vMerkleTree: 25615a2037c2a3f8990feae7f4444e1ea643b55b95081287d93524d41325775e 
2014-05-27 10:09:53 Pre-allocating up to position 0x1000000 in blk00000.dat
2014-05-27 10:09:53 ERROR: CheckProofOfWork() : hash doesn't match nBits
2014-05-27 10:09:53 ERROR: CBlock::ReadFromDisk() : errors in block header
2014-05-27 10:09:53 *** Failed to read block
2014-05-27 10:09:55 ERROR: LoadBlockIndex() : genesis block not accepted
2014-05-27 10:09:55 Shutdown : In progress...
2014-05-27 10:09:55 StopNode()
2014-05-27 10:09:55 Flushed 0 addresses to peers.dat  16ms
2014-05-27 10:09:55 Committing 0 changed transactions to coin database...
2014-05-27 10:09:55 Shutdown : done

!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet)

        const char* pszTimestamp = "14 June 2014 Soceroos lose to Chile 3-1 in FIFA world cup";
        CTransaction txNew;
        txNew.nTime = 1402712622;
        txNew.vin.resize(1);
        txNew.vout.resize(1);
        txNew.vin[0].scriptSig = CScript() << 0 << CBigNum(42) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
        txNew.vout[0].SetEmpty();
        CBlock block;
        block.vtx.push_back(txNew);
        block.hashPrevBlock = 0;
        block.hashMerkleRoot = 0;
        block.nVersion = 0;
        block.nTime    = 0;
        block.nBits    = 0;
        block.nNonce   = 0;

        //// debug print
        assert(block.hashMerkleRoot == uint256("0x0"));
        block.print();
        assert(block.GetHash() == (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
        assert(block.CheckBlock());

CBlock(hash=694b3a55a61339b43c01421b13f710e22e33a7eabda1cd48103bb9f376081d16, ver=0, hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000, hashMerkleRoot=0000000000000000000000000000000000000000000000000000000000000000, nTime=0, nBits=00000000, nNonce=0, vtx=1, vchBlockSig=)
  Coinbase(hash=b89a899f43, nTime=1402712622, ver=1, vin.size=1, vout.size=1, nLockTime=0)
    CTxIn(COutPoint(0000000000, 4294967295), coinbase 00012a393134204a756e65203230313420536f6365726f6f73206c6f736520746f204368696c6520332d3120696e204649464120776f726c6420637570)
    CTxOut(empty)
  vMerkleTree: 

Assertion failed: (block.hashMerkleRoot == uint256("0x")), function LoadBlockIndex, file main.cpp, line 2031.
Abort trap: 6