# Python 2.5
# terms of use: public domain. you are free to use or abuse this code anyway you want :)
import socket, base64, hashlib
op={
chr(0): 'OP_FALSE', # this value is replaced later
chr(81): 'OP_TRUE', # this value is replaced later
chr(0): 'OP_0',
chr(76): 'OP_PUSHDATA1',
chr(77): 'OP_PUSHDATA2',
chr(78): 'OP_PUSHDATA4',
chr(79): 'OP_1NEGATE',
chr(81): 'OP_1',
chr(97): 'OP_NOP',
chr(99): 'OP_IF',
chr(100): 'OP_NOTIF',
chr(103): 'OP_ELSE',
chr(104): 'OP_ENDIF',
chr(105): 'OP_VERIFY',
chr(106): 'OP_RETURN',
chr(107): 'OP_TOALTSTACK',
chr(108): 'OP_FROMALTSTACK',
chr(115): 'OP_IFDUP',
chr(116): 'OP_DEPTH',
chr(117): 'OP_DROP',
chr(118): 'OP_DUP',
chr(119): 'OP_NIP',
chr(120): 'OP_OVER',
chr(121): 'OP_PICK',
chr(122): 'OP_ROLL',
chr(123): 'OP_ROT',
chr(124): 'OP_SWAP',
chr(125): 'OP_TUCK',
chr(109): 'OP_2DROP',
chr(110): 'OP_2DUP',
chr(111): 'OP_3DUP',
chr(112): 'OP_2OVER',
chr(113): 'OP_2ROT',
chr(114): 'OP_2SWAP',
chr(126): 'OP_CAT',
chr(127): 'OP_SUBSTR',
chr(128): 'OP_LEFT',
chr(129): 'OP_RIGHT',
chr(130): 'OP_SIZE',
chr(131): 'OP_INVERT',
chr(132): 'OP_AND',
chr(133): 'OP_OR',
chr(134): 'OP_XOR',
chr(135): 'OP_EQUAL',
chr(136): 'OP_EQUALVERIFY',
chr(139): 'OP_1ADD',
chr(140): 'OP_1SUB',
chr(141): 'OP_2MUL',
chr(142): 'OP_2DIV',
chr(143): 'OP_NEGATE',
chr(144): 'OP_ABS',
chr(145): 'OP_NOT',
chr(146): 'OP_0NOTEQUAL',
chr(147): 'OP_ADD',
chr(148): 'OP_SUB',
chr(149): 'OP_MUL',
chr(150): 'OP_DIV',
chr(151): 'OP_MOD',
chr(152): 'OP_LSHIFT',
chr(153): 'OP_RSHIFT',
chr(154): 'OP_BOOLAND',
chr(155): 'OP_BOOLOR',
chr(156): 'OP_NUMEQUAL',
chr(157): 'OP_NUMEQUALVERIFY',
chr(158): 'OP_NUMNOTEQUAL',
chr(159): 'OP_LESSTHAN',
chr(160): 'OP_GREATERTHAN',
chr(161): 'OP_LESSTHANOREQUAL',
chr(162): 'OP_GREATERTHANOREQUAL',
chr(163): 'OP_MIN',
chr(164): 'OP_MAX',
chr(165): 'OP_WITHIN',
chr(166): 'OP_RIPEMD160',
chr(167): 'OP_SHA1',
chr(168): 'OP_SHA256',
chr(169): 'OP_HASH160',
chr(170): 'OP_HASH256',
chr(171): 'OP_CODESEPARATOR',
chr(172): 'OP_CHECKSIG',
chr(173): 'OP_CHECKSIGVERIFY',
chr(174): 'OP_CHECKMULTISIG',
chr(175): 'OP_CHECKMULTISIGVERIFY',
chr(253): 'OP_PUBKEYHASH',
chr(254): 'OP_PUBKEY',
chr(255): 'OP_INVALIDOPCODE',
chr(80): 'OP_RESERVED',
chr(98): 'OP_VER',
chr(101): 'OP_VERIF',
chr(102): 'OP_VERNOTIF',
chr(137): 'OP_RESERVED1',
chr(138): 'OP_RESERVED2'
}
for i in range(1,76): op[chr(i)]='OP_PUSH'+str(i) # name isn't shown in the script
for i in range(82,97): op[chr(i)]='OP_'+str(i-80) # name isn't shown in the script
for i in range(176,186): op[chr(i)]='OP_NOP'+str(i-175)
for i in range(256): op[chr(i)]= op[chr(i)] if (chr(i) in op) else 'OP_UNKNOWN'
class jsonrpcserver():
def __init__(self, host, port, username, password):
self.jsonsock=socket.socket()
self.jsonsock.connect((host,port))
self.authkey=base64.b64encode(username+':'+password)
class jsonerror(Exception):
def __init__(self, errormessage, response):
self.errormessage = errormessage
self.response = response
def __str__(self):
return str(self.errormessage)
def request(self, method, params, errormessage):
k='POST / HTTP/1.1\r\nContent-Type: application/json-rpc\r\nAuthorization: Basic '+self.authkey+'\r\nContent-Length: '
k2='{"method": "'+method+'", "params": '+str(params).replace("'",'"')+', "id":0}'
self.jsonsock.send(k+str(len(k2))+'\r\n\r\n'+k2); response=self.jsonsock.recv(2**20)
while response.count('{')!=response.count('}'): response+=self.jsonsock.recv(2**20)
c=eval(response.split('\r\n\r\n')[-1].replace('null','None'))
if c['error']:
raise self.jsonerror(errormessage+' - "'+str(c['error']['message'])+'"', c)
return c['result']
def getrawtx(self, hash):
return self.request('getrawtransaction', [hash], 'getrawtx failed to retrieve tx '+hash)
def getblock(self, hash):
return self.request('getblock', [hash], 'getblock failed to retrieve block '+hash)
def getblockcount(self):
return self.request('getblockcount', [], 'getblockcount failed to retrieve block count')
def getblockhash(self, blocknum):
return self.request('getblockhash', [blocknum], 'getblockhash failed to retrieve hash for block #'+str(blocknum))
#bitcoinqt=jsonrpcserver('localhost',8332,'bitcoinrpc','password')
#print bitcoinqt.getrawtx('384287be164a79c707f93a687a57ec5d9c1230af521a546186cd5c3af2011dae')
#print bitcoinqt.getblock('00000000000000eac823d5c3f6c17f9ec08414c4e23fff6060e842fae0581fd6')
#print bitcoinqt.getblockcount()
#print bitcoinqt.getblockhash(0)
def hash256(x): return hashlib.sha256(hashlib.sha256(x).digest()).digest()
def makemerkletree(txhashes):
levels=[txhashes]
while len(levels[-1])!=1:
newlevel=[]
for l in range((len(levels[-1])+1)/2):
newlevel.append(hash256(levels[-1][l*2].decode('hex')[::-1]+levels[-1][min(l*2+1,len(levels[-1])-1)].decode('hex')[::-1])[::-1].encode('hex'))
levels.append(newlevel)
tree=[]
for level in levels: tree+=level
return tree
def humanreadablescript(script): # same as blockexplorer/getblock's, I personally prefer OP_FALSE and OP_TRUE
out='' # maybe this function should be called asm ? what does asm stand for ?
while script!='':
if 'OP_PUSH' in op[script[0]]:
if 'OP_PUSHDATA' in op[script[0]]: # 199593
numbytes=int(op[script[0]][-1]); script=script[1:]
pushlen=sum([ord(script[x])*(256**x) for x in range(numbytes)]); script=script[numbytes:]
else: pushlen=ord(script[0]); script=script[1:]
out+=script[:pushlen].encode('hex')+' '; script=script[pushlen:]
elif op[script[0]][3:].isdigit(): out+=op[script[0]][3:]+' '; script=script[1:] # 199388 # 201121
else:
out+=op[script[0]]+' '; script=script[1:]
return out.strip()
#print humanreadablescript('76a914de7a247c0d617aafa5823994ecb648411e008f1288ac'.decode('hex'))
def humanreadabletx(rawtx): # similar to decoderawtransaction, but faster than using the rpc. also, fun to write
tx={} # needs better name # code could be prettier
tx['size']=len(rawtx)
tx['hash']=hash256(rawtx)[::-1].encode('hex')
tx['ver']=sum([ord(rawtx[x])*(256**x) for x in range(4)]); rawtx=rawtx[4:]
numinputs=ord(rawtx[0]); rawtx=rawtx[1:]
if numinputs==253: numinputs=sum([ord(rawtx[x])*(256**x) for x in range(2)]); rawtx=rawtx[2:] # 199090
tx['vin_sz']=numinputs
tx['in']=[]
for inputnum in range(numinputs):
input={'prev_out':{}}
input['prev_out']['hash']=rawtx[:32][::-1].encode('hex'); rawtx=rawtx[32:]
if input['prev_out']['hash']=='0'*64:
input['prev_out']['n']=sum([ord(rawtx[x])*(256**x) for x in range(4)]); rawtx=rawtx[4:]
coinbasesize=ord(rawtx[0]); rawtx=rawtx[1:]
if coinbasesize==253: coinbasesize=sum([ord(rawtx[x])*(256**x) for x in range(2)]); rawtx=rawtx[2:] # 199593
input['coinbase']=rawtx[:coinbasesize].encode('hex'); rawtx=rawtx[coinbasesize:]
input['sequence']=sum([ord(rawtx[x])*(256**x) for x in range(4)]); rawtx=rawtx[4:] # 199002
if input['sequence']==256**4-1: del input['sequence']
else:
input['prev_out']['n']=sum([ord(rawtx[x])*(256**x) for x in range(4)]); rawtx=rawtx[4:]
sigsize=ord(rawtx[0]); rawtx=rawtx[1:]
if sigsize==253: sigsize=sum([ord(rawtx[x])*(256**x) for x in range(2)]); rawtx=rawtx[2:] # 199593
input['scriptSig']=humanreadablescript(rawtx[:sigsize]); rawtx=rawtx[sigsize:]
input['sequence']=sum([ord(rawtx[x])*(256**x) for x in range(4)]); rawtx=rawtx[4:]
if input['sequence']==256**4-1: del input['sequence']
tx['in'].append(input)
numoutputs=ord(rawtx[0]); rawtx=rawtx[1:]
if numoutputs==253: numoutputs=sum([ord(rawtx[x])*(256**x) for x in range(2)]); rawtx=rawtx[2:] # 199025
tx['vout_sz']=numoutputs
tx['out']=[]
for outputnum in range(numoutputs):
output={}
numericvalue=sum([ord(rawtx[x])*(256**x) for x in range(8)]); rawtx=rawtx[8:]
output['value']=str(numericvalue/100000000)+'.'+str(numericvalue%100000000).zfill(8)
scriptsize=ord(rawtx[0]); rawtx=rawtx[1:]
if scriptsize==253: scriptsize=sum([ord(rawtx[x])*(256**x) for x in range(2)]); rawtx=rawtx[2:] # 71036
output['scriptPubKey']=humanreadablescript(rawtx[:scriptsize]); rawtx=rawtx[scriptsize:]
tx['out'].append(output)
tx['lock_time']=sum([ord(rawtx[x])*(256**x) for x in range(4)]); rawtx=rawtx[4:]
return tx
#print humanreadabletx('01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000'.decode('hex')) # genesis transaction, good luck trying to get that from bitcoinqt though. I wonder if Satoshi can spend that tx if he wanted to...
# grunt work
def bxformattx(hrtx): # block explorer format
out ='{\n'
out+=' "hash":"'+hrtx['hash']+'",\n'
out+=' "ver":'+str(hrtx['ver'])+',\n'
out+=' "vin_sz":'+str(hrtx['vin_sz'])+',\n'
out+=' "vout_sz":'+str(hrtx['vout_sz'])+',\n'
out+=' "lock_time":'+str(hrtx['lock_time'])+',\n'
out+=' "size":'+str(hrtx['size'])+',\n'
out+=' "in":[\n'
for input in hrtx['in']:
out+=' {\n'
out+=' "prev_out":{\n'
out+=' "hash":"'+input['prev_out']['hash']+'",\n'
out+=' "n":'+str(input['prev_out']['n'])+'\n'
out+=' },\n'
field=['scriptSig','coinbase'][input['prev_out']['hash']=='0'*64]
out+=' "'+field+'":"'+input[field]+'"\n'
if 'sequence' in input:
out=out[:-1]+',\n'
out+=' "sequence":'+str(input['sequence'])+'\n'
out+=' },\n'
out=out[:-2]+'\n' # removing the last comma
out+=' ],\n'
out+=' "out":[\n'
for output in hrtx['out']:
out+=' {\n'
out+=' "value":"'+output['value']+'",\n'
out+=' "scriptPubKey":"'+output['scriptPubKey']+'"\n'
out+=' },\n'
out=out[:-2]+'\n' # removing the last comma
out+=' ]\n'
out+='}'
return out
def bxformatblock(block, transactiondata): # block explorer format
out ='{\n'
out+=' "hash":"'+block['hash']+'",\n'
out+=' "ver":'+str(block['version'])+',\n'
out+=' "prev_block":"'+block['previousblockhash']+'",\n'
out+=' "mrkl_root":"'+block['merkleroot']+'",\n'
out+=' "time":'+str(block['time'])+',\n'
out+=' "bits":'+str(int(block['bits'],16))+',\n'
out+=' "nonce":'+str(block['nonce'])+',\n'
out+=' "n_tx":'+str(len(block['tx']))+',\n'
out+=' "size":'+str(block['size'])+',\n'
out+=' "tx":[\n'
for transactionhash in block['tx']:
out+=' '+bxformattx(transactiondata[transactionhash]).replace('\n','\n ')+',\n' # add indentation
out=out[:-2]+'\n' # removing the last comma
out+=' ],\n'
out+=' "mrkl_tree":[\n'
for i in makemerkletree(block['tx']):
out+=' "'+i+'",\n'
out=out[:-2]+'\n' # removing the last comma
out+=' ]\n'
out+='}'
return out
# end of grunt work
def bxgettx(txid, server):
return bxformattx(humanreadabletx(server.getrawtx(txid).decode('hex')))
def bxgetblock(blockhash, server):
blockdata=server.getblock(blockhash)
txdata={}
for tx in blockdata['tx']: txdata[tx]=humanreadabletx(server.getrawtx(tx).decode('hex'))
return bxformatblock(blockdata,txdata)
#bitcoinqt=jsonrpcserver('localhost',8332,'bitcoinrpc','password')
#print bxgetblock('00000000000000eac823d5c3f6c17f9ec08414c4e23fff6060e842fae0581fd6', bitcoinqt)
# http server for offline block explorer
import threading
sock=socket.socket()
sock.bind(('',8334))
sock.listen(100)
def handleconnection(newconnection):
bitcoinqt=jsonrpcserver('localhost',8332,'bitcoinrpc','password')
req=newconnection.recv(2**20)
reqpage=req.split('\r\n')[0].split(' ')[1]
foundheader='HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: text/plain\r\nContent-Length: '
notfoundheader='HTTP/1.1 404 Not Found\r\nConnection: close\r\nContent-Type: text/plain\r\nContent-Length: '
def response(data, found=True): return [notfoundheader,foundheader][found]+str(len(data))+'\r\n\r\n'+data
try:
if reqpage[:10]=='/rawblock/': resptext=response(bxgetblock(reqpage[10:], bitcoinqt))
elif reqpage[:7]=='/rawtx/': resptext=response(bxgettx(reqpage[7:], bitcoinqt))
elif reqpage=='/q/getblockcount': resptext=response(str(bitcoinqt.getblockcount()))
elif reqpage[:16]=='/q/getblockhash/': resptext=response(bitcoinqt.getblockhash(int(reqpage[16:])).upper())
else: resptext=response('Nothing here.', found=False)
except jsonrpcserver.jsonerror, e: resptext=response(str(e.response))
except: resptext=response('Nothing here.', found=False); print 'ERROR - disable line 324 and restart to see what went wrong'
newconnection.send(resptext); newconnection.close()
while True: threading.Thread(target=handleconnection, args=(sock.accept()[0],)).start()
