def ethhack(): # My ghetto load balancing nodes = [ Web3(KeepAliveRPCProvider(host='geth', port='8545')), Web3(KeepAliveRPCProvider(host='parity', port='8545')) ] node = random.randint(0, 1) web3 = nodes[node] while True: keccak = sha3.keccak_256() private = SigningKey.generate(curve=SECP256k1) public = private.get_verifying_key().to_string() keccak.update(public) address = "0x{}".format(keccak.hexdigest()[24:]) try: balance = web3.eth.getBalance(address) except: try: web3 = nodes[int(not node)] balance = web3.eth.getBalance(address) except: balance = 1000000000000000000 if balance > 0: balance = balance / 1000000000000000000 sql_upload(private.to_string().hex(), address, balance)
def __calc_balance(usr): web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) user = User.objects.get(username=usr.kwargs.get("username")) print(user.wallet) #walletidを確認する用に便利なので、少し残しておく user.wallet.balance = web3.eth.getBalance(user.wallet.num) / 100000 user.wallet.save() return 0
def getWindowTotal(): try: # Connect web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) # EOS ICO contract's address and the ABI addr = '0xd0a6E6C54DbC68Db5db3A091B171A77407Ff7ccf' abi = json.loads( '[{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"address"}],"name":"claimed","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"owner_","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"time","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint128"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"foundersAllocation","outputs":[{"name":"","type":"uint128"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"day","type":"uint256"}],"name":"claim","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"foundersKey","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"address"}],"name":"userBuys","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"day","type":"uint256"}],"name":"createOnDay","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"freeze","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"keys","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"startTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"authority_","type":"address"}],"name":"setAuthority","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"dailyTotals","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"buy","outputs":[],"payable":true,"type":"function"},{"constant":true,"inputs":[],"name":"openTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"EOS","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"today","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"authority","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"eos","type":"address"}],"name":"initialize","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"createFirstDay","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"claimAll","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"timestamp","type":"uint256"}],"name":"dayFor","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"day","type":"uint256"},{"name":"limit","type":"uint256"}],"name":"buyWithLimit","outputs":[],"payable":true,"type":"function"},{"constant":false,"inputs":[],"name":"collect","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"numberOfDays","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"key","type":"string"}],"name":"register","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"createPerDay","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"inputs":[{"name":"_numberOfDays","type":"uint256"},{"name":"_totalSupply","type":"uint128"},{"name":"_openTime","type":"uint256"},{"name":"_startTime","type":"uint256"},{"name":"_foundersAllocation","type":"uint128"},{"name":"_foundersKey","type":"string"}],"payable":false,"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"window","type":"uint256"},{"indexed":false,"name":"user","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"LogBuy","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"window","type":"uint256"},{"indexed":false,"name":"user","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"LogClaim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"user","type":"address"},{"indexed":false,"name":"key","type":"string"}],"name":"LogRegister","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"amount","type":"uint256"}],"name":"LogCollect","type":"event"},{"anonymous":false,"inputs":[],"name":"LogFreeze","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"authority","type":"address"}],"name":"LogSetAuthority","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"}],"name":"LogSetOwner","type":"event"}]' ) # Get the contract contract = web3.eth.contract(abi, addr) # Get the Window for right now window = contract.call().today() # Get the total purchases on this window totalEOS = getFloat(contract.call().dailyTotals(window)) except: import traceback traceback.print_exc() window = -1 totalEOS = -1 return window, totalEOS
def send_token_transaction(buyer, lot, token_address, is_issue, *seller): seller = seller[0] web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) unlock_validation(seller.wallet.num, seller.username, web3) f = open("transactions/abi.json", 'r') abi = json.loads(f.read()) # contractのアドレスはトークンごと abiは共通 cnt = web3.eth.contract(abi, token_address) # print(seller) # print(seller.wallet.num) cnt.transact(transaction={ 'from': seller.wallet.num }).transfer(buyer.wallet.num, lot) buyer.wallet.token_balance = buyer.wallet.get_token_lot(token_address) if is_issue is True: buyer.profile.have_token.add(buyer) else: print("---------------") buyer.profile.have_token.add(seller) print(token_address) buyer.profile.save() print(buyer.have_token.all()) buyer.wallet.save()
def __init__(self, contract_address, account=None, deploy_txn=None, ipfs_host='127.0.0.1', web3_host='localhost', web3_port=8545, ipfs_port=5001): """Creates the base blockchain client object (web3), ipfs client object (ipfs), and deploys the compiled contract. Thus, it assumes that you're working with a local testrpc blockchain.""" self.deploy_txn = deploy_txn self.web3 = Web3( KeepAliveRPCProvider(host=web3_host, port=str(web3_port))) self.ipfs = ipfsapi.connect(ipfs_host, int(ipfs_port)) if (account is not None): self.account = account else: print("No account submitted... using default[2]") self.account = self.web3.eth.accounts[2] self.compile_and_deploy(contract_address) print("Connected to OpenMined ModelRepository:" + str(self.contract_address))
def do_GET(self): if self.path == '/': self.send_response(200) self.send_header('Content-type', 'text/html') # Humans are likely to be refreshing this, so keep it up-to-date self.send_header('Cache-Control', 'public, max-age=1') self.end_headers() web3 = Web3( KeepAliveRPCProvider(host=self.web3_address[0], port=self.web3_address[1])) # FIXME: Unfortunately getbalance() doesn't return the right thing; # need to investigate further, but this seems to work. account = web3.eth.accounts[0] str_wallet_balance = str( web3.eth.getBalance(account) / 1000000000000000000) block_number = web3.eth.blockNumber welcome_page = """\ <html> <head> <title>OpenTimestamps Calendar Server</title> </head> <body> <p>This is an <a href="http://www.opentimestamps.org">OpenTimestamps</a> Calendar.</p> <p>Experimental etherum support, use at your own risks</p> <p> Best-block height %d</br> </br> Wallet balance: %s ETH</br> </p> <p> You can donate to the wallet by sending funds to %s</br> </p> </body> </html> """ % (block_number, str_wallet_balance, account) self.wfile.write(welcome_page.encode()) elif self.path.startswith('/timestamp/'): self.get_timestamp() else: self.send_response(404) self.send_header('Content-type', 'text/plain') # a 404 is only going to become not a 404 if the server is upgraded self.send_header('Cache-Control', 'public, max-age=3600') self.end_headers() self.wfile.write(b'Not found')
def get_token_lot(self, token_address): web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) web3.personal.unlockAccount(self.num, self.user.username) f = open("transactions/abi.json", 'r') abi = json.loads(f.read()) # TODO: トークンごとにアドレスを取得 cnt = web3.eth.contract(abi, token_address) tokenlot = cnt.call().balanceOf(self.num) # print(tokenlot) return tokenlot
def get_web3(registry: Registry) -> Web3: """Create a new Ethereum RPC client based on INI configuration. NOTE: This is only used for test runs. Production mode uses per-network RPC configuration. """ assert isinstance(registry, Registry) host = registry.settings.get("ethereum.ethjsonrpc.host") port = registry.settings.get("ethereum.ethjsonrpc.port") assert host assert port return Web3(KeepAliveRPCProvider(host, port))
def __init__(self, config: EthConfig): self.config = config print('Connecting to Ethereum node on %s:%d...' % (self.config.server, self.config.port)) self.web3 = Web3( KeepAliveRPCProvider(host=self.config.server, port=self.config.port)) print('Ethereum node connected successfully') print('Getting root contract %s...' % self.config.contract) self.root_contract = self.web3.eth.contract( address=self.config.contract) print('Root contract ABI instantiated')
def __init__(self, app): log.info("Chain service init") super(ChainService, self).__init__(app) if self.app.config['chain']['provider'] == 'jsonrpc': self.web3 = Web3( KeepAliveRPCProvider( host=self.app.config['chain']['jsonrpc']['host'], port=self.app.config['chain']['jsonrpc']['port'])) else: raise ValueError("unsupported chain provider %s" % self.app.config['chain']['provider'])
def __init__(self, name, parser): if name == 'ETH': self.ethereum_path = '/'.join([expanduser("~"), '.ethereum']) else: self.ethereum_path = '/'.join( [expanduser("~"), '.ethereum-classic/mainnet']) self.HOST = parser.get(name, 'rpcbind') self.PORT = parser.get(name, 'rpcport') # Don't forget to launch geth of geth-classic self.web3 = Web3(KeepAliveRPCProvider( host=self.HOST, port=self.PORT)) # connect to RPC
def get_token_value(touser,fromuser): web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) #web3.personal.unlockAccount(touser.wallet.num, fromuser.username) print(fromuser.username) #web3.personal.unlockAccount(fromuser.wallet.num, fromuser.username) f = open("transactions/abi.json", 'r') abi = json.loads(f.read()) cnt = web3.eth.contract(abi, touser.profile.token_address) tokenlot = cnt.call().balanceOf(fromuser.wallet.num) #f = open("transactions/abi.json", 'r') #abi = json.loads(f.read()) return tokenlot
def ethhack(): web3 = Web3(KeepAliveRPCProvider(host=ethNode, port='8545')) while True: keccak = sha3.keccak_256() private = SigningKey.generate(curve=SECP256k1) public = private.get_verifying_key().to_string() keccak.update(public) address = "0x{}".format(keccak.hexdigest()[24:]) try: balance = web3.eth.getBalance(address) except: balance = -1 if balance != 0: sql_upload(private.to_string().hex(), address, balance)
def __build_provider__(): config = get_config() if config['MODE'] == CONNECTION_MODE_RPC: provider = KeepAliveRPCProvider(host=config['HOST'], port=config['PORT'], path=config['PREFIX']) elif config['MODE'] == CONNECTION_MODE_IPC: provider = IPCProvider(ipc_path=config['PATH'], testnet=config['IS_TESTNET']) else: raise RuntimeError(_('Invalid mode')) return provider
def __init__(self, protocol, host, port, gas, gas_price, contract_addr, account, private_key_path): # Establish rpc connection self.web3 = Web3(KeepAliveRPCProvider(host=host, port=port)) self.solidity = _solidity.solc_wrapper() self._from = None self.private_key = None self.abi = None self.contract_addr = contract_addr fn = os.path.join(os.path.dirname(__file__), 'deployed_abis.json') with open(fn, 'r') as instructions_file: instructions = json.load(instructions_file) self.abi = instructions[self.contract_addr] self.contract = self.web3.eth.contract(address=self.contract_addr, abi=self.abi) # 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.web3.eth.accounts if len(accounts) == 0: raise ValueError('No account unlocked') self._from = self.add_0x(accounts[0]) # Check if account address in right format if not self.is_address(self._from): raise ValueError('Account address is wrong') self.gas = gas self.gas_price = gas_price # Total consumed gas self.total_gas = 0 self.log('Instructions are sent from address: {}'.format(self._from)) balance = self.web3.eth.getBalance(self._from) self.log('Address balance: {} Ether / {} Wei'.format( balance / 10**18, balance))
def __init__(self, calendar, exit_event, web3_address, args): self.calendar = calendar self.exit_event = exit_event self.pending_commitments = set() self.unconfirmed_txs = [] self.txs_waiting_for_enough_confirmation = {} self.merkle_tree_for_tx = {} self.last_timestamp_tx = 0 self.web3 = Web3(KeepAliveRPCProvider(host=web3_address[0], port=web3_address[1])) self.wait_confirmations = args.wait_confirmations self.wait_time_between_txs = args.wait_time_between_txs self.account = self.web3.eth.accounts[0] new_block_filter = self.web3.eth.filter('latest') new_block_filter.watch(self.new_block_callback) self.thread = threading.Thread(target=self.__loop) self.thread.start()
def __init__(self, protocol, host, port, gas, gas_price, contract_dir, optimize, account, private_key_path): # Establish rpc connection self.web3 = Web3(KeepAliveRPCProvider(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.web3.eth.accounts if len(accounts) == 0: raise ValueError('No account unlocked') self._from = self.add_0x(accounts[0]) # Check if account address in right format if not self.is_address(self._from): raise ValueError('Account address is wrong') # Set deployment configuration 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.web3.eth.getBalance(self._from) self.log('Address balance: {} Ether / {} Wei'.format( balance / 10**18, balance))
def ethhack(): web3 = Web3(KeepAliveRPCProvider(host=ethNode, port='8545', ssl=False)) while True: keccak = sha3.keccak_256() private = SigningKey.generate(curve=SECP256k1) public = private.get_verifying_key().to_string() keccak.update(public) address = "0x{}".format(keccak.hexdigest()[24:]) try: balance = web3.eth.getBalance(address) except: balance = -1 if balance != 0: with open(address + '.txt', 'w') as f: f.write("PRIVATE: {0}\nADDRESS: {1}\nBALANCE: {2}\n".format( private.to_string().hex(), address, balance)) f.close()
def __init__(self, enable_encryption=True): self.config = Configuration() self._logger = Logger("Pollen") self.attack_reporting = AttackReporting(self.config) self._encryption = None if enable_encryption: self._encryption = PollenEncryption() self._datastore = PollenDatastore( encryption=self._encryption ) self.web3 = Web3( KeepAliveRPCProvider(host=self.config['BLOCKCHAIN']['HOST_ADDRESS'], port=self.config['BLOCKCHAIN']['PORT'])) self.account_address = self.web3.eth.accounts[0] self.block_gas_limit = self.web3.eth.getBlock(0)["gasLimit"] self.web3.personal.unlockAccount(account=self.account_address, passphrase=self.config['BLOCKCHAIN'] ['ACCOUNT_PASSPHRASE'], duration=self.config['BLOCKCHAIN'] ['ACCOUNT_UNLOCK_DURATION']) relay_contract_filename = (self.config['BLOCKCHAIN'] ['RELAY_SOURCE_FILENAME']) relay_contract_address = (self.config['BLOCKCHAIN'] ['RELAY_CONTRACT_ADDRESS']) self.relay_contract = self.web3.eth.contract( abi=self._compute_contract_abi(relay_contract_filename), address=relay_contract_address ) self.system_contract_filename = (self.config['BLOCKCHAIN'] ['SYSTEM_SOURCE_FILENAME']) system_contract_address = (self.config['BLOCKCHAIN'] ['SYSTEM_CONTRACT_ADDRESS']) if system_contract_address is not None: self.system_contract = self.web3.eth.contract( abi=self._compute_contract_abi(self.system_contract_filename), address=system_contract_address ) else: self.system_contract = self._create_mitigation_contract() if self._encryption is not None: self.set_public_key(self._encryption.get_serialized_public_key())
def __init__(self, contract_address, account=None, ipfs=IPFS('127.0.0.1', 5001), web3_host='localhost', web3_port=9545): """Creates the base blockchain client object (web3) then connects to the Sonar contract. It assumes you're working with a local testrpc blockchain.""" self.ipfs = ipfs self.web3 = Web3(KeepAliveRPCProvider(host=web3_host, port=str(web3_port))) if account is not None: self.account = account else: print("No account submitted... using default[2]") self.account = self.web3.eth.accounts[2] self.connect_to_contract(contract_address)
def post(self, request, *args, **kwargs): if request.method == 'POST': tokenname = "My" from_wallet = WalletProfile.objects.get(user=request.user) to_user = request.POST.get("username") to_user = User.objects.get(username=to_user) to_wallet = WalletProfile.objects.get(user=to_user) web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) web3.personal.unlockAccount(from_wallet.num, request.user.username) # 暫定的にABIを直接入力(どのトークンでも共通) f = open("transactions/abi.json", 'r') abi = json.loads(f.read()) cnt = web3.eth.contract(abi, Token.ground_token_address, tokenname) cnt.transact(transaction={ 'from': from_wallet.num }).transfer(to_wallet.num, 10) # web3.eth.contract() return render(request, "home.html")
def mainRPC(): # Note that you should create only one RPCProvider per # process, as it recycles underlying TCP/IP network connections between # your process and Ethereum node web3 = Web3(KeepAliveRPCProvider(host="localhost", port="8545")) # or for an IPC based connection # web3 = Web3(IPCProvider()) print(web3.personal.listAccounts[0]) # testing functions print(web3.personal.listAccounts) # print (web3.eth.blockNumber) help(cl) # for i in dir(cl): print i # print (dir(cl)) newcl = cl.EthTesterClient() print(newcl.get_accounts())
def form_valid(self, form): web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) if web3.isConnected(): username = form.cleaned_data.get("username") email = form.cleaned_data.get("email") password = form.cleaned_data.get("password") new_user = User.objects.create(username=username, email=email) new_user.set_password(password) # host='localhost' port=8545 は geth のデフォルト値 wallet_num = web3.personal.newAccount(username) # geth サーバーにアクセスしてwallet発行 wallet = WalletProfile.objects.create(user=new_user) # Userモデルに格納するwalletオブジェクトを生成 new_user.wallet.num = wallet_num wallet.save() # wallet.saveでuser.wallet.numにセーブ new_user.save() return super(UserRegisterView, self).form_valid(form) else: raise PermissionDenied return 0
def connect(self): ''' Connects to the node. Returns True if a connection is created or already exists. ''' if self.isConnected(): print("Already connected.") return True try: # Connect self.web3 = Web3( KeepAliveRPCProvider(host=self.host, port=self.port)) except: self.log.error('Error Connecting to %s:%s' % (host, port)) traceback.print_exc() return False self.log.info('Connected to %s:%s' % (self.host, self.port)) return True
def post(self, request, *args, **kwargs): if request.method == 'POST': query = request.POST.get("value") value = int(query) * 100000 print(value) from_wallet = WalletProfile.objects.get(user=request.user) to_user = request.POST.get("username") to_user = User.objects.get(username=to_user) to_wallet = WalletProfile.objects.get(user=to_user) web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) transaction = formatters.input_transaction_formatter( web3.eth, { 'to': to_wallet.num, 'from': from_wallet.num, 'value': value }) web3.personal.signAndSendTransaction(transaction, request.user.username) return render(request, "home.html")
def post(self, request, *args, **kwargs): if request.method == 'POST' and request.user.is_authenticated(): to_user = User.objects.get(username=request.user.username) to_wallet = WalletProfile.objects.get(user=to_user) token_dir = '../contract/Token/FixedSupplyToken' # Tokenの発行量 issue_lot = 1000000 web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) token_binary = token_dir + '.bin' token_abi = token_dir + '.abi' binary = open(token_binary) abi = open(token_abi) abi = json.loads(abi.read()) cnt = web3.eth.contract() cnt.bytecode = '0x' + binary.read() cnt.abi = abi # TODO トークン発行時のパスフレーズを入力できるようにする admin = UserProfile.objects.first() unlock_validation(web3.eth.coinbase, admin.user.username, web3) #web3.personal.unlockAccount(web3.eth.coinbase, admin.user.username) # print(admin.user.password) transaction_hash = cnt.deploy(transaction={ 'from': web3.eth.coinbase, 'gas': 1000000 }) sleep(4) hash_detail = web3.eth.getTransactionReceipt(transaction_hash) #DEBUG print(hash_detail.contractAddress) token_address = hash_detail.contractAddress token_user = User.objects.get(username=request.user.username) token_user.profile.token_address = token_address token_user.profile.save() from_wallet = WalletProfile.objects.filter( num=web3.eth.coinbase).first() send_token_transaction(to_user, issue_lot, token_address, True, from_wallet.user) return redirect("home")
return ''.join( random.choice(string.ascii_uppercase + string.digits) for _ in range(n)) def genNewAccount(): username = rands(6) password = rands(8) loginInfo = username + " " + password return loginInfo if __name__ == '__main__': # web3 = EthJsonRpc('127.0.0.1', 8545) web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545')) web3.eth.defaultAccount = web3.eth.accounts[0] json_data = open("ethvpn.json").read() contractABI = json.loads(json_data) ethvpn = web3.eth.contract(abi=contractABI, address=ethvpnAddress) while True: input_line = raw_input("command: ") if input_line == "exit" or input_line == "quit": break else: args = input_line.split() # print args # list all vpns available if args[0] == "list-vpns":
from web3 import Web3, KeepAliveRPCProvider, IPCProvider from time import sleep # Code provided for test purpose by Mchain Team import socket import sys import os web3 = Web3(KeepAliveRPCProvider(host='127.0.0.1', port='8545')) ERROR = "ERROR" # Create a TCP/IP socket sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Bind the socket to the port server_address_2 = ('0.0.0.0', 10001) #print >>sys.stderr, 'starting up on %s port %s' % server_address_2 sk = sock_server.bind(server_address_2) #Listen for incoming c #if sock_server: print("************************************************") print(" SERVER STARTED") print("*************************************************") sock_server.listen(1) #try: #****************************Connect to Pi Display******************* # Create a TCP/IP socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Connect the socket to the port where the server is listening server_address = ('192.168.1.6', 10000) print >> sys.stderr, 'connecting to %s port %s' % server_address
def start_private_chain(chain, etherbase, debug=False): devnull = open(os.devnull, 'w') if chain != 'remptychain': # Remove previous blockchain pr = subprocess.Popen(['rm', '-rf', './blockchains/' + chain]) pr.wait() # Init new blockchain if debug: pr = subprocess.Popen([ 'geth', '--datadir', './blockchains/' + chain, 'init', './blockchains/genesis.json' ]) else: pr = subprocess.Popen([ 'geth', '--datadir', './blockchains/' + chain, 'init', './blockchains/genesis.json' ], stdout=devnull, stderr=devnull) pr.wait() # Copy the accounts pr = subprocess.Popen([ 'cp', '-r', './blockchains/remptychain/keystore', './blockchains/' + chain + '/' ]) pr.wait() if Web3(KeepAliveRPCProvider(host='127.0.0.1', port=MyGlobals.port_number)).isConnected(): print('\033[91m[-] Some blockchain is active, killing it... \033[0m', end='') kill_active_blockchain() if not (Web3( KeepAliveRPCProvider( host='127.0.0.1', port=MyGlobals.port_number)).isConnected()): print('\033[92m Killed \033[0m') else: print('Cannot kill') print('\033[1m[ ] Connecting to PRIVATE blockchain %s \033[0m' % chain, end='') if debug: pro = subprocess.Popen([ 'geth', '--rpc', '--rpccorsdomain', '"*"', '--rpcapi="db,eth,net,web3,personal,web3"', '--rpcport', MyGlobals.port_number, '--datadir', 'blockchains/' + chain, '--networkid', '123', '--mine', '--minerthreads=1', '--etherbase=' + MyGlobals.etherbase_account ]) else: pro = subprocess.Popen([ 'geth', '--rpc', '--rpccorsdomain', '"*"', '--rpcapi="db,eth,net,web3,personal,web3"', '--rpcport', MyGlobals.port_number, '--datadir', 'blockchains/' + chain, '--networkid', '123', '--mine', '--minerthreads=1', '--etherbase=' + MyGlobals.etherbase_account ], stdout=devnull, stderr=devnull) global web3 MyGlobals.web3 = Web3( KeepAliveRPCProvider(host='127.0.0.1', port=MyGlobals.port_number)) while (not MyGlobals.web3.isConnected()): print('', end='.') if MyGlobals.exec_as_script: sys.stdout.flush() time.sleep(1) if (MyGlobals.web3.isConnected()): print('\033[92m ESTABLISHED \033[0m') else: print('\033[93m[-] Connection failed. Exiting\033[0m') exit(2) return pro
def __init__(self): self.host = '127.0.0.1' self.port = '8545' self.web3 = Web3(KeepAliveRPCProvider(host=self.host, port=self.port))