def start_rpc():
global _rpc
_rpc = EthJsonRpc("127.0.0.1", config.CONFIG["rpc_port"])
try:
_rpc.eth_blockNumber()
except:
print "Couldn't connect to geth. RPC not started?"
print "Checking to see if geth node is active..."
try:
subprocess.check_call(["pgrep", "geth"])
except subprocess.CalledProcessError:
print "Geth does not appear to be running."
else:
print "Geth appears to be running, but we cannot connect."
raise IOError("Could not connect to geth instance.")
addrs = [config.CONFIG["vault_registry"]]
addrs.extend(data.get_vaults())
filter_id = _rpc.eth_newFilter(
from_block=data.get_last_update_block(),
to_block="latest" ,
address=addrs)
global _filter_id
_filter_id = filter_id
def index():
# price курс BTC_ETH
ticker = polo.api('returnTicker')
allprice = (ticker['BTC_ETH'])
price1 = allprice['last']
price = price1[0:6]
# priceUSD курс USDT_ETH
ticker2 = polo.api('returnTicker')
allprice2 = (ticker2['USDT_ETH'])
price2 = allprice2['last']
priceUSD = price2[0:5]
accounts = {}
totshare = 0
reward = BLOCK_REWARD - FEE
c = EthJsonRpc('localhost', 8545)
posts = c.eth_accounts()
conn = sqlite3.connect(DBSHARE_FILE)
db = conn.cursor()
for row in db.execute('SELECT miner, sum(diff) FROM share GROUP BY miner'):
accounts[row[0]] = row[1]
totshare += row[1]
for acc in accounts:
racc = accounts[acc] * reward / float(totshare)
conn.commit()
conn.close()
# запрос хэшрейтинга пула и количества блоков сети
c = EthJsonRpc('localhost', 8545)
Hashrate = c.eth_hashrate()
Blocks = c.eth_blockNumber()
return render_template('index.html',
price=price,
priceUSD=priceUSD,
Blocks=Blocks,
accounts=accounts,
Hashrate=Hashrate,
totshare=totshare,
cround=cround,
server=SERVER_POOL)
def index():
# price курс BTC_ETH
# priceUSD курс USDT_ETH
accounts = {}
totshare = 0
reward = BLOCK_REWARD - FEE
c = EthJsonRpc('172.16.0.7', 8545)
posts = c.eth_accounts()
conn = sqlite3.connect(DBSHARE_FILE)
db = conn.cursor()
for row in db.execute('SELECT miner, sum(diff) FROM share GROUP BY miner'):
accounts [row [0]] = row [1]
totshare += row [1]
for acc in accounts:
racc = accounts[acc] * reward / float (totshare)
conn.commit ()
conn.close ()
# запрос хэшрейтинга пула и количества блоков сети
c = EthJsonRpc('172.16.0.7', 8545)
Hashrate = c.eth_hashrate()
Blocks = c.eth_blockNumber()
return render_template('index.html', Blocks=Blocks, accounts=accounts, Hashrate=Hashrate, totshare=totshare, cround=cround, server=SERVER_POOL)
class ContractWrapper:
def __init__(
self,
the_code=False,
the_sig=None,
the_args=None,
the_address=False,
events_callback=False,
deploy_callback=False,
blocking_sleep_time=0.1,
rpc_host=DEFAULT_RPC_HOST,
rpc_port=DEFAULT_RPC_PORT,
settings_confirm_states={},
contract_address=False,
start_at_current_block=False,
auto_deploy=True,
contract_thread_sleep_time=1.0,
reorg_callback=False,
):
"""
Simple contract wrapper, assists with deploying contract, sending transactions, and tracking event logs.
Args:
- the_code: solidity code for contract that should be deployed, prior to any operations.
- the_address: address of already-deployed main contract.
- contract_address: contract address, from previous `deploy()` call.
- the_sig: optional constructor signature.
- the_args: optional constructor args.
- events_callback: callback for event messages e.g. `TheLog()`, `MintEvent()`, `LockupTokEvent()`, `TransferTokEvent()`.
- deploy_callback: callback for contract deploys.
- blocking_sleep_time: time to sleep when blocking and polling for a transaction receipt.
"""
self.block_details = {}
self.reorg_callback = reorg_callback
self.confirmation_tracker = {
} ## {'block_hash':{'prev_block_hash':xx, 'block_num':yy}}
self.done_block_nums = {} ## {confirm_state:set()}
self.done_transactions = {} ## {confirm_state:set()}
self.prev_block_num = {} ## {confirm_state:set()}
self.blocking_sleep_time = blocking_sleep_time
self.c = EthJsonRpc(rpc_host, rpc_port)
self.contract_thread_sleep_time = contract_thread_sleep_time
self.start_at_current_block = start_at_current_block
self.current_block_at_init = self.c.eth_blockNumber()
if self.start_at_current_block:
self.last_incoming_block = max(0, self.current_block_at_init - 1)
else:
self.last_incoming_block = 0
self.starting_block_num = self.last_incoming_block
self.msgs = {} ## {block_num:[msg, msg, msg]}
self.the_code = the_code
self.the_sig = the_sig
self.the_args = the_args
self.contract_address = the_address
assert self.the_code or self.contract_address
self.loop_block_num = -1
self.confirm_states = settings_confirm_states
self.events_callback = events_callback
self.pending_transactions = {} ## {tx:callback}
self.pending_logs = {}
self.latest_block_num = -1
self.latest_block_num_done = 0
self.send_transaction_queue = Queue()
self.is_deployed = False
if auto_deploy:
if the_address:
assert self.check_anything_deployed(the_address), (
'NOTHING DEPLOYED AT SPECIFIED ADDRESS:', the_address)
self.is_deployed = True
elif the_code:
self.deploy()
def check_anything_deployed(self, address):
""" Basic sanity check, checks if ANY code is deployed at provided address. """
if self.c.eth_getCode(address) == '0x0':
return False
return True
def deploy(
self,
the_sig=False,
the_args=False,
block=False,
deploy_from=False,
callback=False,
):
""" Deploy contract. Optional args_sig and args used to pass arguments to contract constructor."""
if the_sig is not False:
self.the_sig = the_sig
if the_args is not False:
self.the_args = the_args
assert self.the_code
if deploy_from is False:
deploy_from = self.c.eth_coinbase()
print('DEPLOYING_CONTRACT...', 'deploy_from:', deploy_from, 'the_sig:',
the_sig, 'the_args:', the_args)
# get contract address
xx = self.c.eth_compileSolidity(self.the_code)
#print ('GOT',xx)
compiled = get_compiled_code(xx)
contract_tx = self.c.create_contract(
from_=deploy_from,
code=compiled,
gas=3000000,
sig=self.the_sig,
args=self.the_args,
)
if block:
## NOTE: @yusef feel free to switch back to this method if you want:
#print('CONTRACT DEPLOYED, WAITING FOR CONFIRMATION')
#wait_for_confirmation(self.c, contract_tx)
print('BLOCKING FOR RECEIPT..')
while True:
receipt = self.c.eth_getTransactionReceipt(
contract_tx) ## blocks to ensure transaction is mined
if receipt:
break
sleep(self.blocking_sleep_time)
print('GOT RECEIPT')
else:
self.pending_transactions[contract_tx] = (callback,
self.latest_block_num)
self.contract_address = str(self.c.get_contract_address(contract_tx))
self.is_deployed = True
print('DEPLOYED', self.contract_address)
return self.contract_address
def loop_once(self):
assert self.is_deployed, 'Must deploy contract first.'
had_any_events = False
if self.c.eth_syncing():
print('BLOCKCHAIN_STILL_SYNCING')
return False
if self.events_callback is not False:
had_any_events = self.poll_incoming()
had_any_events = self.poll_outgoing() or had_any_events
num_fails = 0
while self.send_transaction_queue.qsize():
print('TRY_TO_SEND')
tries, args, kw = self.send_transaction_queue.get()
try:
self._send_transaction(*args, **kw)
except Exception as e:
print('FAILED_TO_SEND', e, tries, args, kw)
sleep(1) ## TODO
self.send_transaction_queue.put((tries + 1, args, kw))
break
return had_any_events
def check_for_reorg(
self,
block_num,
):
""" Check for reorg since last check, and reorgs during our reorg rewinding... """
print('START check_for_reorg', block_num)
return
block_num = ethereum.utils.parse_int_or_hex(block_num)
while True:
cur_num = block_num
had_reorg = False
while True:
if cur_num == self.starting_block_num:
break
assert cur_num >= self.starting_block_num, (
cur_num, self.starting_block_num)
## Get info for prev and current:
for x_block_num in [block_num, block_num - 1]:
if x_block_num not in self.block_details:
rh = self.c.eth_getBlockByNumber(x_block_num)
## Strip down to just a couple fields:
block_h = {
'timestamp':
ethereum.utils.parse_int_or_hex(rh['timestamp']),
'hash':
rh['hash'],
'parentHash':
rh['parentHash'],
'blockNumber':
x_block_num,
}
self.block_details[x_block_num] = block_h
## Check for reorg:
block_h = self.block_details[block_num]
if block_h['parentHash'] != self.block_details[
block_h['blockNumber'] - 1]['hash']:
print('!!! REORG', block_num, '->', cur_num)
cur_num -= 1
self.latest_done_block = cur_num
had_reorg = True
continue
break
## Rewind state if had_reorg:
if had_reorg and (self.reorg_callback is not False):
self.reorg_callback(cur_num)
self.last_incoming_block = cur_num - 1
## If had_reorg, loop again - to detect another reorg that occured while we tracked down the reorg...
if not had_reorg:
break
return had_reorg
def poll_incoming(self, chunk_size=50):
"""
https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_newfilter
- track buffer of events from old blocks
- track pointer to last processed block
"""
assert self.is_deployed, 'Must deploy contract first.'
#self.latest_block_num = self.c.eth_blockNumber()
from_block = self.last_incoming_block + 1
params = {
'from_block': fixed_int_to_hex(from_block),
'to_block': 'latest', #fixed_int_to_hex(from_block + chunk_size),
'address': self.contract_address,
}
print('eth_newFilter', 'from_block:', from_block, 'params:', params)
self.the_filter = str(self.c.eth_newFilter(**params))
num_blocks = len(self.msgs)
xx_msgs = self.c.eth_getFilterLogs(self.the_filter)
for msg in xx_msgs:
msg['blockNumber'] = ethereum.utils.parse_int_or_hex(
msg['blockNumber'])
if msg['blockNumber'] not in self.msgs:
self.msgs[msg['blockNumber']] = []
self.msgs[msg['blockNumber']].append(msg)
if num_blocks == len(self.msgs):
## Nothing new
assert not len(xx_msgs), len(xx_msgs)
return False
for do_state, state_num_blocks in self.confirm_states.items():
longest_confirm_state = max(self.confirm_states.values())
newest_block_num = max(max(self.msgs), self.last_incoming_block)
## Oldest to newest:
for nn in xrange(
max(1, self.last_incoming_block - state_num_blocks),
newest_block_num + 1,
):
if self.check_for_reorg(nn):
## Just wait for next call to poll_incoming() before resuming.
return False
if nn in self.msgs:
for msg in self.msgs[nn]:
print('EMIT', do_state, nn, msg['data'])
self.events_callback(msg=msg,
receipt=False,
received_via=do_state)
## Clear out old buffer:
for nn in self.msgs.keys():
if nn < newest_block_num - longest_confirm_state - 1:
del self.msgs[nn]
self.last_incoming_block = newest_block_num
return True
if False:
## START CHECKS
if do_state not in self.done_transactions:
self.done_transactions[do_state] = set()
self.done_block_nums[do_state] = set()
msg_block_num = ethereum.utils.parse_int_or_hex(msg['blockNumber'])
if cm == 0:
assert msg_block_num not in self.done_block_nums[do_state], (
'Seen block twice?',
msg_block_num,
)
self.done_block_nums[do_state].add(msg_block_num)
if do_state in self.prev_block_num:
assert msg_block_num >= self.prev_block_num[do_state], (
'REORG?',
msg_block_num,
self.prev_block_num[do_state],
)
self.prev_block_num[do_state] = msg_block_num
assert msg['transactionHash'] not in self.done_transactions[
do_state], (
'Seen transaction twice?',
msg_block_num,
msg['transactionHash'],
)
self.done_transactions[do_state].add(msg['transactionHash'])
## END CHECKS
return had_any_events
def _start_contract_thread(
self,
terminate_on_exception=False,
):
while True:
try:
had_any_events = self.loop_once()
except Exception as e:
print('-----LOOP_ONCE_EXCEPTION', e)
#exit(-1)
raise
if terminate_on_exception:
raise
continue
if not had_any_events:
print('NO_NEW_EVENTS')
sleep(self.contract_thread_sleep_time)
def start_contract_thread(
self,
start_in_foreground=False,
terminate_on_exception=False,
):
"""
Start ContractWrapper loop_once() in background thread, which (in that thread!) calls back to self.process_event()
"""
if start_in_foreground:
self._start_contract_thread(
terminate_on_exception=terminate_on_exception)
else:
self.t = Thread(
target=self._start_contract_thread,
args=(terminate_on_exception, ),
)
self.t.daemon = True
self.t.start()
def send_transaction(self, *args, **kw):
assert len(args) <= 2
if kw.get('block'):
self.send_transaction(*args, **kw)
else:
self.send_transaction_queue.put((0, args, kw))
def _send_transaction(
self,
args_sig,
args,
callback=False,
send_from=False,
block=False,
gas_limit=False,
gas_price=100,
value=100000000000,
):
"""
1) Attempt to send transaction.
2) Get first confirmation via transaction receipt.
3) Re-check receipt again after N blocks pass.
https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sendtransaction
"""
assert self.is_deployed, 'Must deploy contract first.'
print('SEND_TRANSACTION:', args_sig, args)
if send_from is False:
send_from = self.c.eth_coinbase()
send_to = self.contract_address
print('====TRANSACTION')
print('send_from', send_from)
print('send_to', send_to)
print('args_sig', args_sig)
print('args', args)
#print ('gas', gas_limit)
gas_limit = 1000000
gas_price = self.c.DEFAULT_GAS_PRICE
value = web3.utils.currency.to_wei(1, 'ether')
data = self.c._encode_function(args_sig, args)
data_hex = '0x' + data.encode('hex')
tx = self.c.eth_sendTransaction(
from_address=send_from,
to_address=send_to,
data=data_hex,
gas=gas_limit,
gas_price=gas_price,
value=value,
)
if block:
print('BLOCKING FOR RECEIPT..')
while True:
receipt = self.c.eth_getTransactionReceipt(
tx) ## blocks to ensure transaction is mined
if receipt:
break
sleep(self.blocking_sleep_time)
print('GOT RECEIPT')
#print ('GOT_RECEIPT', receipt)
#if receipt['blockNumber']:
# self.latest_block_num = max(ethereum.utils.parse_int_or_hex(receipt['blockNumber']), self.latest_block_num)
else:
self.pending_transactions[tx] = (callback, self.latest_block_num)
self.latest_block_num = self.c.eth_blockNumber()
return tx
def poll_outgoing(self):
"""
Confirm outgoing transactions.
"""
assert self.is_deployed, 'Must deploy contract first.'
had_any_events = False
if self.pending_transactions:
had_any_events = True
for tx, (callback,
attempt_block_num) in self.pending_transactions.items():
## Compare against the block_number where it attempted to be included:
if (attempt_block_num <= self.latest_block_num -
self.confirm_states['BLOCKCHAIN_CONFIRMED']):
continue
receipt = self.c.eth_getTransactionReceipt(tx)
if receipt is not None and 'blockNumber' in receipt:
actual_block_number = ethereum.utils.parse_int_or_hex(
receipt['blockNumber'])
else:
## TODO: wasn't confirmed after a long time.
actual_block_number = False
## Now compare against the block_number where it was actually included:
if (actual_block_number is not False) and (
actual_block_number >= self.latest_block_num -
self.confirm_states['BLOCKCHAIN_CONFIRMED']):
if callback is not False:
callback(receipt)
del self.pending_transactions[tx]
return had_any_events
def read_transaction(self, args_sig, value):
rr = self.c.call(self.c.eth_coinbase(), self.contract_address,
args_sig, value)
return rr
def sign(self, user_address, value):
rr = self.c.eth_sign(self.c.eth_coinbase(), self.contract_address,
user_address, value)
return rr
def main():
#
# check
#
assert os.path.isfile(CONTRACT) and 'contract file not found'
#
# now, just connect to our own blockchain node via rpc interface
#
try:
rpc = EthJsonRpc(RPC_HOST, RPC_PORT)
print('-' * 80)
print('client software: {}'.format(rpc.web3_clientVersion()))
print('block: {}'.format(rpc.eth_blockNumber()))
print('address: {}'.format(rpc.eth_coinbase()))
except:
print('unable to connect to rpc server at {}:{}'.format(
RPC_HOST, RPC_PORT))
sys.exit(-1)
#
# compile contract
#
print('-' * 80)
print('compiling contract...')
os.system('solcjs --bin {} > /dev/null'.format(CONTRACT))
with open(CONTRACT_COMPILED, 'r') as f:
contract_bin = f.read()
print(contract_bin)
#
# create contract
#
print('-' * 80)
lastBlock = rpc.eth_blockNumber()
contract_tx = rpc.create_contract(
rpc.eth_coinbase(), contract_bin,
gas=GAS) #send to address 0 by default to create contract
print('contract sent, waiting for it to be mined...')
#
# get current block count
#
numTry = 0
contract_addr = None
while True:
curBlock = rpc.eth_blockNumber()
if curBlock > lastBlock:
lastBlock = curBlock
numTry += 1
try:
contract_addr = rpc.get_contract_address(contract_tx)
if rpc.eth_getCode(
contract_addr
) == '0x0': #it means the binary code of the contract is stil under compiling
raise Exception()
print('contract mined (block: {})'.format(curBlock))
break
except:
print('new block detected, but contract not mined')
print('number of trying: {}'.format(numTry))
if numTry == WAIT_BLOCKS:
print('publishing contract failed')
sys.exit(-1)
time.sleep(1)
#
# return contract addr
#
print('-' * 80)
print('contract_address:\n\n\n--> {} <--\n\n'.format(contract_addr))
print('-' * 80)
def main():
#
# receive contract addr
#
if len(sys.argv) != 3:
print('Usage:\npython user.py <contract addr> <account addr>')
sys.exit(-1)
contract_addr = sys.argv[1]
account_addr = sys.argv[2]
#
# create rpc interface
#
try:
print('-' * 80)
rpc = EthJsonRpc(RPC_HOST, RPC_PORT)
print('client software: {}'.format(rpc.web3_clientVersion()))
print('block: {}'.format(rpc.eth_blockNumber()))
print('address: {}'.format(rpc.eth_coinbase()))
except:
print('unable to connect to rpc server at {}:{}'.format(
RPC_HOST, RPC_PORT))
sys.exit(-1)
#
# check contract is online
#
print('-' * 80)
if rpc.eth_getCode(contract_addr) == '0x0':
print('!!! contract code not available on blockchain !!!')
sys.exit(-1)
print('found contract on blockchain!')
#
# console
#
topics = []
print('-' * 80)
print('starting chat command line...')
while True:
#
# simply read input
#
sys.stdout.write('>> ')
command = sys.stdin.readline()
#
# quit?
#
if 'q' in command:
sys.exit(0)
#
# show help
#
elif command == '\n' or 'help' in command:
print('commands: help, send, status, topics, search, listen')
#
# compose new message
#
elif 'send' in command:
print('-' * 80)
print('[composing new message]')
sys.stdout.write('message....: ')
msg = sys.stdin.readline().strip()
sys.stdout.write('image file.: ')
img = sys.stdin.readline().strip()
sys.stdout.write('custom tags: ')
tag = sys.stdin.readline().strip()
print('-' * 80)
print('sending...')
# loading image
try:
image = Image.open(img)
except Exception as e:
print('loading {} failed'.format(img))
continue
# prediction
print('precessing image...')
label = ImageClassifier.predict(img)
if label is None:
print('classification failed')
continue
print('label: {}'.format(label))
tag += ' #' + label
bs = ImageHelper.imgToBytes(image)
tx = rpc.call_with_transaction(
account_addr,
contract_addr,
'setNewUserState(string,bytes,string)', [msg, bs, tag],
gas=GAS)
print('done, transaction id: {}'.format(tx))
#
# get own last post
#
elif 'status' in command:
print('-' * 80)
print('[receiving last post]')
userMessage, userImage, userTags = rpc.call(
contract_addr, 'getUserState(address)', [account_addr],
['string', 'bytes', 'string'])
if not userMessage:
print('nothing posted yet')
continue
print(' content: {}'.format(userMessage))
print(' tags...: {}'.format(userTags))
ImageHelper.bytesToImg(userImage).show()
#
# set tag filters
#
elif 'topics' in command:
topics = [t.strip() for t in command.split()[1:]]
if len(topics) == 0:
print('please provide actual topics after <topics> command')
continue
print('filter set for messages on topics: {}'.format(topics))
#
# search complete blockchain for messages with certain tags
#
elif 'search' in command:
if len(topics) == 0:
print('call topics first')
continue
curBlock = rpc.eth_blockNumber()
for i in range(curBlock + 1):
for trans in rpc.eth_getBlockByNumber(i)['transactions']:
res = Decoder.decodeABI(trans['input'])
if res is None:
continue
msg, code, tags = res
if all(t not in tags for t in topics):
continue
print('-' * 80)
print('message from user {} (block {}):'.format(
trans['from'], i))
print(' content: {}'.format(msg))
print(' tags...: {}'.format(tags))
ImageHelper.bytesToImg(code).show(title='{}'.format(tags))
#
# start listening for messages
#
elif 'listen' in command:
if len(topics) == 0:
print('call topics first')
continue
global LISTENING
LISTENING = True
curBlock = rpc.eth_blockNumber()
while LISTENING:
newBlock = rpc.eth_blockNumber()
if newBlock > curBlock:
print('new block detected ({})'.format(newBlock))
curBlock = newBlock
for trans in rpc.eth_getBlockByNumber(
newBlock)['transactions']:
res = Decoder.decodeABI(trans['input'])
if res is None:
continue
msg, code, tags = res
if all(t not in tags for t in topics):
continue
print('-' * 80)
print('message from user {} (block {}):'.format(
trans['from'], newBlock))
print(' content: {}'.format(msg))
print(' tags...: {}'.format(tags))
ImageHelper.bytesToImg(code).show(
title='{}'.format(tags))
time.sleep(1)
#
# default response
#
else:
print('command not recognized')
from ethjsonrpc import EthJsonRpc
c = EthJsonRpc('172.17.0.26', 8545)
print 'Net Version', c.net_version()
print 'web3 client version', c.web3_clientVersion()
print 'gas price', c.eth_gasPrice()
print 'block number', c.eth_blockNumber()
print 'eth syncing', c.eth_syncing()
from ethjsonrpc import EthJsonRpc
from ethjsonrpc.utils import wei_to_ether, ether_to_wei
c = EthJsonRpc('192.168.1.129', 8545)
from_address = "0x90b983390bef91b17f3a2f2d7eb9121c1214fc6b"
to_address = "0x16Ba1a0e4F6bA1E9B614ae8C25d101eA7441A0a1"
print c.net_version()
print c.web3_clientVersion()
print c.eth_gasPrice()
print c.eth_blockNumber()
print wei_to_ether(c.eth_getBalance(from_address))
print wei_to_ether(c.eth_getBalance(to_address))
# print c.web3_toWei(0.01, "ether")
amount = int(ether_to_wei(0.001))
print type(amount)
print amount
print hex(amount)
class EthereumBlockchain:
def __init__(self,
the_code = False,
the_sig = None,
the_args = None,
the_address = False,
rpc_host = DEFAULT_RPC_HOST,
rpc_port = DEFAULT_RPC_PORT,
background_thread_sleep_time = 1.0,
):
self.con = EthJsonRpc(rpc_host, rpc_port)
self.the_code = the_code
self.the_sig = the_sig
self.the_args = the_args
self.contract_address = the_address
assert self.the_code or self.contract_address
self.loop_once_started = False
self.sig_to_topic_id_cache = {}
self.send_transaction_queue = Queue()
self.background_thread_sleep_time = background_thread_sleep_time
self.pending_transactions = {} ## {tx:callback}
self.is_deployed = False
if the_address:
assert self.check_anything_deployed(the_address), ('NOTHING DEPLOYED AT SPECIFIED ADDRESS:', the_address)
self.is_deployed = True
elif the_code:
if auto_deploy:
self.deploy()
#def setup_create_pending_transaction(func):
# self._create_pending_transaction = func
#def setup_logic_callback(func):
# self._logic_callback = func
def event_sig_to_topic_id(self, sig):
""" Compute ethereum topic_ids from function signatures. """
if sig in self.sig_to_topic_id_cache:
return self.sig_to_topic_id_cache[sig]
name = sig[:sig.find('(')]
types = [x.strip().split()[0] for x in sig[sig.find('(')+1:sig.find(')')].split(',')]
topic_id = ethereum.utils.int_to_hex(ethereum.abi.event_id(name,types))
self.sig_to_topic_id_cache[sig] = topic_id
return topic_id
def setup_event_callbacks(self,
log_handlers,
pending_handlers,
):
self.log_handlers = log_handlers
self.log_handlers_hashed = {((x == 'DEFAULT') and 'DEFAULT' or self.event_sig_to_topic_id(x)):y
for x,y
in log_handlers.items()}
self.pending_handlers = pending_handlers
def logic_callback(self, msg, *args, **kw):
default_func = self.log_handlers_hashed.get('DEFAULT', False)
if 'topics' not in msg:
assert default_func is not False, ('Unknown topic_id and no DEFAULT handler.')
print ('PROXY logic_callback()', '->', default_func, kw)
default_func(msg, *args, **kw)
return
for topic in msg['topics']:
func = self.log_handlers_hashed.get(topic, default_func)
print ('PROXY logic_callback()', topic, '->', func)
assert func is not False, ('Unknown topic_id and no DEFAULT handler.', topic, kw)
func(msg, *args, **kw)
def simulate_pending(self,
args_sig,
args,
*aa, **bb):
"""
See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI#events
"""
## TODO: support indexed topics?
func = self.pending_handlers.get(args_sig, self.pending_handlers.get('DEFAULT', False))
print ('Proxy: simulate_pending()', args_sig, '->', func)
return func(args_sig, args, *aa, **bb)
def get_block_by_hash_callback(self, block_hash):
"""
Get block by blockHash.
https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getblockbyhash
"""
print ('bcc.get_block_by_hash_callback()', block_hash)
rh = self.con.eth_getBlockByHash(block_hash)
for k in ['number', 'timestamp']:
rh[k] = ethereum.utils.parse_int_or_hex(rh[k])
return rh
def get_logs_by_block_num_callback(self, block_num):
"""
Get event logs for a particular block num. It's OK if the block_num has an unexpected hash,
that'll be taken care of by caller.
https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getlogs
"""
print ('bcc.get_logs_by_block_num_callback()', block_num)
the_filter = self.con.eth_newFilter(from_block = fixed_int_to_hex(block_num),
to_block = fixed_int_to_hex(block_num),
address = self.contract_address,
)
rr = self.con.eth_getFilterLogs(str(the_filter))
rr2 = []
for msg in rr:
#assert 'topics' in msg, list(sorted(msg.keys()))
got_num = ethereum.utils.parse_int_or_hex(msg['blockNumber'])
if got_num != block_num:
continue
msg['data'] = solidity_string_decode(msg['data'])
msg['blockNumber'] = got_num
msg["logIndex"] = ethereum.utils.parse_int_or_hex(msg['logIndex'])
msg["transactionIndex"] = ethereum.utils.parse_int_or_hex(msg['transactionIndex'])
#msg_data = loads_compact(msg['data'])
#payload_decoded = loads_compact(msg_data['payload'])
rr2.append(msg)
rr = rr2
return rr
def get_latest_block_number(self):
print ('bcc.get_latest_block_number()')
bn = self.con.eth_blockNumber()
return bn
def get_latest_block_callback(self):
"""
Returns the single latest block. Missing intermediate blocks will be automatically looked up by caller.
"""
print ('bcc.get_latest_block_callback()')
bn = self.get_latest_block_number()
block = self.con.eth_getBlockByNumber(bn)
return block
def check_anything_deployed(self, address):
""" Basic sanity check, checks if ANY code is deployed at provided address. """
print ('bcc.check_anything_deployed()', address)
if self.con.eth_getCode(address) == '0x0':
return False
return True
def deploy(self,
the_sig = False,
the_args = False,
block = False,
deploy_from = False,
callback = False,
):
""" Deploy contract. Optional args_sig and args used to pass arguments to contract constructor."""
print ('bcc.deploy()')
if the_sig is not False:
self.contract_sig = the_sig
if the_args is not False:
self.contract_args = the_args
assert self.the_code
if deploy_from is False:
deploy_from = self.con.eth_coinbase()
print ('DEPLOYING_CONTRACT...', 'deploy_from:', deploy_from, 'the_sig:', the_sig, 'the_args:', the_args)
# get contract address
xx = self.con.eth_compileSolidity(self.the_code)
#print ('GOT',xx)
compiled = None
try:
compiled = xx['code']
except KeyError:
# geth seems to like putting the compiler output into an inner dict keyed by input filename,
# e.g {'CCCoinToken.sol': {'code': '...', 'etc': '...'}
for k, v in xx.iteritems():
if isinstance(v, dict) and 'code' in v:
compiled = v['code']
break
assert compiled
contract_tx = self.con.create_contract(from_ = deploy_from,
code = compiled,
gas = 3000000,
sig = self.contract_sig,
args = self.contract_args,
)
if block:
## NOTE: @yusef feel free to switch back to this method if you want:
#print('CONTRACT DEPLOYED, WAITING FOR CONFIRMATION')
#wait_for_confirmation(self.c, contract_tx)
print ('BLOCKING FOR RECEIPT..')
while True:
receipt = self.con.eth_getTransactionReceipt(contract_tx) ## blocks to ensure transaction is mined
if receipt:
break
sleep(self.blocking_sleep_time)
print ('GOT RECEIPT')
else:
self.pending_transactions[contract_tx] = callback
self.contract_address = str(self.con.get_contract_address(contract_tx))
self.is_deployed = True
print ('DEPLOYED', self.contract_address)
return self.contract_address
def send_transaction(self, *args, **kw):
"""
1) If possible create simulated outputs of transactions, to use as pending state.
2) Queue the transaction for blockchain commit.
Used for e.g.:
- addLog(bytes)
- mintTokens(address, uint, uint, uint, uint, uint, uint)
- withdrawTok(bytes)
- lockupTok(bytes)
"""
print ('bcc.send_transaction()')
assert len(args) <= 2
#assert self.loop_once_started, 'loop_once() not started?'
## Potentially slow blocking call to commit it to the blockchain:
if kw.get('block'):
## Send transaction in blocking mode, and grab actual event logs that are committed:
rh = self.inner_send_transaction(*args, **kw)
pending_logs = rh['pending_logs']
is_pending = False
else:
## Run callbacks, return simulated event logs where possible:
self.send_transaction_queue.put((0, args, kw))
pending_logs = self.simulate_pending(*args, **kw)
is_pending = True
## Run logic_callback() against pending transactions:
for log in pending_logs:
print ('CALLING', 'is_pending:', is_pending, 'is_noop:', log.get('is_noop', False))
self.logic_callback(log,
is_pending = is_pending,
is_noop = log.get('is_noop', False)
)
return pending_logs
def inner_send_transaction(self,
args_sig,
args,
callback = False,
send_from = False,
block = False,
gas_limit = False,
gas_price = 100,
value = 100000000000,
):
"""
1) Attempt to send transaction.
2) Get first confirmation via transaction receipt.
3) Re-check receipt again after N blocks pass.
https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sendtransaction
"""
print ('bcc.inner_send_transaction()')
assert self.is_deployed, 'Must deploy contract first.'
print ('SEND_TRANSACTION:', args_sig, args)
if send_from is False:
send_from = self.con.eth_coinbase()
send_to = self.contract_address
print ('====TRANSACTION')
print ('send_from', send_from)
print ('send_to', send_to)
print ('args_sig', args_sig)
print ('args', args)
#print ('gas', gas_limit)
gas_limit = 1000000
gas_price = self.con.DEFAULT_GAS_PRICE
value = web3.utils.currency.to_wei(1,'ether')
data = self.con._encode_function(args_sig, args)
data_hex = '0x' + data.encode('hex')
tx = self.con.eth_sendTransaction(from_address = send_from,
to_address = send_to,
data = data_hex,
gas = gas_limit,
gas_price = gas_price,
value = value,
)
if block:
print ('BLOCKING FOR RECEIPT..')
while True:
receipt = self.con.eth_getTransactionReceipt(tx) ## blocks to ensure transaction is mined
if receipt:
break
sleep(self.blocking_sleep_time)
print ('GOT RECEIPT')
#print ('GOT_RECEIPT', receipt)
#if receipt['blockNumber']:
# self.latest_block_num = max(ethereum.utils.parse_int_or_hex(receipt['blockNumber']), self.latest_block_num)
else:
self.pending_transactions[tx] = callback
#self.latest_block_num = self.con.eth_blockNumber()
return {'tx':tx}
def poll_outgoing_receipts(self):
"""
Check for transaction receipts on transactions sent from this node.
TODO - why not replace this with just watching for incoming transactions???
"""
assert self.is_deployed, 'Must deploy contract first.'
had_any_events = False
if self.pending_transactions:
had_any_events = True
for tx, callback in self.pending_transactions.items():
receipt = self.con.eth_getTransactionReceipt(tx)
if receipt is not None and 'blockNumber' in receipt:
actual_block_number = ethereum.utils.parse_int_or_hex(receipt['blockNumber'])
else:
## TODO: wasn't confirmed after a long time.
actual_block_number = False
## Now compare against the block_number where it was actually included:
if actual_block_number is not False:
if callback is not False:
callback(receipt)
del self.pending_transactions[tx]
return had_any_events
def _start_background_thread(self,
terminate_on_exception = False,
):
last_event = False
while True:
try:
had_any_events = self.loop_once_blockchain()
except Exception as e:
print ('-----LOOP_ONCE_EXCEPTION', e)
#exit(-1)
raise
if terminate_on_exception:
raise
continue
if had_any_events:
last_event = time()
else:
print ('NO_NEW_EVENTS', last_event and (time() - last_event))
sleep(self.background_thread_sleep_time)
def start_background_thread(self,
start_in_foreground = False,
terminate_on_exception = False,
):
"""
Start ContractWrapper loop_once() in background thread, which (in that thread!) calls back to self.process_event()
"""
if start_in_foreground:
self._start_background_thread(terminate_on_exception = terminate_on_exception)
else:
self.t = Thread(target = self._start_background_thread,
args = (terminate_on_exception,),
)
self.t.daemon = True
self.t.start()
def loop_once_blockchain(self):
## Check for available write receipts:
#self.poll_outgoing_receipts()
self.loop_once_started = True
## Do write transactions transactions:
while self.send_transaction_queue.qsize():
print ('TRY_TO_SEND')
tries, args, kw = self.send_transaction_queue.get()
try:
self.inner_send_transaction(*args, **kw)
except Exception as e:
print ('FAILED_TO_SEND', e, tries, args, kw)
sleep(1) ## TODO
self.send_transaction_queue.put((tries + 1, args, kw))
break
import os, sys, array, time
from bottle import response, route, run, static_file, template
from ethjsonrpc import EthJsonRpc
geth = EthJsonRpc('127.0.0.1', 8545)
print "blockNumber: ", geth.eth_blockNumber()
# TODO calculate from parameters
paymentHash = "0011223344556677889900112233445566778899001122334455667788990011"
paymentHashHex = paymentHash.decode("hex")
# You need to change this deployed address whenever it changes
# Geth
deployedMasterPay = '3bd2b739aa327d8bab879d9767468082f9ad0cac'
# TestRPC
# deployedMasterPay = 0xd715bca35d2b0c07419a8432e881d262c3dfd497;
# You need to change this binary whenever it changes.
productPaymentCompiled = '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'
# TODO get it from API
productPriceWei = 84000000000000000000 # 84 Ether
durationSeconds = 86400
def waitForTransaction(geth, txnHash, interval=1):
"Wait for transaction to be mined"
while geth.eth_getTransactionByHash(txnHash)['transactionIndex'] == None:
print "Sleeping for", interval, " second"
time.sleep(interval)
return
def main():
CONTRACT = sys.argv[1]
#
# just load contract code from file (e.g. contract.sol)
#
assert os.path.isfile(CONTRACT) and 'contract file not found ({})'.format(
CONTRACT)
with open(CONTRACT, 'r') as f:
CONTRACT_CODE = f.read()
#
# now, just connect to our own blockchain node via rpc interface
#
try:
rpc = EthJsonRpc(RPC_HOST, RPC_PORT)
print('-' * 80)
print('client software: {}'.format(rpc.web3_clientVersion()))
print('block: {}'.format(rpc.eth_blockNumber()))
print('address: {}'.format(rpc.eth_coinbase()))
except:
print('unable to connect to rpc server at {}:{}'.format(
RPC_HOST, RPC_PORT))
sys.exit(-1)
#
# compile contract
#
print('-' * 80)
print('compiling contract...')
compiled = rpc.eth_compileSolidity(CONTRACT_CODE)
contract_bin = compiled['code']
#
# create contract
#
print('-' * 80)
lastBlock = rpc.eth_blockNumber()
contract_tx = rpc.create_contract(rpc.eth_coinbase(),
contract_bin,
gas=GAS)
print('contract sent, waiting for it to be mined...')
#
# get current block count
#
numTry = 0
contract_addr = None
while True:
curBlock = rpc.eth_blockNumber()
if curBlock > lastBlock:
lastBlock = curBlock
numTry += 1
try:
contract_addr = rpc.get_contract_address(contract_tx)
if rpc.eth_getCode(contract_addr) == '0x0':
raise Exception()
print('contract mined (block: {})'.format(curBlock))
break
except:
print('new block detected, but contract not mined')
if numTry == WAIT_BLOCKS:
print('publishing contract failed')
sys.exit(-1)
time.sleep(1)
#
# return contract addr
#
print('-' * 80)
print('contract_address:\n\n\n--> {} <--\n\n'.format(contract_addr))
print('-' * 80)
