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")
