bitcoin-blockchain-feed-bot

alectryon.py

#jsonrpc.py from https://github.com/JoinMarket-Org/joinmarket/blob/master/joinmarket/jsonrpc.py
#copyright # Copyright (C) 2013,2015 by Daniel Kraft <d@domob.eu> and phelix / blockchained.com

import base64
import httplib
import json

class JsonRpcError(Exception):
    def __init__(self, obj):
        self.code = obj["code"]
        self.message = obj["message"]

class JsonRpcConnectionError(JsonRpcError): pass

class JsonRpc(object):
    def __init__(self, host, port, user, password):
        self.host = host
        self.port = port
        self.authstr = "%s:%s" % (user, password)
        self.queryId = 1

    def queryHTTP(self, obj):
        headers = {"User-Agent": "joinmarket",
                   "Content-Type": "application/json",
                   "Accept": "application/json"}
        headers["Authorization"] = "Basic %s" % base64.b64encode(self.authstr)
        body = json.dumps(obj)
        try:
            conn = httplib.HTTPConnection(self.host, self.port)
            conn.request("POST", "", body, headers)
            response = conn.getresponse()
            if response.status == 401:
                conn.close()
                raise JsonRpcConnectionError(
                        "authentication for JSON-RPC failed")
            # All of the codes below are 'fine' from a JSON-RPC point of view.
            if response.status not in [200, 404, 500]:
                conn.close()
                raise JsonRpcConnectionError("unknown error in JSON-RPC")
            data = response.read()
            conn.close()
            return json.loads(data)
        except JsonRpcConnectionError as exc:
            raise exc
        except Exception as exc:
            raise JsonRpcConnectionError("JSON-RPC connection failed. Err:" +
                                         repr(exc))

    def call(self, method, params):
        currentId = self.queryId
        self.queryId += 1
        request = {"method": method, "params": params, "id": currentId}
        response = self.queryHTTP(request)
        if response["id"] != currentId:
            raise JsonRpcConnectionError("invalid id returned by query")
        if response["error"] is not None:
            raise JsonRpcError(response["error"])
        return response["result"]


#irc bot code starts here
##single file, no dependencies
#by belcher

#Ares punished Alectryon by turning him into a rooster which never forgets
#to announce the arrival of the sun in the morning by its crowing.

import socket, time
from datetime import datetime
from getpass import getpass

#configuration stuff
nick = 'Alectryon'
hostport = ('irc.freenode.net', 6667)
nickserv_password = getpass('enter nickserv password for ' + nick + ': ')
channel = '#bitcoin-blocks'
#TODO :orwell.freenode.net 437 * Alectryon :Nick/channel is temporarily unavailable, then send /ns release <nick> <password>
rpc = JsonRpc(host = 'localhost',
            port = 8332,
            user = 'bitcoinrpc',
            password = 'password')
#TODO :Alectryon!~Alectryon@host NICK :Guest11162, for when you fuck up and dont identify in time
#TODO :barjavel.freenode.net 404 Guest878 #bitcoin-blocks :Cannot send to channel
check_for_new_block_interval = 10
fee_estimate_output_interval = 60*15
ping_interval_seconds = 120
ping_timeout_seconds = 60*5


old_bci = [rpc.call('getblockchaininfo', [])]
print 'bestblock = ' + old_bci[0]['bestblockhash']
old_head = [rpc.call('getblockheader', [old_bci[0]['bestblockhash']])]

block_times = []
head = old_head[0]
for c in range(2016):
    block_times.append(head['time'])
    head = rpc.call('getblockheader', [head['previousblockhash']])
block_times.reverse()

last_fee_estimate = [datetime.now()]

def strtimediff(s):
    return "%02d:%02d" % (s/60, s%60)

def strfeerate(con, econ):
    if con == econ:
        return str(con*1e5)
    else:
        return str(con*1e5) + ', ' + str(econ*1e5)

def create_fee_rate_stats():
    st = time.time()
    blocks = [(2, 'asap'), (6, 'hour'), (12, '2h'), (24, '4h'), (36, '6h'), (72, '12h'), (144, 'day'), (432, '3day'), (1008, 'week')]
    data = []
    for b, t in blocks:
        con = rpc.call('estimatesmartfee', [b, 'CONSERVATIVE'])
        econ = rpc.call('estimatesmartfee', [b, 'ECONOMICAL'])
        data.append((b, t, con['feerate'], econ['feerate']))
    message = 'FEE ESTIMATION'
    message += ' fee rates: target-->(conservative, economical)sat/vbyte ' + ' '.join(
        [t + '-->(' + strfeerate(con, econ) + ')' for b, t, con, econ in data])

    blocks_index = [0, 6, 8] #asap, day, week
    #typical tx 74a0b9a414f59dfe846473474b24c5d1d9d9c5110b0f54c8a22811f9eaa7a137
    TYPICAL_VBYTES_KB = 168
    message += ' typical tx(' + str(TYPICAL_VBYTES_KB) + ' vbytes): ' + ' '.join(
        [t + '-->' + '%.5f'%(con*TYPICAL_VBYTES_KB) + 'mbtc' for b, t, con, econ in [data[i] for i in blocks_index]])

    #TODO maybe also cost per input/cost per output
    et = time.time()
    print 'fees = ' + str(et - st) + 'sec'
    return message

def check_fee_estimate(sock):
    try:
        if (datetime.now() - last_fee_estimate[0]).total_seconds() < fee_estimate_output_interval:
            return
        last_fee_estimate[0] = datetime.now()

        message = create_fee_rate_stats()
        print message
        sock.sendall('PRIVMSG ' + channel + ' :' + message + '\r\n')
    except JsonRpcError as e:
        print repr(e)

def create_block_stats(blockhash):
    st = time.time()
    #TODO average fee rate, median fee rate, minimum fee rate
    bci = rpc.call('getblockchaininfo', [])
    head = rpc.call('getblockheader', [blockhash])

    block_times.pop(0) #remove oldest block
    block_times.append(head['time']) #add new block

    MAX_WEIGHT = 4000000 #TODO lower this
    SUBSIDY = 12.5 #TODO implement inflation schedule
    block = rpc.call('getblock', [blockhash, 2])
    coinbase_tx = block['tx'][0] 
    reward = sum([tx_out['value'] for tx_out in coinbase_tx['vout']])
    fees = reward - SUBSIDY

    coinbase_str = coinbase_tx['vin'][0]['coinbase']
    readable_coinbase = ''.join([i for i in coinbase_str.decode('hex')
        if i < '\x7f' and i > '\x19'])

    windows = [6, 36, 144, 432, 1008, 2016]
    intervals =  [(block_times[-1] - block_times[-w])/w for w in windows]

    until_retarget = -(bci['blocks'] % -2016)

    utxos_produced = 0
    utxos_consumed = 0
    for tx in block['tx']:
        utxos_produced += len(tx['vout'])
        utxos_consumed += len(tx['vin'])

    message = 'NEW BLOCK!'
    message += ' hash=' + blockhash
    #message += ' prevhash=' + head['previousblockhash']
    message += ' height=' + str(bci['blocks'])
    message += (' mediantime=' +
        datetime.fromtimestamp(bci['mediantime']).strftime("%Y-%m-%d %H:%M:%S")
        + ' timestamp=' + 
        datetime.fromtimestamp(head['time']).strftime("%Y-%m-%d %H:%M:%S"))
    message += ' #tx=' + str(len(block['tx']))
    message += ' outputs=' + str(utxos_produced) + ' inputs=' + str(utxos_consumed) + ' utxoset-change=' + '%+d'%(utxos_produced - utxos_consumed)
    message += ' fees=' + str(fees) + ' btc(' + ('%.2f%%)' % (100.0*fees / reward))
    message += ' weight=' + str(block['weight']) + '(%.0f%% full)' % (100.0 * block['weight'] / MAX_WEIGHT)
    message += ' interval=' + str(strtimediff(head['time'] - old_head[0]['time']))
    message += ' avg-intervals(' + ', '.join([str(w) for w in windows]) + ')blocks = (' + ', '.join([str(strtimediff(d)) for d in intervals]) + ')'
    message += ' retarget=' + str(until_retarget) + 'blocks(' + str(until_retarget/144) + ' days)'
    message += ' minermsg=' + readable_coinbase

    print 'diff=' + str(bci['difficulty']) + ' olddiff=' + str(old_bci[0]['difficulty'])
    if bci['difficulty'] != old_bci[0]['difficulty']:
         message += (' RETARGET! new difficulty=' + str(bci['difficulty']) + '(' + ('%+.1f'
            % ((bci['difficulty'] - old_bci[0]['difficulty']) /
            old_bci[0]['difficulty'] * 100)) + ')')
    old_bci[0] = bci
    old_head[0] = head
    et = time.time()
    print 'block stats = ' + str(et - st) + 'sec'
    return message

def check_new_block(sock):
    try:
        blockhash = rpc.call('getbestblockhash', [])
        if blockhash == old_bci[0]['bestblockhash']:
            return
        last_fee_estimate[0] = datetime.fromtimestamp(0)
        message = create_block_stats(blockhash)
        print message
        sock.sendall('PRIVMSG ' + channel + ' :' + message + '\r\n')
        check_fee_estimate(sock)
    except JsonRpcError as e:
        print repr(e)

def handle_irc_line(sock, line, chunks):
    if len(chunks) < 2:
        return
    #    sock.sendall('JOIN ' + channel + '\r\n')
    #nuh_chunks = chunks[0].split('!')
    #if nuh_chunks[0] == ':NickServ' and 'registered' in line and 'identify' in line:
    if chunks[1] == '376': ##end of modt
        print 'sending nickserv password'
        sock.sendall('PRIVMSG NickServ :identify ' + nickserv_password + '\r\n')
    if chunks[1] == '396':
        #:sinisalo.freenode.net 396 beIcher unaffiliated/belcher :is now your hidden host (set by services.)
        print 'joining channel'
        sock.sendall('JOIN ' + channel + '\r\n')

print create_fee_rate_stats()
print create_block_stats(old_bci[0]['bestblockhash'])
'''
import sys
sys.exit(0)
'''

while True:
    try:
        print 'connecting'
        sock = socket.socket()
        sock.connect(hostport)
        print 'connected'
        sock.settimeout(check_for_new_block_interval)
        sock.sendall('USER ' + nick + ' b c :' + nick + '\r\n')
        sock.sendall('NICK ' + nick + '\r\n')
        recv_buffer = ""
        last_ping = datetime.now()
        waiting_for_pong = False
        while True:
            try:
                #print 'reading'
                recv_data = sock.recv(4096)
                if not recv_data or len(recv_data) == 0:
                    raise EOFError()
                
                recv_buffer += recv_data
                lb = recv_data.find('\n')
                if lb == -1:
                    continue
                    
                while lb != -1:
                    line = recv_buffer[:lb].rstrip()
                    recv_buffer = recv_buffer[lb + 1:]
                    lb = recv_buffer.find('\n')
                    
                    #print str(datetime.now()) + ' ' + line
                    print line
                    chunks = line.split(' ')
                    if chunks[0] == 'PING':
                        sock.sendall(line.replace('PING', 'PONG') + '\r\n')
                    elif len(chunks) > 1 and chunks[1] == 'PONG':
                        #print 'server replied to ping'
                        last_ping = datetime.now()
                        waiting_for_pong = False
                    else:
                        handle_irc_line(sock, line, chunks)
            except socket.timeout:
                #print 'timed out'
                check_new_block(sock)
                check_fee_estimate(sock)
                
                if waiting_for_pong:
                    if (datetime.now() - last_ping).total_seconds() < ping_timeout_seconds:
                        continue
                    print 'server ping timed out'
                    sock.close()
                else:
                    if (datetime.now() - last_ping).total_seconds() < ping_interval_seconds:
                        continue
                    last_ping = datetime.now()
                    #print 'sending ping to server'
                    waiting_for_pong = True
                    sock.sendall('PING :hello world\r\n')
    except (IOError, EOFError) as e:
        print repr(e)
        time.sleep(5)
    finally:
        try:
            sock.close()
        except IOError:
            pass