def setUp(self): with open('compiled.evm') as f: compiled = f.read().rstrip() self.c = EthJsonRpc() self.c._call('evm_reset') self.cb = self.c.eth_coinbase() self.contract_addr = self.AddressToIPv4(self.cb, compiled)
class EthLocust(Locust): ''' This is the abstract Locust class which should be subclassed. It provides an Ethereum JSON-RPC client that can be used for requests that will be tracked in Locust's statistics. ''' def __init__(self, *args, **kwargs): super(EthLocust, self).__init__(*args, **kwargs) server, port = self.host.split(':') if int(port) == 443: tls_flag = True else: tls_flag = False self.client = EthJsonRpc(server, port, tls=tls_flag) self.addresses = self.get_target_address_list() def get_target_address_list(self, count=100): ''' As part of the initialization, we build up a list of 1k addresses which will be the targets of the getBal call. We do it as part of the initialization so that we dont slow down the concurrent tests. ''' addrs = [] block = self.client.eth_getBlockByNumber() while len(addrs) < count: block = self.client.eth_getBlockByHash(block['parentHash']) if block['transactions'] is not None: addrs += [ t['to'] for t in block['transactions'] if t['to'] is not None ] # Use a set to dedupe commonly used addresses (coinbase, poloniex, etc) return list(set(addrs))
def credits(): reward = BLOCK_REWARD - FEE accounts = {} totshare = 0 worker = {} 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 row in db.execute('SELECT miner, worker FROM share GROUP BY miner'): worker[row[0]] = row[1] for acc in accounts: racc = accounts[acc] * reward / float(totshare) conn.commit() conn.close() return render_template('credits.html', cround=cround, worker=worker, accounts=accounts, posts=posts, totshare=totshare, server=SERVER_POOL)
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 check_anything_deployed(address): from ethjsonrpc import EthJsonRpc c = EthJsonRpc(DEFAULT_RPC_HOST, DEFAULT_RPC_PORT) if c.eth_getCode(address) == '0x0': print('NOTHING DEPLOYED AT SPECIFIED ADDRESS:', address) return False return True
def setup(f, host, port, add_dev_code, contract_dir, gas, gas_price, private_key): with open(f) as data_file: instructions = json.load(data_file) json_rpc = EthJsonRpc(host, port) coinbase = json_rpc.eth_coinbase()["result"] if private_key: print "Your address for your private key: {}".format( privtoaddr(private_key.decode('hex')).encode('hex')) else: print "Your coinbase: {}".format(coinbase) for instruction in instructions: print 'Your balance: {} Wei'.format( int(json_rpc.eth_getBalance(coinbase)['result'], 16)) if instruction["type"] == "deployment": deploy_code( json_rpc, coinbase, instruction["file"], instruction["constructorParams"] if "constructorParams" in instruction else None, instruction["addresses"] if "addresses" in instruction else None, add_dev_code == "true", contract_dir, int(gas), int(gas_price), private_key) elif instruction["type"] == "transaction": do_transaction(json_rpc, coinbase, instruction["contract"], instruction["name"], instruction["params"], int(gas), int(gas_price), private_key) elif instruction["type"] == "assertion": do_assertion(json_rpc, instruction["contract"], instruction["name"], instruction["params"], instruction["return"]) for contract_name, contract_address in addresses.iteritems(): print 'Contract {} was created at address {}.'.format( contract_name, contract_address)
def __init__(self, *args, **kwargs): super(EthLocust, self).__init__(*args, **kwargs) server, port = self.host.split(':') if int(port) == 443: tls_flag = True else: tls_flag = False self.client = EthJsonRpc(server, port, tls=tls_flag) self.addresses = self.get_target_address_list()
def main01(): load_dotenv() eth_host = os.environ.get('ETH_HOST') eth_port = os.environ.get('ETH_PORT') contract_addr = os.environ.get('CONTRACT_ADDR') c = EthJsonRpc(eth_host, eth_port) # data = c.call(contract_addr, 'rooms(uint256)', [0], ['Room']) # print(data) data = c.call(contract_addr, 'name()', [], ['string']) print(decode(data, 'string'))
def __init__(self, ip='127.0.0.1', port=8545, contract_id=None): self.connection = EthJsonRpc(ip, port) self.contract_id = contract_id self.abi_def = [{ "constant": False, "inputs": [], "name": "dumpSaltedHashArray", "outputs": [{ "name": "Hashes", "type": "bytes32[]" }, { "name": "Salts", "type": "bytes32[]" }, { "name": "Timestamps", "type": "uint256[]" }], "payable": False, "type": "function" }, { "constant": False, "inputs": [{ "name": "Hash", "type": "bytes32" }, { "name": "Salt", "type": "bytes32" }], "name": "addHash", "outputs": [], "payable": False, "type": "function" }, { "inputs": [{ "name": "Hash", "type": "bytes32" }, { "name": "Salt", "type": "bytes32" }], "payable": False, "type": "constructor" }]
def get_lang_version(): minimal_code = \ """ pragma solidity ^0.4.6; contract CCCoin { event MainLog(bytes); function addLog(bytes val) { MainLog(val); } } """ from ethjsonrpc import EthJsonRpc c = EthJsonRpc('127.0.0.1', 9999) c.eth_compileSolidity(minimal_code)['info']['compilerVersion']
def send_payment(command): to_address = command["data"]["to_address"] from_address = command["data"]["from_address"] amount = float(command["data"]["amount"]) amount_wei = int(ether_to_wei(amount)) print "Sending {0} ETH {1} Wei to {2}".format(amount, amount_wei, to_address) client = EthJsonRpc(geth_rpc_ip, 8545) print client.transfer(from_address, to_address, amount_wei)
def eth_json_rpc(eth_rpc_host, eth_rpc_port): """ An instance of EthJsonRpc that uses the host and port specified with the `--rpc-host` and `--rpc-port` flags (or an ephemeral testrpc instance if `--rpc-port` is not given) """ return EthJsonRpc(eth_rpc_host, eth_rpc_port)
def setUp(self): with open('compiled.evm') as f: compiled = f.read().rstrip() self.c = EthJsonRpc() self.c._call('evm_reset') self.cb = self.c.eth_coinbase() self.contract_addr = self.AddressToUrl(self.cb, compiled)
class AddressToUrlTestCase(unittest.TestCase): def setUp(self): with open('compiled.evm') as f: compiled = f.read().rstrip() self.c = EthJsonRpc() self.c._call('evm_reset') self.cb = self.c.eth_coinbase() self.contract_addr = self.AddressToUrl(self.cb, compiled) def tearDown(self): pass def test_set(self): url = 'http://www.yahoo.com' self.set_url(self.cb, self.contract_addr, url) result = self.get_url(self.contract_addr, self.cb[2:]) self.assertEqual(url, result) def test_set_clear(self): url = 'http://www.yahoo.com' self.set_url(self.cb, self.contract_addr, url) result = self.get_url(self.contract_addr, self.cb[2:]) self.assertEqual(url, result) self.set_url(self.cb, self.contract_addr, '') result = self.get_url(self.contract_addr, self.cb[2:]) self.assertEqual('', result) def test_get(self): result = self.get_url(self.contract_addr, self.cb[2:]) self.assertEqual('', result) ################################################################################ def AddressToUrl(self, sender, compiled): ''' constructor ''' sig = 'AddressToUrl()' args = [] tx = self.c.create_contract(sender, compiled, 300000, sig, args) return self.c.get_contract_address(tx) def set_url(self, sender, contract_addr, ip): sig = 'set_url(string)' args = [ip] self.c.call_with_transaction(sender, contract_addr, sig, args) def get_url(self, contract_addr, addr): sig = 'get_url(address)' args = [addr] result_types = ['string'] return self.c.call(contract_addr, sig, args, result_types)[0]
def miner(): # ЧТО НЕ СДЕЛАНО! # Необходимо вывести количество workers, общий хэшрейт майнера # Необходимо сформировать таблицу название workers,, хэшрейт workers, усреднённый хэшрейт workers, шары workers address = request.form['address'].replace('0x', '') payouts = [] paylock.acquire() reward = BLOCK_REWARD - FEE accounts = {} totshare = 0 worker = {} 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 row in db.execute('SELECT miner, worker FROM share GROUP BY miner'): worker[row[0]] = row[1] for acc in accounts: workers = worker[acc] racc = accounts[acc] * reward / float(totshare) conn.commit() conn.close() conn2 = sqlite3.connect(DBPAYOUT_FILE) db2 = conn2.cursor() for row in db2.execute('SELECT * FROM payout WHERE miner=?', [address]): payouts.append(row) conn2.commit() conn2.close() paylock.release() if address in cround['accounts']: rshare = cround['accounts'][address] else: rshare = 0 print rshare, cround return render_template('miner.html', address=address, workers=workers, payouts=payouts, shares=rshare)
def test_getters(): minimal_code = \ """ pragma solidity ^0.4.6; contract Test { uint256 public the_var = 5; } """ from ethjsonrpc import EthJsonRpc c = EthJsonRpc('127.0.0.1', 9999) xx = c.eth_compileSolidity(minimal_code) compiled = xx['code'] contract_tx = c.create_contract( c.eth_coinbase(), compiled, gas=3000000, ) contract_address = str(c.get_contract_address(contract_tx)) rr = c.call( address=contract_address, sig='the_var()', args=[], result_types=['uint256'], ) assert rr[0] == 5, rr print('PASSED')
def get_ethclient(host): if host == "": return None if "https" in host: _port = 443 _host = host.split(':')[1].split('//')[1] else: _port = host.split(':')[2] _host = host.split(':')[1].split('//')[1] try: client = EthJsonRpc(host=_host, port=_port, tls=True) except Exception as e: QMessageBox.information(self,"Information",str(e)) return if client.net_listening(): return client else: return
def get_ethclient(self): host = self.comboBox_webNo.text() if host == "": return None if "https" in host: _port = 443 _host = host.split(':')[1].split('//')[1] else: _port = host.split(':')[2] _host = host.split(':')[1].split('//')[1] try: self.client = EthJsonRpc(host=_host, port=_port, tls=True) except Exception as e: QMessageBox.information(self, "Information", str(e)) return if self.client.net_listening(): return self.client else: QMessageBox.warning("Warning", "节点链接失败,请检查节点")
def __init__(self, protocol, host, port, add_dev_code, verify_code, contract_dir, gas, gas_price, private_key): self.pp = PreProcessor() self.s = t.state() self.s.block.number = 1150000 # Homestead t.gas_limit = int(gas) self.json_rpc = EthJsonRpc(protocol=protocol, host=host, port=port) if private_key: self.user_address = '0x' + privtoaddr( private_key.decode('hex')).encode('hex') else: self.user_address = self.json_rpc.eth_coinbase()["result"] self.add_dev_code = add_dev_code == 'true' self.verify_code = verify_code == 'true' self.contract_dir = contract_dir self.gas = int(gas) self.gas_price = int(gas_price) self.private_key = private_key self.contract_addresses = {} self.contract_abis = {}
def main(): # # create rpc interface # try: rpc = EthJsonRpc(RPC_HOST, RPC_PORT) except: print('unable to connect to rpc server at {}:{}'.format( RPC_HOST, RPC_PORT)) sys.exit(-1) method = sys.argv[1] if method == "newContract": owner = sys.argv[2] partner = sys.argv[3] text = sys.argv[4] tx = rpc.call_with_transaction(owner, CONTRACT_STORAGE_ADDRESS, 'createNewContract(string,string)', [partner, text], gas=GAS) print(format(tx)) elif method == "contractData": trans_addr = sys.argv[2] trans = rpc.eth_getTransactionByHash(trans_addr) res = Decoder.decodeABI(trans['input'], 'createNewContract(string,string)', ['string', 'string']) print(res) elif method == "newUser": address = sys.argv[2] dataString = sys.argv[3] tx = rpc.call_with_transaction(address, USER_STORAGE_ADDRESS, 'setUserIdentityDocs(string)', [dataString], gas=GAS) elif method == "identification": account_addr = sys.argv[2] transactionHashes, identityDocuments = rpc.call( USER_STORAGE_ADDRESS, 'getUser(address)', [account_addr], ['string', 'string']) print(identityDocuments) elif method == "accounts": account_id = sys.argv[2] print(rpc.eth_accounts()[int(account_id)]) else: print("method not recognized!")
def get_eth(key_from, task_price): # Тут стучимся в эфир compiled = u"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" c = EthJsonRpc('127.0.0.1', 8545) c.net_version() # continued from above contract_tx = c.create_contract(settings.GENERAL_KEY, compiled, gas=300000) contract_addr = c.get_contract_address(contract_tx) value = task_price/(10**18) tx = c.call_with_transaction(settings.GENERAL_KEY, contract_addr, 'transferFrom({0}, {1}, {2})'.format( settings.GENERAL_KEY, key_from, value), ['Hello, world']) return tx
def __init__(self, protocol, host, port, gas, gas_price, contract_dir, optimize, account, private_key_path): # establish rpc connection self.json_rpc = EthJsonRpc(protocol=protocol, host=host, port=port) self.solidity = _solidity.solc_wrapper() self._from = None self.private_key = None # set sending account if account: self._from = self.add_0x(account) elif private_key_path: with open(private_key_path, 'r') as private_key_file: self.private_key = private_key_file.read().strip() self._from = self.add_0x( privtoaddr(self.private_key.decode('hex')).encode('hex')) else: accounts = self.json_rpc.eth_accounts()['result'] if len(accounts) == 0: raise ValueError('No account unlocked') self._from = self.add_0x(accounts[0]) # account address in right format if not self.is_address(self._from): raise ValueError('Account address is wrong') self.optimize = optimize self.contract_dir = contract_dir self.gas = gas self.gas_price = gas_price # references dict maps labels to addresses self.references = {} # abis dict maps addresses to abis self.abis = {} # total consumed gas self.total_gas = 0 self.log('Instructions are sent from address: {}'.format(self._from)) balance = self.hex2int( self.json_rpc.eth_getBalance(self._from)['result']) self.log('Address balance: {} Ether / {} Wei'.format( balance / 10.0**18, balance))
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 synchronize(backend, strategy, user, response, is_new=False, *args, **kwargs): compiled = u"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" c = EthJsonRpc('127.0.0.1', 8545) c.net_version() # continued from above contract_tx = c.create_contract(settings.GENERAL_KEY, compiled, gas=300000) contract_addr = c.get_contract_address(contract_tx) balans = c.call_with_transaction( settings.GENERAL_KEY, contract_addr, 'eth.getBalance("{0}")'.format(settings.GENERAL_KEY), ['Hello, world']) user.balans = balans user.save() return True
def setup(host, port, contract, gas, gas_price, private_key): gas = int(gas) gas_price = int(gas_price) json_rpc = EthJsonRpc(host, port) coinbase = json_rpc.eth_coinbase()["result"] if private_key: print "Your address for your private key: {}".format( privtoaddr(private_key.decode('hex')).encode('hex')) else: print "Your coinbase: {}".format(coinbase) contract_abi = json.loads( '[{"inputs": [], "constant": true, "type": "function", "name": "startDate", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "CROWDFUNDING_PERIOD", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": false, "type": "function", "name": "emergencyCall", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [{"type": "address", "name": "singularDTVFundAddress"}, {"type": "address", "name": "singularDTVTokenAddress"}], "constant": false, "type": "function", "name": "setup", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [], "constant": false, "type": "function", "name": "withdrawFunding", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "fundBalance", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "singularDTVFund", "outputs": [{"type": "address", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "baseValue", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "TOKEN_TARGET", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "singularDTVToken", "outputs": [{"type": "address", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "owner", "outputs": [{"type": "address", "name": ""}]}, {"inputs": [{"type": "uint256", "name": "valueInWei"}], "constant": false, "type": "function", "name": "changeBaseValue", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [{"type": "address", "name": ""}], "constant": true, "type": "function", "name": "investments", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": false, "type": "function", "name": "fund", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "stage", "outputs": [{"type": "uint8", "name": ""}]}, {"inputs": [], "constant": false, "type": "function", "name": "updateStage", "outputs": [{"type": "uint8", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "valuePerShare", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "TOKEN_LOCKING_PERIOD", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "campaignEndedSuccessfully", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "workshopWaited2Years", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [], "constant": true, "type": "function", "name": "CAP", "outputs": [{"type": "uint256", "name": ""}]}, {"inputs": [], "constant": false, "type": "function", "name": "withdrawForWorkshop", "outputs": [{"type": "bool", "name": ""}]}, {"inputs": [], "type": "constructor"}]' ) translator = ContractTranslator(contract_abi) data = translator.encode("emergencyCall", ()).encode("hex") bc_return_val = json_rpc.eth_call(to_address=contract, data=data)["result"] result_decoded = translator.decode("emergencyCall", bc_return_val[2:].decode("hex"))[0] if result_decoded: if private_key: address = privtoaddr(private_key.decode('hex')) nonce = int( json_rpc.eth_getTransactionCount('0x' + address.encode('hex')) ["result"][2:], 16) tx = Transaction(nonce, gas_price, gas, contract, 0, data.decode('hex')) tx.sign(private_key.decode('hex')) raw_tx = rlp.encode(tx).encode('hex') transaction_hash = json_rpc.eth_sendRawTransaction( "0x" + raw_tx)["result"] else: transaction_hash = json_rpc.eth_sendTransaction( coinbase, to_address=contract, data=data, gas=gas, gas_price=gas_price)["result"] wait_for_transaction_receipt(json_rpc, transaction_hash) print 'Transaction {} for contract {} completed.'.format( "emergencyCall", contract)
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)
'eth_protocolVersion', 'eth_coinbase', 'eth_mining', 'eth_hashrate', 'eth_gasPrice', 'eth_accounts', 'eth_blockNumber', 'eth_getCompilers', 'eth_newPendingTransactionFilter', 'eth_getWork', # 'shh_version', # 'shh_newIdentity', # 'shh_newGroup', ] c = EthJsonRpc() print len(methods) for m in methods: meth = getattr(c, m) result = meth() print '%s: %s (%s)' % (m, result, type(result)) ################################################################################ print '*' * 80 addr = '0x1dcb8d1f0fcc8cbc8c2d76528e877f915e299fbe' for x in ['earliest', 'latest', 'pending', 150000]: result = c.eth_getTransactionCount(addr, x) print 'eth_getTransactionCount: %s (%s)' % (result, type(result)) b = (231301, '0x9476018748ba1dae5bdf5e3725f8966df1fa127d49f58e66f621bf6868a23c85')
'eth_syncing', 'eth_coinbase', 'eth_mining', 'eth_hashrate', 'eth_gasPrice', 'eth_accounts', 'eth_blockNumber', 'eth_getCompilers', 'eth_newPendingTransactionFilter', 'eth_getWork', # 'shh_version', # 'shh_newIdentity', # 'shh_newGroup', ] c = EthJsonRpc() print len(methods) for m in methods: meth = getattr(c, m) result = meth() print '%s: %s (%s)' % (m, result, type(result)) ################################################################################ print '*' * 80 addr = '0x1dcb8d1f0fcc8cbc8c2d76528e877f915e299fbe' for x in ['earliest', 'latest', 'pending', 150000]: result = c.eth_getTransactionCount(addr, x) print 'eth_getTransactionCount: %s (%s)' % (result, type(result)) b = (231301, '0x9476018748ba1dae5bdf5e3725f8966df1fa127d49f58e66f621bf6868a23c85')
#!/usr/bin/python import logging import json import cStringIO import ipfsApi from ethjsonrpc import EthJsonRpc from flask import Flask, request, jsonify, g from flask_restplus import Api, Resource app = Flask(__name__, static_url_path="") logging.basicConfig(level=logging.DEBUG) with open("VarStore.json", "r") as f: eth = EthJsonRpc("ethereum", 8545) contract = json.loads(f.read()) # REMIND: Move this into the compile step external to the server contract["address"] = eth.get_contract_address(contract["transaction"]) logging.debug("Contract at {}".format(contract["address"])) eth_filter = eth.eth_newFilter(from_block=0, address=contract["address"]) @app.before_request def connect_to_ipfs(): g.ipfs = ipfsApi.Client("ipfs", 5001) g.eth = EthJsonRpc("ethereum", 8545) @app.route("/") def index(): return app.send_static_file("index.html")
''' from ethjsonrpc import EthJsonRpc import time import datetime import time import serial ser = serial.Serial('/dev/ttyACM0', 38400) contract_addr = '0xc421d5e214ddb07a41d28cf89ee37495aa5edba7' machineID = 123 #Wait for sometime to initialize serial port time.sleep(10) # Connect to Blockchain network c = EthJsonRpc('192.168.1.20', 8101) tempCount = 0 vibrationCount = 0 tempThreshold = 200 vibrationThreshold = 100 tempCountThreshold = 1000 vibrationCountThreshold = 1000 while True: line = serialTTL.readline() data = line.split(',') vibration = data[0] temperature = data[1] if(vibration>vibrationThreshold):
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
import json from ethjsonrpc import EthJsonRpc eth = EthJsonRpc("ethereum", 8545) with open("VarStore.sol") as f: contract = eth.eth_compileSolidity(f.read()) transaction = eth.create_contract(eth.eth_coinbase(), contract['VarStore']['code'], gas=300000) contract["transaction"] = transaction contract["account"] = eth.eth_coinbase() print json.dumps(contract)
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)
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ''' #!flask/bin/python from flask import Flask, jsonify, abort, request, make_response, url_for from ethjsonrpc import EthJsonRpc import time import datetime c = EthJsonRpc('127.0.0.1', 8101) contract_addr = "0xdd44F726FDd682c20857e9CD37F0dA8bf78518D7" stationID = [123] balance = c.eth_getBalance(contract_addr) print "Starting Balance = " + str(balance) app = Flask(__name__, static_url_path="") #curl -i http://localhost:5000/api/stationstate/123 @app.route('/api/stationstate/<int:id>', methods=['GET']) def getStationState(id): result = c.call(contract_addr, 'getStationState(uint256)', [id], ['bool']) return jsonify(result)
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')
class Ipv4TestCase(unittest.TestCase): def setUp(self): with open('compiled.evm') as f: compiled = f.read().rstrip() self.c = EthJsonRpc() self.c._call('evm_reset') self.cb = self.c.eth_coinbase() self.contract_addr = self.AddressToIPv4(self.cb, compiled) def tearDown(self): pass ################################################################################ def test_read(self): result = self.get_ip(self.contract_addr, self.cb[2:]) unchained_ip = self.ip_from_chain(result) self.assertEqual('0.0.0.0', unchained_ip) def test_set_read(self): ip = u'192.168.1.1' chained_ip = self.ip_to_chain(ip) self.set_ip(self.cb, self.contract_addr, chained_ip) result = self.get_ip(self.contract_addr, self.cb[2:]) unchained_ip = self.ip_from_chain(result) self.assertEqual(ip, unchained_ip) def test_set_delete_read(self): ip = u'192.168.1.1' chained_ip = self.ip_to_chain(ip) self.set_ip(self.cb, self.contract_addr, chained_ip) self.delete_ip(self.cb, self.contract_addr) result = self.get_ip(self.contract_addr, self.cb[2:]) unchained_ip = self.ip_from_chain(result) self.assertEqual('0.0.0.0', unchained_ip) ################################################################################ def ip_to_chain(self, ip): return int(IPv4Address(ip)) def ip_from_chain(self, ip): return str(IPv4Address(ip)) ################################################################################ def AddressToIPv4(self, sender, compiled): ''' constructor ''' sig = 'AddressToIPv4()' args = [] tx = self.c.create_contract(sender, compiled, sig, args) return self.c.get_contract_address(tx) def set_ip(self, sender, contract_addr, ip): sig = 'set_ip(uint32)' args = [ip] self.c.call_with_transaction(sender, contract_addr, sig, args) def delete_ip(self, sender, contract_addr): sig = 'delete_ip()' args = [] self.c.call_with_transaction(sender, contract_addr, sig, args) def get_ip(self, contract_addr, addr): sig = 'get_ip(address)' args = [addr] result_types = ['uint32'] return self.c.call(contract_addr, sig, args, result_types)[0]
'eth_syncing', 'eth_coinbase', 'eth_mining', 'eth_hashrate', 'eth_gasPrice', 'eth_accounts', 'eth_blockNumber', 'eth_getCompilers', 'eth_newPendingTransactionFilter', 'eth_getWork', # 'shh_version', # 'shh_newIdentity', # 'shh_newGroup', ] c = EthJsonRpc() print(len(methods)) for m in methods: meth = getattr(c, m) result = meth() print('%s: %s (%s)' % (m, result, type(result))) ################################################################################ print('*' * 80) addr = '0x1dcb8d1f0fcc8cbc8c2d76528e877f915e299fbe' for x in ['earliest', 'latest', 'pending', 150000]: result = c.eth_getTransactionCount(addr, x) print('eth_getTransactionCount: %s (%s)' % (result, type(result))) b = (231301, '0x9476018748ba1dae5bdf5e3725f8966df1fa127d49f58e66f621bf6868a23c85')
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ''' from ethjsonrpc import EthJsonRpc import time import datetime import RPi.GPIO as GPIO ## Import GPIO library ## Use board pin numbering GPIO.setmode(GPIO.BOARD) ## Setup GPIO Pin 7 to OUT GPIO.setup(7, GPIO.OUT) # Connect to Blockchain network c = EthJsonRpc('192.168.1.20', 8101) # Device account address to watch account_to_watch = "0x0cafd203ca406bb39985d0f70d55b44b78d756eb" # Get balance in the device account balance = c.eth_getBalance(account_to_watch) print "Starting Balance = " + str(balance) # Switch is off initially onStatus=False GPIO.output(7,False) ## Turn off GPIO pin 7 while True: newbalance = c.eth_getBalance(account_to_watch) if onStatus==True:
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()
from ethjsonrpc import EthJsonRpc c = EthJsonRpc('127.0.0.1', 8545) print(c.eth_gasPrice()) addr_list = c.eth_accounts() print(addr_list) print(c.eth_getBalance(addr_list[0], 'latest')) print(c.eth_getBalance(addr_list[1], 'latest')) print(c.eth_getTransactionCount (addr_list[0], 'latest')) #c.eth_sendTransaction(addr_list[0], addr_list[1], 30400, c.eth_gasPrice(), 1000000, 0) #print(c.db_putString('testDB', 'myKey', 'myString')) #print(c.db_getString('testDB', 'myKey'))