def main(): parser = argparse.ArgumentParser(prog="check-balances") parser.add_argument("--endpoint", default=W3_ENDPOINT) subparsers = parser.add_subparsers(dest="command") show_balance_parser = subparsers.add_parser("balance") show_balance_parser.add_argument("token-address") show_balance_parser.add_argument("-a", "--account", default="0") transfer_parser = subparsers.add_parser("transfer") transfer_parser.add_argument("token-address") transfer_parser.add_argument("amount", type=int) transfer_parser.add_argument("-f", "--from", default="0") transfer_parser.add_argument("-t", "--to", default="1") allowance_parser = subparsers.add_parser("allowance") allowance_parser.add_argument("token-address") allowance_parser.add_argument("--spender") allowance_parser.add_argument("-a", "--account", default="0") args = vars(parser.parse_args()) w3 = web3.Web3(web3.HTTPProvider(args["endpoint"])) manager = W3Manager(w3) if args["command"] == "balance": manager.show_balance(args["token-address"], args["account"]) elif args["command"] == "transfer": manager.transfer_tokens(args["token-address"], args["from"], args["to"], args["amount"]) elif args["command"] == "allowance": manager.show_allowance(args["token-address"], args["account"], args["spender"]) else: print("no command passed")
def init_web3(parser, section, label): # Initialize web3 for a ledger and return a dictionary with the useful info for that ledger endpoint = f"{parser.get(section, 'url')}:{parser.get(section, 'port')}" web3_instance = web3.Web3(web3.Web3.HTTPProvider(endpoint)) if web3_instance.isConnected(): #print(f"OK - {label}: connected to {endpoint}") abi_file = parser.get(section, "contract_abi") abi = read_contract_abi(abi_file) ledger = dict() ledger["web3"] = web3_instance ledger["endpoint"] = endpoint ledger["minter"] = parser.get(section, "minter") ledger["contract_address"] = parser.get(section, "contract") ledger["contract"] = ledger["web3"].eth.contract( abi=abi, address=ledger["contract_address"]) return ledger else: print("ERROR Not connected to : ", endpoint) sys.exit(1)
def get_web3(rpc_endpoint): if rpc_endpoint.startswith("ws:"): provider = web3.WebsocketProvider(rpc_endpoint) else: provider = web3.HTTPProvider(rpc_endpoint) return web3.Web3(provider)
def get_transaction_receipt(host, txn_hash): try: w3 = web3.Web3(web3.Web3.HTTPProvider(host)) w3.eth.getTransactionReceipt(txn_hash) return 1 except web3ex.TransactionNotFound: return 0
def deploy_contract(contract_name, **data): eth_test = web3.Web3(web3.EthereumTesterProvider()) eth_test.eth.defaultAccount = eth_test.eth.accounts[0] try: template = TEMPLATES.get_template(contract_name) contract_code = solc.compile_source(template.render(**data)) # contract_interface = contract_code["<stdin>:{}".format(data["name"]["class"])] # new_contract = eth_test.eth.contract( # abi=contract_interface["abi"], # bytecode=contract_interface["bin"] # ) # transaction = new_contract.constructor().buildTransaction() # tx_hash = eth_test.eth.sendTransaction(transaction) # tx_receipt = eth_test.eth.waitForTransactionReceipt(tx_hash) # test_contract = eth_test.eth.contract( # address=tx_receipt.contractAddress, # abi=contract_interface["abi"] # ) # balance = test_contract.functions.balanceOf(eth_test.eth.defaultAccount).call() # if balance: return contract_code # raise Exception("Что то пошло не так!!!") except Exception as e: print(e) raise Exception("Все очень плохо!!!")
def Main(): range_supply = GenerateRange(MINIMUM_VALUE_SUPPLY ,MAXIMUM_VALUE_SUPPLY ,GROWTH_FACTOR_SUPPLY ) range_reserve = GenerateRange(MINIMUM_VALUE_RESERVE,MAXIMUM_VALUE_RESERVE,GROWTH_FACTOR_RESERVE) range_ratio = GenerateRange(MINIMUM_VALUE_RATIO ,MAXIMUM_VALUE_RATIO ,GROWTH_FACTOR_RATIO ) range_amount = GenerateRange(MINIMUM_VALUE_AMOUNT ,MAXIMUM_VALUE_AMOUNT ,GROWTH_FACTOR_AMOUNT ) testNum = 0 numOfTests = len(range_supply)*len(range_reserve)*len(range_ratio)*len(range_amount) web3RPCProvider = web3.Web3(web3.RPCProvider()) abi = open('../contracts/build/BancorFormula.abi').read() bin = open('../contracts/build/BancorFormula.bin').read() contract = web3RPCProvider.eth.contract(abi=json.loads(abi),bytecode=bin) FormulaContractAddr = contract(web3RPCProvider.eth.getTransactionReceipt(contract.deploy())['contractAddress']).call() for supply in range_supply : for reserve in range_reserve: for ratio in range_ratio : for amount in range_amount : testNum += 1 if amount <= supply: resultSolidityPort = Run(FormulaSolidityPort,supply,reserve,ratio,amount) resultContractAddr = Run(FormulaContractAddr,supply,reserve,ratio,amount) print 'Test {} out of {}: resultSolidityPort = {}, resultContractAddr = {}'.format(testNum,numOfTests,resultSolidityPort,resultContractAddr) if resultSolidityPort != resultContractAddr: print 'Emulation Error:' print 'supply = {}'.format(supply ) print 'reserve = {}'.format(reserve) print 'ratio = {}'.format(ratio ) print 'amount = {}'.format(amount ) return
def start(self): """ Start the blockchain client using the configured blockchain gateway. """ assert self._w3 is None if self._gateway: w3 = web3.Web3(web3.Web3.HTTPProvider(self._gateway)) else: # using automatic provider detection: from web3.auto import w3 # check we are connected, and check network ID if not w3.isConnected(): emsg = 'could not connect to Web3/Ethereum at: {}'.format( self._gateway or 'auto') self.log.warn(emsg) raise RuntimeError(emsg) else: print('connected to network {} at provider "{}"'.format( w3.version.network, self._gateway or 'auto')) self._w3 = w3 # set new provider on XBR library xbr.setProvider(self._w3)
def __init__(self): self.geth = web3.Web3(web3.HTTPProvider("HTTP://26.200.208.237:7545")) self.geth.eth.defaultAccount = self.geth.eth.accounts[0] print(self.geth.eth.accounts) self.cont = self.geth.eth.contract(address=self.address, abi=self.abi) for i in range(len(self.accounts())): self.cont.functions.add_user(self.accounts()[i]).transact()
def _get_provider_for_url(self, url): """ Get Ethereum provider endpoint for submitting a transaction Parameters: url URL of the Ethereum provider """ return web3.Web3(PROVIDER_DICT[urlparse(url).scheme](url))
def __init__(self, host='localhost', port='8545'): try: self.ethereum = web3.Web3(web3.HTTPProvider('{host}:{port}'.format(host=host, port=port))) self.ethereum.eth.blockNumber self.contract = None except InvalidSchema: logging.error('Cannot connect to ethereum provider!') raise EthereumConnectionError
def getWeb3Instance(): import web3 if network == "kovan": provider = web3.Web3.HTTPProvider(kovan_url) elif network == "mainnet": provider = web3.Web3.HTTPProvider(main_url) w3 = web3.Web3(provider) return w3
def __init__(self, network: str): self.network = network self.provider = self._get_provider() self.chain_id = _get_chain_id(self.network) self.w3 = web3.Web3(self.provider) self.interchain_address, self.private_key = load_address(self.network) _log.info(f"[ETHEREUM] Using address: {self.interchain_address}") _log.info(f"[ETHEREUM] Using RPC network: {self.provider}")
def create_web3_client(): provider = web3.providers.rpc.HTTPProvider(app_settings.JSON_RPC_PROVIDER_URL) w3 = web3.Web3( provider, external_modules={ "sbch": SmartBCHModule, } ) return w3
def __init__(self, credentials: tuple, contracts: dict, provider: web3.providers.BaseProvider): """ :param credentials: Network credentials ( address, password ) :param contracts: Contract structure containing name, ABI and bytecode and address keys. :param provider: Blockchain client rpc structure containing endpoint URL and connection type """ self.credentials = credentials self.contracts = contracts self.w3 = web3.Web3(provider)
def connect(port=8545): global w3 if w3 is None or not w3.isConnected: # large request timeout required for performance tests w3 = web3.Web3( web3.HTTPProvider(f"http://127.0.0.1:{port}", request_kwargs={"timeout": 60 * 10})) assert w3.isConnected return w3
def connect(): global w3 if w3 is None or not w3.isConnected: # large request timeout require for performance tests w3 = web3.Web3( web3.HTTPProvider('http://127.0.0.1:8545', request_kwargs={'timeout': 60 * 10})) assert w3.isConnected return w3
def __init__(self, name: str, rpc_address: str, chain_id: int, b64_private_key: str): self.blockchain = "ethereum" self.name = name self.rpc_address = rpc_address self.chain_id = chain_id self.priv_key = eth_keys.keys.PrivateKey(base64.b64decode(b64_private_key)) self.address = self.priv_key.public_key.to_checksum_address() self.w3 = web3.Web3(web3.HTTPProvider(self.rpc_address)) # Set gas strategy self.w3.eth.setGasPriceStrategy(web3.gas_strategies.time_based.medium_gas_price_strategy)
def _get_highest_known_block_infura(self): """Get the highest known block from Consensys Infura""" infura_uri = "https://mainnet.infura.io/%s" % (self.infura_api_key) try: infura_web3 = web3.Web3(web3.HTTPProvider(infura_uri)) number = infura_web3.ifa.blockNumber return int(number) except: self.console.error("Could not retrieve from Infura.") return False
def __init__(self, network, address, rpc_endpoint_url, safe_relay_url): """Initializes a Safe. """ self.network = network self.address = address self.w3 = web3.Web3(web3.HTTPProvider(rpc_endpoint_url)) # https://web3py.readthedocs.io/en/stable/middleware.html#geth-style-proof-of-authority self.w3.middleware_stack.inject(geth_poa_middleware, layer=0) self.contract = get_safe_contract(w3=self.w3, address=self.address) self.safe_relay = Relay(safe_relay_url)
def getbalance(account="*", confirmations=1): print("@getbalance", "account", account, "address", address(account), "confirmations", confirmations) if account == "*": return str(sum(balances.values())) if confirmations == 0: return '0' w3 = web3.Web3(web3.Web3.HTTPProvider("https://ropsten.infura.io/v3/090e2fb264dd4c5fbb28f4af2f6ccaba")) balance = str(w3.fromWei(w3.eth.getBalance(address(account)), "ether")) # balance = etherscan_client().get_eth_balance(address(account)) balances[address(account)] = float(balance) return balance
def estOnlyConnection(gethIpcPath, isDevNet): ipcCon=web3.Web3(web3.Web3.IPCProvider(gethIpcPath)) # FOR TEST NET ONLY: inject the poa compatibility middleware to the innermost layer. if isDevNet: # It was like that before the version web3 v4. was renamed in web5. # ipcCon.middleware_stack.inject(geth_poa_middleware, layer=0) ipcCon.middleware_onion.inject(geth_poa_middleware, layer=0) ipcCon.eth.defaultAccount=ipcCon.eth.coinbase print(ipcCon.eth.blockNumber) return ipcCon
def _get_web3() -> "web3.Web3": global _WEB3_INSTANCE if _WEB3_INSTANCE is None: try: import web3 _WEB3_INSTANCE = web3.Web3() except ModuleNotFoundError: _print_eth_dependencies_and_die() return _WEB3_INSTANCE
def make_w3(gateway_config): """ Create a Web3 instance configured and ready-to-use gateway to the blockchain. :param gateway_config: Blockchain gateway configuration. :type gateway_config: dict :return: Configured Web3 instance. :rtype: :class:`web3.Web3` """ request_kwargs = gateway_config.get('http_options', {}) if gateway_config['type'] == 'auto': w3 = web3.Web3() elif gateway_config['type'] == 'user': w3 = web3.Web3( web3.Web3.HTTPProvider(gateway_config['http'], request_kwargs=request_kwargs)) elif gateway_config['type'] == 'infura': project_id = gateway_config['key'] # project_secret = gateway_config['secret'] http_url = 'https://{}.infura.io/v3/{}'.format( gateway_config['network'], project_id) w3 = web3.Web3( web3.Web3.HTTPProvider(http_url, request_kwargs=request_kwargs)) # https://web3py.readthedocs.io/en/stable/middleware.html#geth-style-proof-of-authority if gateway_config.get('network', None) == 'rinkeby': # This middleware is required to connect to geth --dev or the Rinkeby public network. from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer w3.middleware_onion.inject(geth_poa_middleware, layer=0) else: raise RuntimeError('invalid blockchain gateway type "{}"'.format( gateway_config['type'])) return w3
def __encode_call(compiled_sol, call): new_contract_data_abi = copy.deepcopy(compiled_sol['metadata']['output']['abi']) for item in new_contract_data_abi: for input_item in item["inputs"]: if input_item["type"] == "address": input_item["internalType"] = "bytes32" input_item["type"] = "bytes32" new_contract = web3.Web3().eth.contract(abi=new_contract_data_abi, bytecode=compiled_sol['bytecode']) if call['method'] == "constructor": call_data = new_contract.constructor(*call["args"]).data_in_transaction call_data = call_data[2:] else: call_data = new_contract.encodeABI(fn_name=call["method"], args=call["args"]) original = web3.Web3().eth.contract(abi=compiled_sol['metadata']['output']['abi']) target_hash = Client.__create_function_hash(original.get_function_by_name(call["method"])) call_data = target_hash[2] + call_data[10:] return call_data
def __init__(self, url): self.MAX_RETRIES = 1000 self.SECONDS_BETWEEN_RETRIES = 5 self.w3 = web3.Web3(HTTPProvider(url)) self.contracts = { "producer": json.load(open('./assets/AssetProducingRegistryLogic.json')), "consumer": json.load(open('./assets/AssetConsumingRegistryLogic.json')), "asset": json.load(open('./assets/AssetLogic.json')) }
def is_valid_feedbk(self, net_id, usr_addr, msg_txt, sign): try: provider = web3.HTTPProvider(NETWORKS[net_id]['http_provider']) w3 = web3.Web3(provider) message = w3.sha3(text=msg_txt) message_hash = defunct_hash_message(primitive=message) recovered = str(w3.eth.account.recoverHash(message_hash, signature=sign)) return str(usr_addr).lower() == recovered.lower() except Exception as e: print(repr(e)) raise e return False
def is_contract(addy): #check if the address provided is a contract address ''' input: ethereum address 0x... return: boolean ''' global project_id w3 = web3.Web3(web3.Web3.HTTPProvider("https://mainnet.infura.io/v3/" + project_id)) checksum_addy=w3.toChecksumAddress(addy) if len(w3.eth.getCode(checksum_addy))>0: return True else: return False
def get_client() -> web3.Web3: client = web3.Web3(web3.HTTPProvider("http://127.0.0.1:7545")) if not client.isConnected(): print("Not connected") raise RuntimeError("Not connected") client.middleware_onion.inject(web3.middleware.geth_poa_middleware, layer=0) print(f"Connected: {client.clientVersion}") return client
def __init__(self, u_addr): self.w3 = web3.Web3(web3.HTTPProvider('http://192.168.0.2:8545')) with open(f'{os.path.dirname(__file__)}/abi.txt', 'r') as f: abi = json.load(f) with open(f'{os.path.dirname(__file__)}/contract_address.txt', 'r') as f: contract_address = f.read() contract_address = web3.Web3.toChecksumAddress(contract_address) self.contract = self.w3.eth.contract(contract_address, abi=abi) self.u_addr = web3.Web3.toChecksumAddress(u_addr) self.w3.eth.defaultAccount(self.u_addr)
def generate(aleth_path, n): tmp = TemporaryDirectory().name popen = Popen([aleth_path, "--no-discovery", "-d", tmp, "--ipcpath", tmp, "-v", "4"]) time.sleep(3) personal = web3.Web3(web3.Web3.IPCProvider(tmp+"/geth.ipc")).personal for i in range(n): personal.newAccount("1234") popen.terminate() popen.wait() print("Go get your keys in ~/.web3/keys")