def __init__(self, args: list, **kwargs): parser = argparse.ArgumentParser(prog='oasis-market-maker-keeper') parser.add_argument("--rpc-host", type=str, default="localhost", help="JSON-RPC host (default: `localhost')") parser.add_argument("--rpc-port", type=int, default=8545, help="JSON-RPC port (default: `8545')") parser.add_argument("--rpc-timeout", type=int, default=10, help="JSON-RPC timeout (in seconds, default: 10)") parser.add_argument("--eth-from", type=str, required=True, help="Ethereum account from which to send transactions") parser.add_argument("--eth-key", type=str, nargs='*', help="Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')") parser.add_argument("--tub-address", type=str, required=False, help="Ethereum address of the Tub contract") parser.add_argument("--oasis-address", type=str, required=True, help="Ethereum address of the OasisDEX contract") parser.add_argument("--oasis-support-address", type=str, required=False, help="Ethereum address of the OasisDEX support contract") parser.add_argument("--buy-token-address", type=str, required=True, help="Ethereum address of the buy token") parser.add_argument("--sell-token-address", type=str, required=True, help="Ethereum address of the sell token") parser.add_argument("--buy-token-name", type=str, required=True, help="Ethereum address of the buy token") parser.add_argument("--sell-token-name", type=str, required=True, help="Ethereum address of the sell token") parser.add_argument("--buy-token-decimals", type=int, required=True, help="Ethereum address of the buy token") parser.add_argument("--sell-token-decimals", type=int, required=True, help="Ethereum address of the sell token") parser.add_argument("--config", type=str, required=True, help="Bands configuration file") parser.add_argument("--price-feed", type=str, required=True, help="Source of price feed") parser.add_argument("--price-feed-expiry", type=int, default=120, help="Maximum age of the price feed (in seconds, default: 120)") parser.add_argument("--spread-feed", type=str, help="Source of spread feed") parser.add_argument("--spread-feed-expiry", type=int, default=3600, help="Maximum age of the spread feed (in seconds, default: 3600)") parser.add_argument("--control-feed", type=str, help="Source of control feed") parser.add_argument("--control-feed-expiry", type=int, default=86400, help="Maximum age of the control feed (in seconds, default: 86400)") parser.add_argument("--order-history", type=str, help="Endpoint to report active orders to") parser.add_argument("--order-history-every", type=int, default=30, help="Frequency of reporting active orders (in seconds, default: 30)") parser.add_argument("--round-places", type=int, default=2, help="Number of decimal places to round order prices to (default=2)") parser.add_argument("--min-eth-balance", type=float, default=0, help="Minimum ETH balance below which keeper will cease operation") parser.add_argument("--gas-price", type=int, default=0, help="Gas price (in Wei)") parser.add_argument("--smart-gas-price", dest='smart_gas_price', action='store_true', help="Use smart gas pricing strategy, based on the ethgasstation.info feed") parser.add_argument("--ethgasstation-api-key", type=str, default=None, help="ethgasstation API key") parser.add_argument("--refresh-frequency", type=int, default=10, help="Order book refresh frequency (in seconds, default: 10)") parser.add_argument("--debug", dest='debug', action='store_true', help="Enable debug output") self.arguments = parser.parse_args(args) setup_logging(self.arguments) self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(HTTPProvider(endpoint_uri=f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}", request_kwargs={"timeout": self.arguments.rpc_timeout})) self.web3.eth.defaultAccount = self.arguments.eth_from register_keys(self.web3, self.arguments.eth_key) self.our_address = Address(self.arguments.eth_from) self.otc = MatchingMarket(web3=self.web3, address=Address(self.arguments.oasis_address), support_address=Address(self.arguments.oasis_support_address) if self.arguments.oasis_support_address else None) tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address)) \ if self.arguments.tub_address is not None else None self.token_buy = ERC20Token(web3=self.web3, address=Address(self.arguments.buy_token_address)) self.token_sell = ERC20Token(web3=self.web3, address=Address(self.arguments.sell_token_address)) self.buy_token = Token(name=self.arguments.buy_token_name, address=Address(self.arguments.buy_token_address), decimals=self.arguments.buy_token_decimals) self.sell_token = Token(name=self.arguments.sell_token_name, address=Address(self.arguments.sell_token_address), decimals=self.arguments.sell_token_decimals) self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance) self.bands_config = ReloadableConfig(self.arguments.config) self.gas_price = GasPriceFactory().create_gas_price(self.arguments) self.price_feed = PriceFeedFactory().create_price_feed(self.arguments, tub) self.spread_feed = create_spread_feed(self.arguments) self.control_feed = create_control_feed(self.arguments) self.order_history_reporter = create_order_history_reporter(self.arguments) self.history = History() self.order_book_manager = OrderBookManager(refresh_frequency=self.arguments.refresh_frequency) self.order_book_manager.get_orders_with(lambda: self.our_orders()) self.order_book_manager.place_orders_with(self.place_order_function) self.order_book_manager.cancel_orders_with(self.cancel_order_function) self.order_book_manager.enable_history_reporting(self.order_history_reporter, self.our_buy_orders, self.our_sell_orders) self.order_book_manager.start()
def __init__(self): super().__init__(HTTPProvider('null')) self.provider = None
def run_app( address: Address, keystore_path: str, gas_price: Callable, eth_rpc_endpoint: str, user_deposit_contract_address: Optional[UserDepositAddress], api_address: Endpoint, rpc: bool, rpccorsdomain: str, sync_check: bool, console: bool, password_file: TextIO, web_ui: bool, datadir: Optional[str], matrix_server: str, network_id: ChainID, environment_type: Environment, unrecoverable_error_should_crash: bool, pathfinding_service_address: str, pathfinding_max_paths: int, enable_monitoring: bool, resolver_endpoint: str, default_reveal_timeout: BlockTimeout, default_settle_timeout: BlockTimeout, routing_mode: RoutingMode, flat_fee: Tuple[Tuple[TokenAddress, FeeAmount], ...], proportional_fee: Tuple[Tuple[TokenAddress, ProportionalFeeAmount], ...], proportional_imbalance_fee: Tuple[Tuple[TokenAddress, ProportionalFeeAmount], ...], blockchain_query_interval: float, cap_mediation_fees: bool, **kwargs: Any, # FIXME: not used here, but still receives stuff in smoketest ) -> App: # pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument token_network_registry_deployed_at: Optional[BlockNumber] smart_contracts_start_at: BlockNumber if datadir is None: datadir = os.path.join(os.path.expanduser("~"), ".raiden") account_manager = AccountManager(keystore_path) web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint))) check_sql_version() check_ethereum_has_accounts(account_manager) check_ethereum_client_is_supported(web3) check_ethereum_network_id(network_id, web3) address, privatekey = get_account_and_private_key(account_manager, address, password_file) api_host, api_port = split_endpoint(api_address) if not api_port: api_port = DEFAULT_HTTP_SERVER_PORT domain_list = [] if rpccorsdomain: if "," in rpccorsdomain: for domain in rpccorsdomain.split(","): domain_list.append(str(domain)) else: domain_list.append(str(rpccorsdomain)) # Set up config fee_config = prepare_mediation_fee_config( cli_token_to_flat_fee=flat_fee, cli_token_to_proportional_fee=proportional_fee, cli_token_to_proportional_imbalance_fee=proportional_imbalance_fee, cli_cap_mediation_fees=cap_mediation_fees, ) rest_api_config = RestApiConfig( rest_api_enabled=rpc, web_ui_enabled=rpc and web_ui, cors_domain_list=domain_list, eth_rpc_endpoint=eth_rpc_endpoint, host=api_host, port=api_port, ) config = RaidenConfig( chain_id=network_id, environment_type=environment_type, reveal_timeout=default_reveal_timeout, settle_timeout=default_settle_timeout, console=console, mediation_fees=fee_config, unrecoverable_error_should_crash=unrecoverable_error_should_crash, resolver_endpoint=resolver_endpoint, rest_api=rest_api_config, ) config.blockchain.query_interval = blockchain_query_interval config.services.monitoring_enabled = enable_monitoring config.services.pathfinding_max_paths = pathfinding_max_paths config.transport.server = matrix_server contracts = load_deployed_contracts_data(config, network_id) rpc_client = JSONRPCClient( web3=web3, privkey=privatekey, gas_price_strategy=gas_price, block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS, ) token_network_registry_deployed_at = None if "TokenNetworkRegistry" in contracts: token_network_registry_deployed_at = BlockNumber( contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["block_number"] ) if token_network_registry_deployed_at is None: smart_contracts_start_at = get_smart_contracts_start_at(network_id) else: smart_contracts_start_at = token_network_registry_deployed_at proxy_manager = ProxyManager( rpc_client=rpc_client, contract_manager=ContractManager(config.contracts_path), metadata=ProxyManagerMetadata( token_network_registry_deployed_at=token_network_registry_deployed_at, filters_start_at=smart_contracts_start_at, ), ) api_server: Optional[APIServer] = None if config.rest_api.rest_api_enabled: api_server = start_api_server( rpc_client=rpc_client, config=config.rest_api, eth_rpc_endpoint=eth_rpc_endpoint ) if sync_check: check_synced(rpc_client) # The user has the option to launch Raiden with a custom # user deposit contract address. This can be used to load # the addresses for the rest of the deployed contracts. # The steps done here make sure that if a UDC address is provided, # the address has to be valid and all the connected contracts # are configured properly. # If a UDC address was not provided, Raiden would fall back # to using the ones deployed and provided by the raiden-contracts package. if user_deposit_contract_address is not None: if not is_address(user_deposit_contract_address): raise RaidenError("The user deposit address is invalid") deployed_addresses = load_deployment_addresses_from_udc( proxy_manager=proxy_manager, user_deposit_address=user_deposit_contract_address, block_identifier=BLOCK_ID_LATEST, ) else: deployed_addresses = load_deployment_addresses_from_contracts(contracts=contracts) # Load the available matrix servers when no matrix server is given # The list is used in a PFS check if config.transport.server == MATRIX_AUTO_SELECT_SERVER: fetch_available_matrix_servers(config.transport, environment_type) raiden_bundle = raiden_bundle_from_contracts_deployment( proxy_manager=proxy_manager, token_network_registry_address=deployed_addresses.token_network_registry_address, secret_registry_address=deployed_addresses.secret_registry_address, ) services_bundle = services_bundle_from_contracts_deployment( config=config, deployed_addresses=deployed_addresses, proxy_manager=proxy_manager, routing_mode=routing_mode, pathfinding_service_address=pathfinding_service_address, enable_monitoring=enable_monitoring, ) check_ethereum_confirmed_block_is_not_pruned( jsonrpc_client=rpc_client, secret_registry=raiden_bundle.secret_registry, confirmation_blocks=config.blockchain.confirmation_blocks, ) database_path = Path( os.path.join( datadir, f"node_{pex(address)}", f"netid_{network_id}", f"network_{pex(raiden_bundle.token_network_registry.address)}", f"v{RAIDEN_DB_VERSION}_log.db", ) ) config.database_path = database_path print(f"Raiden is running in {environment_type.value.lower()} mode") print( "\nYou are connected to the '{}' network and the DB path is: {}".format( ID_TO_CHAINNAME.get(network_id, network_id), database_path ) ) matrix_transport = setup_matrix( config.transport, config.services, environment_type, routing_mode ) event_handler: EventHandler = RaidenEventHandler() # User should be told how to set fees, if using default fee settings log.debug("Fee Settings", fee_settings=fee_config) has_default_fees = ( len(fee_config.token_to_flat_fee) == 0 and len(fee_config.token_to_proportional_fee) == 0 and len(fee_config.token_to_proportional_imbalance_fee) == 0 ) if has_default_fees: click.secho( "Default fee settings are used. " "If you want use Raiden with mediation fees - flat, proportional and imbalance fees - " "see https://raiden-network.readthedocs.io/en/latest/overview_and_guide.html#firing-it-up", # noqa: E501 fg="yellow", ) # Only send feedback when PFS is used if routing_mode == RoutingMode.PFS: event_handler = PFSFeedbackEventHandler(event_handler) message_handler = MessageHandler() one_to_n_address = ( services_bundle.one_to_n.address if services_bundle.one_to_n is not None else None ) monitoring_service_address = ( services_bundle.monitoring_service.address if services_bundle.monitoring_service is not None else None ) raiden_app = App( config=config, rpc_client=rpc_client, proxy_manager=proxy_manager, query_start_block=smart_contracts_start_at, default_registry=raiden_bundle.token_network_registry, default_secret_registry=raiden_bundle.secret_registry, default_service_registry=services_bundle.service_registry, default_user_deposit=services_bundle.user_deposit, default_one_to_n_address=one_to_n_address, default_msc_address=monitoring_service_address, transport=matrix_transport, raiden_event_handler=event_handler, message_handler=message_handler, routing_mode=routing_mode, api_server=api_server, ) raiden_app.start() if config.pfs_config is not None: # This has to be done down here since there is a circular dependency # between the PFS and Transport pfs_broadcast_room_key = make_room_alias(config.chain_id, PATH_FINDING_BROADCASTING_ROOM) check_pfs_transport_configuration( pfs_info=config.pfs_config.info, pfs_was_autoselected=(pathfinding_service_address == MATRIX_AUTO_SELECT_SERVER), transport_pfs_broadcast_room_id=matrix_transport.broadcast_rooms[ pfs_broadcast_room_key ].room_id, matrix_server_url=matrix_transport.server_url, matrix_server_was_autoselected=(config.transport.server == MATRIX_AUTO_SELECT_SERVER), ) return raiden_app
import json from web3 import Web3, HTTPProvider import sys from flask import Flask, render_template # ----- Connect to smart contract ----- # setup web3 instance using ganache ganache_url = "http://127.0.0.1:8545" w3 = Web3(HTTPProvider(ganache_url)) if w3.isConnected(): print("Web3 Connected") else: sys.exit("Couldn't connect to the blockchain via web3") # set default account w3.eth.defaultAccount = w3.eth.accounts[0] # contract details contract_path = './SmartContract/truffle/build/contracts/oceanCoin.json' fp = open('./SmartContract/address.dat', 'r') contract_address = fp.read() fp.close() print("Contract Address: ", contract_address) # open compiled file and get abi & bytecode truffleFile = json.load(open(contract_path)) abi = truffleFile['abi'] bytecode = truffleFile['bytecode'] # contract interface oceanCoin = w3.eth.contract(address=contract_address, abi=abi)
from pwn import * from web3 import Web3, HTTPProvider from solc import compile_files import os import time myAddress = '0xB3580FB6944BC704149CE71DF2247897755Ba7d7' myKey = '0x7613f3f0e75e124b78280cde672d5870ea87ebdea19aca556e1c6a720e8fbe82' w3 = Web3( HTTPProvider( r'https://ropsten.infura.io/v3/6a17ad8ec1ff4b5c97d809725b515aac')) def call(function, value): txn = function.buildTransaction({ 'value': w3.toWei(value, 'ether'), 'nonce': w3.eth.getTransactionCount(myAddress), 'gas': int(w3.eth.getBlock("latest").gasLimit * 0.9), 'gasPrice': w3.toWei('1000', 'gwei') }) sign = w3.eth.account.sign_transaction(txn, myKey) return w3.eth.sendRawTransaction(sign.rawTransaction) os.environ[ 'SOLC_BINARY'] = '/mnt/c/Users/B10515025/Desktop/NTUST_CTF/HW3/solc.exe' ALL_OUTPUT_VALUES = (
import json from web3 import Web3, HTTPProvider, IPCProvider from web3.middleware import geth_poa_middleware import os from os.path import join, dirname from dotenv import load_dotenv load_dotenv(join(dirname(__file__), '.env')) if(os.environ.get("WEB3_USE_IPC") == False): web3 = Web3(HTTPProvider(os.environ.get("WEB3_HTTP_PROVIDER_URL"))) else: web3 = Web3(IPCProvider(os.environ.get("WEB3_IPC_PROVIDER_URL"))) if(os.environ.get("WEB3_MIDDLEWARE_ONION_INJECT")): web3.middleware_onion.inject(geth_poa_middleware, layer=0) web3.eth.defaultAccount = web3.eth.accounts[2] with open('../build/contracts/ClientExample3.json') as file: contract_json = json.load(file) contract_abi = contract_json['abi'] AcriaClient = web3.eth.contract(address=os.environ.get("ACRIA_CLIENT_ADDRESS"), abi=contract_abi) zBytes = "USD/GBP" len1 = len(zBytes) if len1 > 8: print('input string length: '+ str(len1)+ ' is too long') zBytes32 = zBytes[:8]
#!/usr/bin/env python3 import time from web3 import Web3, HTTPProvider from hour_log_process import update_price web3_rpc = Web3(HTTPProvider('http://192.168.0.4:8545')) print(web3_rpc.isConnected()) while True: print(str(format(round(update_price("ethereum")),',')).rjust(6)) a = web3_rpc.eth.syncing if a is False: print("Local Node Done Syncing") break print(a['highestBlock']-a['currentBlock'], "blocks left to catch up") time.sleep(60)
def __init__(self, args: list, **kwargs): parser = argparse.ArgumentParser(prog='mpx-market-maker-keeper') parser.add_argument("--rpc-host", type=str, default="localhost", help="JSON-RPC host (default: `localhost')") parser.add_argument("--rpc-port", type=int, default=8545, help="JSON-RPC port (default: `8545')") parser.add_argument("--rpc-timeout", type=int, default=10, help="JSON-RPC timeout (in seconds, default: 10)") parser.add_argument( "--eth-from", type=str, required=True, help="Ethereum account from which to send transactions") parser.add_argument( "--eth-key", type=str, nargs='*', help= "Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')" ) parser.add_argument( "--mpx-api-server", type=str, default='https://api.mpexchange.io', help= "Address of the MPX API server (default: 'https://api.mpexchange.io')" ) parser.add_argument( "--mpx-api-timeout", type=float, default=9.5, help="Timeout for accessing the MPX API (in seconds, default: 9.5)" ) parser.add_argument( "--exchange-address", type=str, required=True, help="Ethereum address of the Mpx Exchange contract") parser.add_argument("--fee-address", type=str, required=True, help="Ethereum address of the Mpx Fee contract") parser.add_argument( "--pair", type=str, required=True, help="Token pair (sell/buy) on which the keeper will operate") parser.add_argument("--sell-token-address", type=str, required=True, help="Ethereum address of the Sell Token") parser.add_argument("--buy-token-address", type=str, required=True, help="Ethereum address of the Buy Token") parser.add_argument("--gas-price", type=int, default=0, help="Gas price (in Wei)") parser.add_argument( "--smart-gas-price", dest='smart_gas_price', action='store_true', help= "Use smart gas pricing strategy, based on the ethgasstation.info feed" ) parser.add_argument("--ethgasstation-api-key", type=str, default=None, help="ethgasstation API key") parser.add_argument("--config", type=str, required=True, help="Bands configuration file") parser.add_argument("--price-feed", type=str, required=True, help="Source of price feed") parser.add_argument( "--price-feed-expiry", type=int, default=120, help="Maximum age of the price feed (in seconds, default: 120)") parser.add_argument("--spread-feed", type=str, help="Source of spread feed") parser.add_argument( "--spread-feed-expiry", type=int, default=3600, help="Maximum age of the spread feed (in seconds, default: 3600)") parser.add_argument("--control-feed", type=str, help="Source of control feed") parser.add_argument( "--control-feed-expiry", type=int, default=86400, help="Maximum age of the control feed (in seconds, default: 86400)" ) parser.add_argument("--order-history", type=str, help="Endpoint to report active orders to") parser.add_argument( "--order-history-every", type=int, default=30, help= "Frequency of reporting active orders (in seconds, default: 30)") parser.add_argument( "--refresh-frequency", type=int, default=3, help="Order book refresh frequency (in seconds, default: 3)") parser.add_argument("--debug", dest='debug', action='store_true', help="Enable debug output") self.arguments = parser.parse_args(args) setup_logging(self.arguments) self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3( HTTPProvider( endpoint_uri= f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}", request_kwargs={"timeout": self.arguments.rpc_timeout})) self.web3.eth.defaultAccount = self.arguments.eth_from self.our_address = Address(self.arguments.eth_from) register_keys(self.web3, self.arguments.eth_key) self.token_buy = ERC20Token(web3=self.web3, address=Address( self.arguments.buy_token_address)) self.token_sell = ERC20Token(web3=self.web3, address=Address( self.arguments.sell_token_address)) self.bands_config = ReloadableConfig(self.arguments.config) self.price_max_decimals = None self.gas_price = GasPriceFactory().create_gas_price( self.web3, self.arguments) self.price_feed = PriceFeedFactory().create_price_feed(self.arguments) self.spread_feed = create_spread_feed(self.arguments) self.control_feed = create_control_feed(self.arguments) self.order_history_reporter = create_order_history_reporter( self.arguments) self.history = History() self.zrx_exchange = ZrxExchangeV2(web3=self.web3, address=Address( self.arguments.exchange_address)) self.mpx_api = MpxApi(api_server=self.arguments.mpx_api_server, zrx_exchange=self.zrx_exchange, fee_recipient=Address( self.arguments.fee_address), timeout=self.arguments.mpx_api_timeout, our_address=self.arguments.eth_from) self.zrx_relayer_api = ZrxRelayerApiV2( exchange=self.zrx_exchange, api_server=self.arguments.mpx_api_server) self.zrx_api = ZrxApiV2(zrx_exchange=self.zrx_exchange, zrx_api=self.zrx_relayer_api) markets = self.mpx_api.get_markets()['data'] market = next( filter( lambda item: item['attributes']['pair-name'] == self.arguments. pair, markets)) self.pair = MpxPair(self.arguments.pair, self.token_buy.address, int(market['attributes']['base-token-decimals']), self.token_sell.address, int(market['attributes']['quote-token-decimals'])) self.order_book_manager = OrderBookManager( refresh_frequency=self.arguments.refresh_frequency) self.order_book_manager.get_orders_with(lambda: self.get_orders()) self.order_book_manager.get_balances_with(lambda: self.get_balances()) self.order_book_manager.cancel_orders_with(self.cancel_order_function) self.order_book_manager.place_orders_with(self.place_order_function) self.order_book_manager.enable_history_reporting( self.order_history_reporter, self.our_buy_orders, self.our_sell_orders) self.order_book_manager.start()
def attempt_connect( self, name: NodeName, ethrpc_endpoint: str, mainnet_check: bool = True, ) -> Tuple[bool, str]: """Attempt to connect to a particular node type For our own node if the given rpc endpoint is not the same as the saved one the connection is re-attempted to the new one """ message = '' node_connected = self.web3_mapping.get(name, None) is not None own_node_already_connected = ( name == NodeName.OWN and self.own_rpc_endpoint == ethrpc_endpoint and node_connected ) if own_node_already_connected or (node_connected and name != NodeName.OWN): return True, 'Already connected to an ethereum node' try: parsed_eth_rpc_endpoint = urlparse(ethrpc_endpoint) if not parsed_eth_rpc_endpoint.scheme: ethrpc_endpoint = f"http://{ethrpc_endpoint}" provider = HTTPProvider( endpoint_uri=ethrpc_endpoint, request_kwargs={'timeout': self.eth_rpc_timeout}, ) ens = ENS(provider) web3 = Web3(provider, ens=ens) web3.middleware_onion.inject(http_retry_request_middleware, layer=0) except requests.exceptions.ConnectionError: message = f'Failed to connect to ethereum node {name} at endpoint {ethrpc_endpoint}' log.warning(message) return False, message if web3.isConnected(): # Also make sure we are actually connected to the Ethereum mainnet synchronized = True msg = '' if mainnet_check: network_id = int(web3.net.version) if network_id != 1: message = ( f'Connected to ethereum node {name} at endpoint {ethrpc_endpoint} but ' f'it is not on the ethereum mainnet. The chain id ' f'the node is in is {network_id}.' ) log.warning(message) return False, message current_block = web3.eth.blockNumber # pylint: disable=no-member try: latest_block = self.query_eth_highest_block() except RemoteError: msg = 'Could not query latest block' log.warning(msg) synchronized = False else: synchronized, msg = _is_synchronized(current_block, latest_block) if not synchronized: self.msg_aggregator.add_warning( f'We could not verify that ethereum node {name} is ' 'synchronized with the ethereum mainnet. Balances and other queries ' 'may be incorrect.', ) log.info(f'Connected ethereum node {name} at {ethrpc_endpoint}') self.web3_mapping[name] = web3 return True, '' else: message = f'Failed to connect to ethereum node {name} at endpoint {ethrpc_endpoint}' log.warning(message) # If we get here we did not connnect return False, message
from web3 import Web3, HTTPProvider import requests import yaml from time import sleep import json from multiprocessing.dummy import Pool as ThreadPool import itertools from tqdm import tqdm with open("config.yml", 'r') as config: cfg = yaml.load(config, Loader=yaml.FullLoader) eth_provider = str(cfg["eth_provider_url"]) w3 = Web3(HTTPProvider(eth_provider)) file_name = cfg["file_name"] csv_delimiter = str(cfg["csv_delimiter"]) csv_file_name = file_name + ".csv" recipient_address = str(cfg["recipient_address"]) eth_gas_limit = int(cfg["eth_gas_limit"]) eth_gas_price = int(cfg["manual_gas_price"] * 1e9) wait_for_gasprice_value = int(cfg["wait_for_gasprice_value"] * 1e9) wait_for_gasprice = str(cfg["wait_for_gasprice"]) sleep_before_tx = cfg["sleep_before_tx"] threads_count = int(cfg["threads_count"]) contract_address = Web3.toChecksumAddress( "0x1cc4426e36faeff09963d6b8b2da3b45f2f1deeb") with open("utils/balance_checker_ABI.json") as f: info_json = json.load(f) abi = info_json contract = w3.eth.contract(contract_address, abi=abi)
import json from web3 import Web3, HTTPProvider # truffle development blockchain address blockchain_address = 'http://127.0.0.1:9545' web3 = Web3(HTTPProvider(blockchain_address)) web3.eth.defaultAccount = web3.eth.accounts[0] compiled_contract_path = '../build/contracts/AcriaMain.json' deployed_contract_address = '0x25339522Df3d615ed729F6c0380B94E93B4eAE64' with open(compiled_contract_path) as file: contract_json = json.load(file) contract_abi = contract_json['abi'] AcriaMain = web3.eth.contract(address=deployed_contract_address, abi=contract_abi) zBytes = "BTC/USD" len1 = len(zBytes) if len1 > 32: print('input string length: ' + str(len1) + ' is too long') zBytes32 = zBytes[:32] else: print('input string length: ' + str(len1) + ' is too short') print('More characters needed: ' + str(32 - len1)) zBytes32 = zBytes.ljust(32, ' ')
def __init__(self, root_chain_provider=HTTPProvider('http://localhost:8545'), child_chain_url="http://localhost:8546/jsonrpc"): deployer = Deployer(root_chain_provider) self.root_chain = deployer.get_contract_at_address("RootChain", CONTRACT_ADDRESS, concise=True) self.child_chain = ChildChainService(child_chain_url)
def start_mining(ip, capture_ip): web3 = Web3(HTTPProvider('http://{}:8545'.format(ip))) web3.miner.setEtherBase(capture_ip) web3.miner.start(4) return web3.eth.mining
#!/usr/bin/env python3 import time import sys import json import math import traceback import os import pandas as pd import numpy as np from web3 import Web3, HTTPProvider node_url = os.getenv('ETH_NODE_URL', 'http://localhost:8545') web3 = Web3(HTTPProvider(node_url)) ### These are the threholds used for % blocks accepting to define the recommended gas prices. can be edited here if desired SAFELOW = 35 STANDARD = 60 FAST = 90 class Timers(): """ class to keep track of time relative to network block """ def __init__(self, start_block): self.start_block = start_block self.current_block = start_block self.process_block = start_block
import argparse from web3 import Web3, HTTPProvider import json import time import sys, os sys.path.append( os.path.join(os.path.dirname(__file__), 'D:/Проекты/Green_wave/src')) import service_function network_config = open('network.json', 'r') rpcUrl = str(json.load(network_config)['rpcUrl']) web3 = Web3(HTTPProvider(rpcUrl)) def key_to_value(args): if (args.deploy != " "): f = open('network.json', 'r') private_key = str(json.load(f)['privKey']) private_key_for_senders_account = private_key addressUser = Web3.toChecksumAddress( web3.eth.account.privateKeyToAccount( '0x' + str(private_key_for_senders_account)).address) with open("carscoins.bin") as bin_file: content = json.loads(bin_file.read()) bytecode = content['object'] with open("carscoins.abi") as abi_file: abi = json.loads(abi_file.read())
import json import time from eth_utils import to_checksum_address from web3 import Web3, HTTPProvider from web3.contract import ConciseContract from web3.middleware import geth_poa_middleware # Solidity source code # web3.py instance # w3 = Web3(HTTPProvider('http://localhost:8545')) # ganache or w3 = Web3(HTTPProvider('https://ropsten.infura.io/NiFrWVGDUTero8xrCJF8')) w3.middleware_stack.inject(geth_poa_middleware, layer=0) # BasicToken abi with open('build/contracts/BasicToken.json', 'r') as f: contract_meta_json = json.loads(f.read()) contract_abi = contract_meta_json['abi'] contract_bin = contract_meta_json['bytecode'] contract = w3.eth.contract(abi=contract_abi, bytecode=contract_bin) # # Get contract address # tx_hash = contract.deploy(transaction={'from': '0x8F8d1bc97E8939e3932BfBeb923A1B2B972D5A9A', 'gas': 41000}) # # while True: # tx_receipt = w3.eth.getTransactionReceipt(tx_hash) # if tx_receipt is not None: # break
from tinydb.operations import delete from OneBitRangeProof import VerifyRangeProofs, GetMerkelProof, ExtractProof CT_Validator_Options = { #Percentage of proofs to verify 0-100 'pct_proof_check': 100, #Finalize all proofs, even if they are not our own (No benefit to me) 'finalize_all_proofs': True, #Proof Data Source 'pull_proof_data_from_event': False } #Connect to local node w3 = Web3(HTTPProvider("http://127.0.0.1:8545")) assert(w3.isConnected()) w3.middleware_stack.inject(geth_poa_middleware, layer=0) #Unlock account accounts = w3.personal.listAccounts assert(len(accounts) > 0) account = accounts[0] pwd = getpass() assert(w3.personal.unlockAccount(account, pwd)) del pwd #Load contract address and abi with open("RangeProofRegistryABI.json") as f: contract_json = json.load(f)
from web3 import Web3, HTTPProvider import urllib3 from solc import compile_source urllib3.disable_warnings() web3 = Web3( HTTPProvider('https://ropsten.infura.io/xxxxxxxxxx', {'verify': False})) private_key = '0x000000000000000000000000000000' account = web3.eth.account.privateKeyToAccount(private_key) web3.eth.defaultAccount = account.address challenge_contract_address = '0x000000000000000000000000000' with open('challenge.sol', 'r') as f: contract_source_code = f.read() compiled_sol = compile_source(contract_source_code, allow_paths='.')['<stdin>:TokenSaleChallenge'] def send_transaction_sync(tx, args={}): args['nonce'] = web3.eth.getTransactionCount(account.address) signed_txn = account.signTransaction(tx.buildTransaction(args)) tx_hash = web3.eth.sendRawTransaction(signed_txn.rawTransaction) return web3.eth.waitForTransactionReceipt(tx_hash) contract = web3.eth.contract(abi=compiled_sol['abi'], address=challenge_contract_address) min_token_number_with_overflow = 2**256 // 10**18 + 1
import src.txFunction as txF from web3 import Web3, HTTPProvider, IPCProvider, WebsocketProvider import sys w3 = Web3(HTTPProvider('http://localhost:8545')) dst = sys.argv[1] block_start = int(sys.argv[2]) block_end = int(sys.argv[3]) txF.extractTx(w3, dst, block_start, block_end)
#!/usr/bin/python # -*- coding: utf-8 -*- import queue import threading import pymongo import datetime import cfscrape import re import time from web3 import Web3, HTTPProvider from bson.decimal128 import Decimal128 from pymongo import MongoClient web3 = Web3(HTTPProvider('http://127.0.0.1:8545')) latestBlock = web3.eth.getBlock('latest') exitFlag = 0 retries = 10 timeout = 1 # seconds wait = 2 # seconds def init(): if web3.eth.syncing == False: print('Ethereum blockchain is up-to-date.') print('Latest block: ' + str(latestBlock.number) + ' (' + datetime.datetime.fromtimestamp( int(latestBlock.timestamp)).strftime('%d-%m-%Y %H:%M:%S') + ')\n')
def __init__(self, args: list, **kwargs): parser = argparse.ArgumentParser(prog='tethfinex-market-maker-keeper') parser.add_argument("--rpc-host", type=str, default="localhost", help="JSON-RPC host (default: `localhost')") parser.add_argument("--rpc-port", type=int, default=8545, help="JSON-RPC port (default: `8545')") parser.add_argument("--rpc-timeout", type=int, default=10, help="JSON-RPC timeout (in seconds, default: 10)") parser.add_argument( "--eth-from", type=str, required=True, help="Ethereum account from which to send transactions") parser.add_argument( "--eth-key", type=str, nargs='*', help= "Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')" ) parser.add_argument( "--exchange-address", type=str, required=True, help="Ethereum address of the 0x Exchange contract") parser.add_argument("--tub-address", type=str, required=False, help="Ethereum address of the Tub contract") parser.add_argument( "--tethfinex-api-server", type=str, default='https://api.ethfinex.com', help= "Address of the Trustless Ethfinex API server (default: 'https://api.ethfinex.com')" ) parser.add_argument( "--tethfinex-timeout", type=float, default=9.5, help="Timeout for accessing the IDEX API (in seconds, default: 9.5)" ) parser.add_argument( "--pair", type=str, required=True, help="Token pair (sell/buy) on which the keeper will operate") parser.add_argument("--config", type=str, required=True, help="Bands configuration file") parser.add_argument("--price-feed", type=str, required=True, help="Source of price feed") parser.add_argument( "--price-feed-expiry", type=int, default=120, help="Maximum age of the price feed (in seconds, default: 120)") parser.add_argument("--spread-feed", type=str, help="Source of spread feed") parser.add_argument( "--spread-feed-expiry", type=int, default=3600, help="Maximum age of the spread feed (in seconds, default: 3600)") parser.add_argument("--control-feed", type=str, help="Source of control feed") parser.add_argument( "--control-feed-expiry", type=int, default=86400, help="Maximum age of the control feed (in seconds, default: 86400)" ) parser.add_argument("--order-history", type=str, help="Endpoint to report active orders to") parser.add_argument( "--order-history-every", type=int, default=30, help= "Frequency of reporting active orders (in seconds, default: 30)") parser.add_argument("--gas-price", type=int, default=0, help="Gas price (in Wei)") parser.add_argument( "--smart-gas-price", dest='smart_gas_price', action='store_true', help= "Use smart gas pricing strategy, based on the ethgasstation.info feed" ) parser.add_argument("--ethgasstation-api-key", type=str, default=None, help="ethgasstation API key") parser.add_argument( "--refresh-frequency", type=int, default=3, help="Order book refresh frequency (in seconds, default: 3)") parser.add_argument("--debug", dest='debug', action='store_true', help="Enable debug output") parser.set_defaults(cancel_on_shutdown=False, withdraw_on_shutdown=False) self.arguments = parser.parse_args(args) setup_logging(self.arguments) self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3( HTTPProvider( endpoint_uri= f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}", request_kwargs={"timeout": self.arguments.rpc_timeout})) self.web3.eth.defaultAccount = self.arguments.eth_from self.our_address = Address(self.arguments.eth_from) register_keys(self.web3, self.arguments.eth_key) tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address)) \ if self.arguments.tub_address is not None else None self.sai = ERC20Token(web3=self.web3, address=tub.sai()) self.price_feed = PriceFeedFactory().create_price_feed( self.arguments, tub) self.bands_config = ReloadableConfig(self.arguments.config) self.gas_price = GasPriceFactory().create_gas_price(self.arguments) self.spread_feed = create_spread_feed(self.arguments) self.control_feed = create_control_feed(self.arguments) self.order_history_reporter = create_order_history_reporter( self.arguments) self.history = History() self.tethfinex_exchange = ZrxExchange( web3=self.web3, address=Address(self.arguments.exchange_address)) self.tethfinex_api = TEthfinexApi( self.tethfinex_exchange, self.arguments.tethfinex_api_server, timeout=self.arguments.tethfinex_timeout) config = self.tethfinex_api.get_config()['0x'] self.fee_address = Address(config['ethfinexAddress']) token_registry = config['tokenRegistry'] token_sell = self.token_sell() token_buy = self.token_buy() self.token_sell_wrapper = TEthfinexToken( self.web3, Address(token_registry[token_sell]['wrapperAddress']), token_sell) self.token_buy_wrapper = TEthfinexToken( self.web3, Address(token_registry[token_buy]['wrapperAddress']), token_buy) pair = self.pair() self.order_book_manager = OrderBookManager( refresh_frequency=self.arguments.refresh_frequency, max_workers=1) self.order_book_manager.get_orders_with( lambda: self.tethfinex_api.get_orders(pair)) self.order_book_manager.cancel_orders_with( lambda order: self.tethfinex_api.cancel_order(order.order_id)) self.order_book_manager.enable_history_reporting( self.order_history_reporter, self.our_buy_orders, self.our_sell_orders) self.order_book_manager.start()
import os import time from web3 import Web3, HTTPProvider from pyflex import Address from pyflex.gf import SAFE from pyflex.deployment import GfDeployment from pyflex.keys import register_keys if len(sys.argv) != 2: print("usage: python can_liq_safe.py <safe addr>") sys.exit() ETH_RPC_URL = os.environ['ETH_RPC_URL'] web3 = Web3( HTTPProvider(endpoint_uri=ETH_RPC_URL, request_kwargs={"timeout": 60})) while web3.eth.syncing: print("Node is syncing") time.sleep(5) geb = GfDeployment.from_node(web3, 'rai') collateral = geb.collaterals['ETH-A'] collateral_type = geb.safe_engine.collateral_type( collateral.collateral_type.name) rate = collateral_type.accumulated_rate safe = geb.safe_engine.safe(collateral_type, Address(sys.argv[1])) if not geb.liquidation_engine.can_liquidate(collateral_type, safe): print("SAFE can't be liquidated.")
from kudos.models import BulkTransferCoupon from marketing.mails import ( grant_cancellation, new_grant, new_grant_admin, new_supporter, subscription_terminated, support_cancellation, thank_you_for_supporting, ) from marketing.models import Keyword, Stat from retail.helpers import get_ip from web3 import HTTPProvider, Web3 logger = logging.getLogger(__name__) w3 = Web3(HTTPProvider(settings.WEB3_HTTP_PROVIDER)) clr_matching_banners_style = 'pledging' matching_live = '($200K matching live now!) ' total_clr_pot = 200000 clr_round = 4 clr_active = True if True: clr_matching_banners_style = 'results' matching_live = '' def get_keywords(): """Get all Keywords.""" return json.dumps([
f1=open("./contract.abi",'r') f2=open("./contract.adr",'r') #Load contract ABI, Address abi=eval(f1.read()) adr=f2.read().rstrip('\n') f2.close() f1.close() #Set Account Password, RPC geth URL passwd="jj" rpc_url = "http://localhost:8545" w3 = Web3(HTTPProvider(rpc_url)) w3.geth.personal.unlockAccount(w3.eth.accounts[0],passwd,15000) # set pre-funded account as sender w3.eth.defaultAccount = w3.eth.accounts[0] checker = w3.eth.contract(address=adr, abi=abi) def createFile(userId,fileHash): tx_hash=checker.functions.createFile(userId,fileHash).transact() #tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash,600) def updateFile(fileId,fileHash): tx_hash=checker.functions.updateFile(fileId,fileHash).transact() #tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash,600) def deleteFile(fileId): tx_hash=checker.functions.deleteFile(fileId).transact() #tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash,600)
import time from web3 import HTTPProvider from web3 import Web3 from core.contracts import RobotLiabilityFactoryContract, RobotLiabilityContract from core.utils import MultihashConverter __author__ = 'Xomak' web3_rpc_url = "http://localhost:8545/" factory_contract_address = "0x12301cb37191136a70c2cb8c5ec1240b69ad3668" sender_address = "0x7262e87595e3bb70f31cc465b28b2b8b2355faa3" active_liability = None web3 = Web3(HTTPProvider(web3_rpc_url, request_kwargs={'timeout': 60})) ipfs_client = ipfsapi.connect() factory_contract = RobotLiabilityFactoryContract(web3, factory_contract_address, sender_address) active_liabilities = [] def callback(block): print("New block") new_contracts = factory_contract.get_new_contracts(sender_address) for contract_address in new_contracts: print("New contract: " + contract_address) active_liabilities.append( RobotLiabilityContract(web3, contract_address, sender_address))
def __init__(self, ethereum_url, user_address) -> None: self.contract_interface = self._load_contract_interface() self.w3 = Web3(HTTPProvider(ethereum_url)) self.user_address = user_address
file_acc = open(chain_location + chain_name + "/py_script_info/list_smgw.csv", "r") list_acc = func_fileIO.readStringArrayFromFile(file_acc) file_acc.close() # load generation curves file_gen = open(chain_location + chain_name + "/py_script_info/input_gen.csv", "r") list_gen = func_fileIO.readFloatArrayFromFile(file_gen) file_gen.close() pv_curve, chp_curve = list_gen[0], list_gen[1] # connect to chain # Establish RPC connection with running node. web3 = Web3(HTTPProvider("http://localhost:8501")) pw = "reghee" # configure smart contract (already deployed on chain manually) contract_address = web3.toChecksumAddress( 0x5e00292eb39f84d94a452866a8cd9c4d0aa7fc65) contract_abi = json.loads(abi_smartcert.returnABIstr()) contract = web3.eth.contract(abi=contract_abi, address=contract_address) for entry in list_acc: func_BC.py_addSMGW(web3, contract, web3.toChecksumAddress(entry[0]), web3.toChecksumAddress(entry[4]), pw) # wait for new block before beginning simulation func_BC.py_waitForNextBlock(
# Created by PyCharm. # User: shehin . F.N # Date: 2/5/18 # Time: 12:07 PM from web3 import Web3, HTTPProvider from flask import Flask, request, jsonify from tasks import celery_app, celery_update_wallet provider = HTTPProvider('http://127.0.0.1:8545') web3 = Web3(provider) app = Flask(__name__) @app.after_request def after_request(response): response.headers.add('Access-Control-Allow-Origin', '*') response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization') response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS') return response @app.route("/updateWallet", methods=['POST', 'GET']) def updateWallet(): req = request.form.to_dict(flat=True) result = celery_update_wallet.delay(req['blockNumber']) data = { 'success': True, 'status_code': '200',
def get_price(): # Retrieve latest FLX price from coingecko resp = requests.get('https://api.coingecko.com/api/v3/simple/price', params={'ids': 'reflexer-ungovernance-token', 'vs_currencies': 'usd'}) return resp.json()['reflexer-ungovernance-token']['usd'] """ Sample auction input: {'id': '1', 'bid_amount': '3.000000000000000000000000000000000000000000000', 'amount_to_sell': '439.000000000000000000', 'block_time': 1652104620, 'auction_deadline': 1652363564, 'price': '0.006833712984054669', 'bid_decrease': '1.030000000000000000', 'high_bidder': '0x6073E8FE874B53732b5DdD469a2De4047f33C64B', 'debt_auction_house': '0x6AcE594C5A421E468c13715AD62A183200C320a6'} """ current_flx_usd_price = get_price() web3 = Web3(HTTPProvider(os.environ['ETH_RPC_URL'])) geb = GfDeployment.from_node(web3, 'rai') redemption_price = geb.oracle_relayer.redemption_price() # FLX Price to bid MAXIMUM_FLX_MULTIPLIER = 0.90 # Buy FLX for 90% of current price # Custom bid decrease # The minimum auction bid decrease can be low, setting a higher one can prevent too many bids # If you want to always use the minimum bid decrease allowed, set this to 0 MY_BID_DECREASE = 1.03 for auction_input in sys.stdin: auction_state = json.loads(auction_input) # If we are already the high bidder, do nothing
import sys import json import math import traceback import os import pandas as pd import numpy as np from web3 import Web3, HTTPProvider ## newly added packages for api import click import logging from threading import Thread from sanic import Sanic, response from retry import retry web3 = Web3(HTTPProvider('https://bsc-dataseed2.binance.org')) ### These are the threholds used for % blocks accepting to define the recommended gas prices. can be edited here if desired app = Sanic() log = logging.getLogger('sanic.error') app.config.LOGO = '' stats = {} SAFELOW = 35 STANDARD = 60 FAST = 90 class Timers(): """ class to keep track of time relative to network block """