def get_last_block_number(self):
val = KeyValue(self.db).get_by_section_key('blocks',
'last_block_number')
if not val:
return 0
last_block = val['last_block']
return last_block
def __init__(self):
self.communication = OracleCommunication()
self.db = OracleDb()
self.btc = BitcoinClient()
self.kv = KeyValue(self.db)
self.task_queue = TaskQueue(self.db)
self.handlers = op_handlers
self.signer = TransactionSigner(self)
def __init__(self):
self.db = OracleDb()
self.btc = BitcoinClient()
self.kv = KeyValue(self.db)
self.task_queue = TaskQueue(self.db)
self.handlers = op_handlers
self.signer = TransactionSigner(self)
last_received = self.kv.get_by_section_key('fastcast', 'last_epoch')
if not last_received:
self.kv.store('fastcast', 'last_epoch', {'last': 0})
self.set_fastcast_address()
def set_last_block(self):
last_block_number = self.btc.get_block_count()
# We need to satisfy a condition on looking only for blocks with at
# least CONFIRMATIONS of confirmations
satisfied = False
while not satisfied:
block_hash = self.btc.get_block_hash(last_block_number)
block = self.btc.get_block(block_hash)
if block['confirmations'] >= CONFIRMATIONS:
satisfied = True
else:
last_block_number -= 1
KeyValue(self.db).store('blocks', 'last_block_number',
{'last_block': last_block_number})
return last_block_number
def __init__(self):
self.db = OracleDb()
self.btc = BitcoinClient()
self.kv = KeyValue(self.db)
self.task_queue = TaskQueue(self.db)
self.handlers = op_handlers
self.signer = TransactionSigner(self)
last_received = self.kv.get_by_section_key('fastcast', 'last_epoch')
if not last_received:
self.kv.store('fastcast', 'last_epoch', {'last': 0})
if not self.kv.exists('fastcast', 'address'):
pub, priv = generateKey()
self.kv.store('fastcast', 'address', {"pub": pub, "priv": priv})
logging.info('fastcast pubkey: %r' %
self.kv.get_by_section_key('fastcast', 'address')['pub'])
def run(self):
if not ORACLE_ADDRESS:
self.oracle_address = self.kv.get_by_section_key(
'config', 'ORACLE_ADDRESS')
if self.oracle_address is None:
new_addr = self.btc.server.getnewaddress()
self.oracle_address = new_addr
logging.error("created a new address: '%s'" % new_addr)
self.kv.store('config', 'ORACLE_ADDRESS', new_addr)
else:
self.oracle_address = ORACLE_ADDRESS
logging.info("my fee: %r" % ORACLE_FEE)
logging.info("my bitcoin address is %s" % self.oracle_address)
logging.info("my bitcoin pubkey: %r" %
self.btc.validate_address(self.oracle_address)['pubkey'])
while True:
# Proceed all requests
requests = getMessages()
requests = requests['results']
requests = self.filter_requests(requests)
for prev_request in requests:
try:
request = self.prepare_request(prev_request)
except MissingOperationError:
logging.info(
'message doesn\'t have operation field, invalid')
logging.info(prev_request)
continue
except FastcastProtocolError:
logging.info('message does not have all required fields')
logging.info(prev_request)
continue
self.handle_request(request)
task = self.task_queue.get_oldest_task()
while task is not None:
self.handle_task(task)
self.task_queue.done(task)
task = self.task_queue.get_oldest_task()
try:
new_block = self.get_new_block()
except:
new_block = None
logging.exception('problematic block!')
if new_block:
handlers = op_handlers.iteritems()
addresses_per_handler = {}
all_addresses = set()
# Every handler can wait for transactions occuring on some addresses
for name, handler in handlers:
addresses = handler(self).get_observed_addresses()
addresses_per_handler[name] = addresses
for address in addresses:
all_addresses.add(address)
transactions = self.btc.get_transactions_from_block(
new_block, list(all_addresses))
handlers = op_handlers.iteritems()
for name, handler in handlers:
addresses = addresses_per_handler[name]
handler_transactions = []
for address in addresses:
if address in transactions:
handler_transactions.extend(transactions[address])
handler(self).handle_new_transactions(handler_transactions)
KeyValue(self.db).update('blocks', 'last_block_number',
{'last_block': new_block['height']})
time.sleep(10)
