def get_web3(network: str = config["network"],
provider: str = config["provider"]) -> Web3:
"""
Get XinFin Web3 instance.
:param network: XinFin network, defaults to ``mainnet``.
:type network: str
:param provider: XinFin network provider, defaults to ``http``.
:type provider: str
:returns: Web3 -- XinFin Web3 instance.
>>> from swap.providers.xinfin.rpc import get_web3
>>> get_web3(network="testnet", provider="http")
<web3.main.Web3 object at 0x000001DDECCD0640>
"""
# Check parameter instances
if not is_network(network=network):
raise NetworkError(
f"Invalid XinFin '{network}' network",
"choose only 'mainnet', 'apothem' or 'testnet' networks.")
if provider == "http":
web3: Web3 = Web3(
HTTPProvider(endpoint_uri=URI(config[network]["http"]),
request_kwargs={"timeout": config["timeout"]}))
return web3
elif provider == "websocket":
web3: Web3 = Web3(
WebsocketProvider(endpoint_uri=URI(config[network]["websocket"])))
return web3
else:
raise ValueError(f"Invalid XinFin '{provider}' provider",
"choose only 'http' or 'websocket' providers.")
def create_provider_from_config(rpc_config: MutableMapping):
uri = rpc_config.get("uri", None)
if uri is not None:
logger.info(f"Autodetect provider from uri {uri}")
provider = load_provider_from_uri(uri)
logger.info(f"Autodetected {provider.__class__.__name__}")
return provider
provider_type = rpc_config["type"]
if provider_type is ProviderType.HTTP:
url = "{}://{}:{}".format(
"https" if rpc_config["use_ssl"] else "http",
rpc_config["host"],
rpc_config["port"],
)
logger.info("Using HTTP provider with URL {}".format(url))
return HTTPProvider(URI(url))
elif provider_type is ProviderType.WEBSOCKET:
url = "{}://{}:{}".format(
"wss" if rpc_config["use_ssl"] else "ws",
rpc_config["host"],
rpc_config["port"],
)
logger.info("Using websocket provider with URL {}".format(url))
return WebsocketProvider(URI(url))
elif provider_type is ProviderType.IPC:
file_path = rpc_config["file_path"]
logger.info("Using IPC provider with file path {}".format(file_path))
return IPCProvider(file_path)
else:
raise ValueError(f"Unknown web3 provider type: {provider_type}")
def get_web3(network: str = config["network"], provider: str = config["provider"],
token: Optional[str] = None) -> Web3:
"""
Get Ethereum Web3 instance.
:param network: Ethereum network, defaults to ``mainnet``.
:type network: str
:param provider: Ethereum network provider, defaults to ``http``.
:type provider: str
:param token: Infura API endpoint token, defaults to ``4414fea5f7454211956b1627621450b4``.
:type token: str
:returns: Web3 -- Ethereum Web3 instance.
>>> from swap.providers.ethereum.rpc import get_web3
>>> get_web3(network="testnet", provider="http", token="infura endpoint token ...")
<web3.main.Web3 object at 0x000001DDECCD0640>
"""
# Check parameter instances
if not is_network(network=network):
raise NetworkError(f"Invalid Ethereum '{network}' network",
"choose only 'mainnet', 'ropsten', 'kovan', 'rinkeby' or 'testnet' networks.")
endpoint: str = "ganache-cli" if network == "testnet" else "infura"
token: str = token if token else config[network][endpoint]["token"]
if provider == "http":
web3: Web3 = Web3(HTTPProvider(
URI(
f"{config[network]['infura']['http']}/{token}"
if token else config[network][endpoint]["http"]
),
request_kwargs={
"timeout": config["timeout"]
}
)
)
return web3
elif provider == "websocket":
web3: Web3 = Web3(WebsocketProvider(
URI(
f"{config[network]['infura']['websocket']}/{token}"
if token else config[network][endpoint]["websocket"]
)
)
)
return web3
else:
raise ValueError(f"Invalid Ethereum '{provider}' provider",
"choose only 'http' or 'websocket' providers.")
def build_infura_url(domain: str) -> URI:
scheme = os.environ.get('WEB3_INFURA_SCHEME', WEBSOCKET_SCHEME)
key = load_api_key()
secret = load_secret()
if scheme == WEBSOCKET_SCHEME and secret != '':
return URI("%s://:%s@%s/ws/v3/%s" % (scheme, secret, domain, key))
elif scheme == WEBSOCKET_SCHEME and secret == '':
return URI("%s://%s/ws/v3/%s" % (scheme, domain, key))
elif scheme == HTTP_SCHEME:
return URI("%s://%s/v3/%s" % (scheme, domain, key))
else:
raise ValidationError("Cannot connect to Infura with scheme %r" %
scheme)
def build_infura_url(domain: str) -> URI:
scheme = os.environ.get('WEB3_INFURA_SCHEME', WEBSOCKET_SCHEME)
key = load_api_key()
secret = load_secret()
if scheme == WEBSOCKET_SCHEME and secret != '':
return URI(f"{scheme}://:{secret}@{domain}/ws/v3/{key}")
elif scheme == WEBSOCKET_SCHEME and secret == '':
return URI(f"{scheme}://{domain}/ws/v3/{key}")
elif scheme == HTTP_SCHEME:
return URI(f"{scheme}://{domain}/v3/{key}")
else:
raise ValidationError(
f"Cannot connect to Infura with scheme {scheme!r}")
def rpc_normalized_endpoint(eth_rpc_endpoint: str) -> URI:
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if "infura.io" in eth_rpc_endpoint:
# Infura needs to have the https scheme
return URI(f"https://{parsed_eth_rpc_endpoint.netloc}{parsed_eth_rpc_endpoint.path}")
if parsed_eth_rpc_endpoint.scheme:
return URI(eth_rpc_endpoint)
scheme = "http://"
if eth_rpc_endpoint.startswith("//"):
scheme = "http:"
return URI(f"{scheme}{eth_rpc_endpoint}")
def get_w3() -> Web3:
"""Set up the web3 provider for serving transactions to the ethereum network.
>>> w3 = get_w3()
>>> type(w3)
<class 'web3.main.Web3'>
>>> type(w3.provider)
<class 'web3.providers.rpc.HTTPProvider'>
>>> os.environ["HMT_ETH_SERVER"] = "wss://localhost:8546"
>>> w3 = get_w3()
>>> type(w3)
<class 'web3.main.Web3'>
>>> type(w3.provider)
<class 'web3.providers.websocket.WebsocketProvider'>
>>> del os.environ["HMT_ETH_SERVER"]
Returns:
Web3: returns the web3 provider.
"""
endpoint = os.getenv("HMT_ETH_SERVER", "http://localhost:8545")
if not endpoint:
LOG.error("Using EthereumTesterProvider as we have no HMT_ETH_SERVER")
provider = (load_provider_from_uri(URI(endpoint))
if endpoint else EthereumTesterProvider())
w3 = Web3(provider)
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
return w3
def patched_web3():
web3 = Web3(HTTPProvider(URI("http://domain/")))
monkey_patch_web3(web3=web3, gas_price_strategy=rpc_gas_price_strategy)
original_get_block = Eth.getBlock
Eth.getBlock = make_patched_web3_get_block(Eth.getBlock)
yield web3
Eth.getBlock = original_get_block
def __init__(self, token_name: str = 'ETH'):
self.block_count_to_wait_confirm = ETH_BLOCK_TO_WAIT_FOR_CONFIRM
self.token_name = token_name
self.logger = get_default_logger(log_level=logging.INFO)
engine = create_engine(MYSQL_CONNECT_INFO, max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine, autocommit=True, autoflush=False)
self.session = Session()
self.redis = redis.Redis(host=REDIS_HOST,
port=REDIS_PORT,
db=REDIS_ADDRESS_POOL_DB_NAME,
decode_responses=True)
self.myweb3 = Web3(provider=HTTPProvider(
endpoint_uri=URI(ETH_FULL_NODE_RPC_URL)))
if not g_IS_MAINNET and ETH_CHAIN_ID == 4:
self.myweb3.middleware_onion.inject(element=geth_poa_middleware,
layer=0)
super().__init__()
pass
def __init__(
self,
endpoint_uri: Optional[Union[URI, str]] = None,
websocket_kwargs: Any = None,
websocket_timeout: int = DEFAULT_WEBSOCKET_TIMEOUT,
) -> None:
self.endpoint_uri = URI(endpoint_uri)
self.websocket_timeout = websocket_timeout
if self.endpoint_uri is None:
self.endpoint_uri = get_default_endpoint()
if WebsocketProvider._loop is None:
WebsocketProvider._loop = _get_threaded_loop()
if websocket_kwargs is None:
websocket_kwargs = {}
else:
found_restricted_keys = set(websocket_kwargs.keys()).intersection(
RESTRICTED_WEBSOCKET_KWARGS)
if found_restricted_keys:
raise ValidationError(
'{0} are not allowed in websocket_kwargs, '
'found: {1}'.format(RESTRICTED_WEBSOCKET_KWARGS,
found_restricted_keys))
self.conn = PersistentWebSocket(self.endpoint_uri,
WebsocketProvider._loop,
websocket_kwargs)
super().__init__()
def fetch_uri_contents(self, uri: URI, package_name: str,
package_version: str) -> URI:
manifest = build_etherscan_manifest(uri, package_name, package_version)
ipfs_backend = get_ipfs_backend()
ipfs_data = builder.build(manifest, builder.validate(),
builder.pin_to_ipfs(backend=ipfs_backend))
return URI(f"ipfs://{ipfs_data[0]['Hash']}")
def handle_offchain_lookup(
offchain_lookup_payload: Dict[str, Any],
transaction: TxParams,
) -> bytes:
formatted_sender = to_hex_if_bytes(
offchain_lookup_payload['sender']).lower()
formatted_data = to_hex_if_bytes(
offchain_lookup_payload['callData']).lower()
if formatted_sender != to_hex_if_bytes(transaction['to']).lower():
raise ValidationError(
'Cannot handle OffchainLookup raised inside nested call. Returned `sender` value does '
'not equal `to` address in transaction.')
for url in offchain_lookup_payload['urls']:
formatted_url = URI(
str(url).replace('{sender}', str(formatted_sender)).replace(
'{data}', str(formatted_data)))
try:
if '{data}' in url and '{sender}' in url:
response = get_response_from_get_request(formatted_url)
elif '{sender}' in url:
response = get_response_from_post_request(formatted_url,
data={
"data":
formatted_data,
"sender":
formatted_sender,
})
else:
raise ValidationError('url not formatted properly.')
except Exception:
continue # try next url if timeout or issues making the request
if 400 <= response.status_code <= 499: # if request returns 400 error, raise exception
response.raise_for_status()
if not 200 <= response.status_code <= 299: # if not 400 error, try next url
continue
result = response.json()
if 'data' not in result.keys():
raise ValidationError(
"Improperly formatted response for offchain lookup HTTP request - missing 'data' "
"field.")
encoded_data_with_function_selector = b''.join([
# 4-byte callback function selector
to_bytes_if_hex(offchain_lookup_payload['callbackFunction']),
# encode the `data` from the result and the `extraData` as bytes
encode_abi(['bytes', 'bytes'], [
to_bytes_if_hex(result['data']),
to_bytes_if_hex(offchain_lookup_payload['extraData']),
])
])
return encoded_data_with_function_selector
raise MultipleFailedRequests("Offchain lookup failed for supplied urls.")
def create_BIP122_uri(
chain_id: HexStr, resource_type: str, resource_identifier: HexStr
) -> URI:
"""
See: https://github.com/bitcoin/bips/blob/master/bip-0122.mediawiki
"""
if resource_type != BLOCK:
raise ValueError("Invalid resource_type. Must be one of 'block'")
elif not is_block_or_transaction_hash(resource_identifier):
raise ValueError(
"Invalid resource_identifier. Must be a hex encoded 32 byte value"
)
elif not is_block_or_transaction_hash(chain_id):
raise ValueError("Invalid chain_id. Must be a hex encoded 32 byte value")
return URI(
parse.urlunsplit(
[
"blockchain",
remove_0x_prefix(chain_id),
f"{resource_type}/{remove_0x_prefix(resource_identifier)}",
"",
"",
]
)
)
def __init__(self, address: str, privkey: str):
self._address = address
self._privkey = privkey
self._web3 = Web3(WebsocketProvider(endpoint_uri=URI(CLIENT_API_URL)))
checked_contract_address = self._web3.toChecksumAddress(CONTRACT_ADDRESS)
abi = loads(ABI)
self._contract = self._web3.eth.contract(abi=abi, address=checked_contract_address)
def __init__(self,
endpoint_uri: Optional[Union[URI, str]] = None,
request_kwargs: Any = None) -> None:
if endpoint_uri is None:
self.endpoint_uri = get_default_endpoint()
else:
self.endpoint_uri = URI(endpoint_uri)
self._request_kwargs = request_kwargs or {}
super().__init__()
def setup_testchain(eth_client: EthClient, free_port_generator: Iterator[Port],
base_datadir: str,
base_logdir: str) -> Iterator[Dict[str, Any]]:
ensure_executable(eth_client.value)
rpc_port = next(free_port_generator)
p2p_port = next(free_port_generator)
eth_rpc_endpoint = URI(f"http://127.0.0.1:{rpc_port}")
web3 = Web3(HTTPProvider(endpoint_uri=eth_rpc_endpoint))
web3.middleware_onion.inject(make_sane_poa_middleware, layer=0)
eth_nodes = [
EthNodeDescription(
private_key=TEST_PRIVKEY,
rpc_port=rpc_port,
p2p_port=p2p_port,
miner=True,
extra_config={},
blockchain_type=eth_client.value,
)
]
random_marker = remove_0x_prefix(HexStr(hex(random.getrandbits(100))))
genesis_description = GenesisDescription(
prefunded_accounts=[
AccountDescription(TEST_ACCOUNT_ADDRESS, DEFAULT_BALANCE)
],
random_marker=random_marker,
chain_id=CHAINNAME_TO_ID["smoketest"],
)
datadir = eth_node_to_datadir(privatekey_to_address(TEST_PRIVKEY),
base_datadir)
if eth_client is EthClient.GETH:
keystore = geth_keystore(datadir)
elif eth_client is EthClient.PARITY:
keystore = parity_keystore(datadir)
eth_node_runner = run_private_blockchain(
web3=web3,
eth_nodes=eth_nodes,
base_datadir=base_datadir,
log_dir=base_logdir,
verbosity="info",
genesis_description=genesis_description,
)
with eth_node_runner as node_executors:
yield dict(
eth_client=eth_client,
base_datadir=base_datadir,
eth_rpc_endpoint=eth_rpc_endpoint,
keystore=keystore,
node_executors=node_executors,
web3=web3,
)
def erc20_transfer(priv_key : str, from_addr : str, contract_addr: str, token_recipient_addr : str,
token_amount : float) \
-> TransferFuncResponse:
myweb3 = Web3(provider=HTTPProvider(
endpoint_uri=URI(ETH_FULL_NODE_RPC_URL)))
# https://web3py.readthedocs.io/en/stable/web3.eth.account.html?highlight=transaction#sign-a-contract-transaction
chksum_contract_address = to_checksum_address(contract_addr)
contract = myweb3.eth.contract(address=chksum_contract_address,
abi=EIP20_ABI)
symbol = contract.functions.symbol().call()
print(symbol)
#判断是否是 USDT
assert str(symbol) == 'USDT', 'only support USDT'
decimals = contract.functions.decimals().call()
print(decimals)
# myweb3.eth.gasPriceStrategy
# myweb3.eth.generateGasPrice()
# myweb3.eth.setGasPriceStrategy()
from_address = to_checksum_address(from_addr)
block_identifier = HexStr('pending')
nonce = myweb3.eth.getTransactionCount(from_address,
block_identifier=block_identifier)
cur_gas_price = myweb3.eth.gasPrice # 获取实时手续费
if cur_gas_price > Web3.toWei(500, 'gwei'): # 防止手续费过高
cur_gas_price = Web3.toWei(500, 'gwei')
elif cur_gas_price < Web3.toWei(50, 'gwei'): # 防止手续费过小
cur_gas_price = Web3.toWei(50, 'gwei')
# assert isinstance(contract.functions, ContractFunctions)
chksum_token_recipient = to_checksum_address(token_recipient_addr)
erc20_unsigned_tx = contract.functions.transfer(
chksum_token_recipient,
# !!! 注意 : 只支持 ERC20_USDT
myweb3.toWei(token_amount, 'mwei')) \
.buildTransaction({
'chainId': ETH_CHAIN_ID,
'gas': ERC20_GAS_LIMIT,
'gasPrice': cur_gas_price,
'nonce': nonce
})
print(erc20_unsigned_tx)
private_key = priv_key
return sign_and_sendtransaction(myweb3=myweb3,
unsigned_tranaction=erc20_unsigned_tx,
private_key=private_key)
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(URI(self.rpc_address)))
# Set gas strategy
self.w3.eth.setGasPriceStrategy(web3.gas_strategies.time_based.medium_gas_price_strategy)
def pin_local_manifest(manifest_path: Path) -> Tuple[str, str, URI]:
manifest_output = json.loads(manifest_path.read_text())
validate_manifest_against_schema(manifest_output)
package_name = manifest_output["package_name"]
package_version = manifest_output["version"]
ipfs_backend = get_ipfs_backend()
ipfs_data = ipfs_backend.pin_assets(manifest_path)
manifest_uri = URI(f"ipfs://{ipfs_data[0]['Hash']}")
return (package_name, package_version, manifest_uri)
def fetch_uri_contents(self, uri: str) -> URI:
"""
Return content-addressed URI stored at registry URI.
"""
address, chain_id, pkg_name, pkg_version, _ = parse_registry_uri(uri)
if chain_id != '1':
# todo: support all testnets
raise CannotHandleURI(
"Currently only mainnet registry uris are supported.")
self.w3.enable_unstable_package_management_api()
self.w3.pm.set_registry(address)
_, _, manifest_uri = self.w3.pm.get_release_data(pkg_name, pkg_version)
return URI(manifest_uri)
def test_connection_issues() -> None:
# 641 is a port registered with IANA for this service:
#
# repcmd 641/tcp
# repcmd 641/udp
#
# This is a comcast utility agent that is unlikely to be running. The numbe
# was chosen with. `sum(ord(c) for c in 'random')`
web3 = Web3(HTTPProvider(URI("http://localhost:641")))
with pytest.raises(RequestsConnectionError):
JSONRPCClient(web3=web3, privkey=make_privatekey_bin())
def get_package(self, package_name: str, version: str) -> Package:
"""
Returns a ``Package`` instance, generated by the ``manifest_uri`` associated with the
given package name and version, if they are published to the currently set registry.
* Parameters:
* ``name``: Must be a valid package name.
* ``version``: Must be a valid package version.
"""
validate_package_name(package_name)
validate_package_version(version)
self._validate_set_registry()
release_data = self.get_release_data(package_name, version)
return self.get_package_from_uri(URI(release_data.manifest_uri))
def __init__(self,
endpoint_uri: Optional[Union[URI, str]] = None,
request_kwargs: Optional[Any] = None,
session: Optional[Any] = None) -> None:
if endpoint_uri is None:
self.endpoint_uri = get_default_endpoint()
else:
self.endpoint_uri = URI(endpoint_uri)
self._request_kwargs = request_kwargs or {}
if session:
cache_session(self.endpoint_uri, session)
super().__init__()
def web3(
deploy_key,
eth_nodes_configuration,
private_keys,
account_genesis_eth_balance,
random_marker,
tmpdir,
chain_id,
logs_storage,
blockchain_type,
):
""" Starts a private chain with accounts funded. """
# include the deploy key in the list of funded accounts
keys_to_fund = sorted(set(private_keys + [deploy_key]))
host = "127.0.0.1"
rpc_port = eth_nodes_configuration[0].rpc_port
endpoint = f"http://{host}:{rpc_port}"
web3 = Web3(HTTPProvider(URI(endpoint)))
accounts_to_fund = [
AccountDescription(privatekey_to_address(key), account_genesis_eth_balance)
for key in keys_to_fund
]
# The private chain data is always discarded on the CI
base_datadir = str(tmpdir)
# Save the Ethereum node's log for debugging
base_logdir = os.path.join(logs_storage, blockchain_type)
genesis_description = GenesisDescription(
prefunded_accounts=accounts_to_fund, chain_id=chain_id, random_marker=random_marker
)
eth_node_runner = run_private_blockchain(
web3=web3,
eth_nodes=eth_nodes_configuration,
base_datadir=base_datadir,
log_dir=base_logdir,
verbosity="info",
genesis_description=genesis_description,
)
with eth_node_runner:
yield web3
cleanup_tasks()
def deploy_registry(config: Config, alias: str = None) -> str:
if not config.private_key:
raise AuthorizationError(
"To deploy a registry, you must provide the password for your local keyfile."
)
chain_id = config.w3.eth.chainId
chain_name = SUPPORTED_CHAIN_IDS[chain_id]
cli_logger.info(
f"Deploying a new registry to {chain_name}, this may take a minute...")
# todo: handle tx timeout error gracefully
registry_address = config.w3.pm.deploy_and_set_registry()
cli_logger.info(
f"New registry deployed to {registry_address} on {chain_name}.")
registry_uri = URI(f"erc1319://{registry_address}:{chain_id}")
add_registry(registry_uri, alias, config)
activate_registry(registry_uri, config)
return registry_address
def main() -> None:
tmpdir = tempfile.mkdtemp()
geth_nodes = []
for i in range(NUM_GETH_NODES):
is_miner = i == 0
node_key = PrivateKey(keccak(f"node:{i}".encode()))
p2p_port = Port(START_PORT + i)
rpc_port = Port(START_RPCPORT + i)
description = EthNodeDescription(
private_key=node_key,
rpc_port=rpc_port,
p2p_port=p2p_port,
miner=is_miner,
extra_config={},
)
geth_nodes.append(description)
rpc_endpoint = URI(f"http://127.0.0.1:{START_RPCPORT}")
web3 = Web3(HTTPProvider(rpc_endpoint))
random_marker = remove_0x_prefix(HexStr(hex(random.getrandbits(100))))
genesis_description = GenesisDescription(
prefunded_accounts=DEFAULT_ACCOUNTS,
random_marker=random_marker,
chain_id=ChainID(CHAINNAME_TO_ID["smoketest"]),
)
private_chain: ContextManager[
List[JSONRPCExecutor]] = run_private_blockchain(
web3=web3,
eth_nodes=geth_nodes,
base_datadir=tmpdir,
log_dir=tmpdir,
verbosity="info",
genesis_description=genesis_description,
)
with private_chain:
from IPython import embed
embed()
from scenario_player.utils.configuration.settings import (
EnvironmentConfig,
PFSSettingsConfig,
ServiceSettingsConfig,
SettingsConfig,
UDCSettingsConfig,
UDCTokenSettings,
)
dummy_env = EnvironmentConfig(
pfs_fee=FeeAmount(100),
environment_file_name="tests",
environment_type="development",
matrix_servers=[],
transfer_token=TokenAddress(bytes([1] * 20)),
pfs_with_fee=URI("http://www.example.com"),
eth_rpc_endpoints=[URI("http://www.example.com")],
ms_reward_with_margin=TokenAmount(1),
settlement_timeout_min=BlockTimeout(100),
raiden_client="raiden",
wait_short=5,
wait_long=10,
)
class TestSettingsConfig:
@pytest.mark.parametrize("key", ["timeout", "gas_price"])
def test_class_returns_expected_default_for_key(
self, key, expected_defaults, minimal_definition_dict
):
"""If supported keys are absent, sensible defaults are returned for them when accessing
def get_default_endpoint() -> URI:
return URI(
os.environ.get('WEB3_HTTP_PROVIDER_URI', 'http://localhost:8545'))
def get_default_endpoint() -> URI:
return URI(
os.environ.get("FLASHBOTS_HTTP_PROVIDER_URI",
"https://relay.flashbots.net"))
def load_provider_from_environment() -> BaseProvider:
uri_string = URI(os.environ.get('WEB3_PROVIDER_URI', ''))
if not uri_string:
return None
return load_provider_from_uri(uri_string)
