def __init__(self,
receiver: str,
sender: str,
deposit: int,
open_block_number
):
"""
A channel between two parties.
Args:
receiver (str): receiver address
sender (str): sender address
deposit (int): channel deposit
open_block_number (int): block the channel was created in
"""
assert is_address(receiver)
assert is_address(sender)
assert deposit >= 0
assert open_block_number >= 0
self.receiver = receiver
self.sender = sender # sender address
self.deposit = deposit # deposit is maximum funds that can be used
self.open_block_number = open_block_number
self.balance = 0 # how much of the deposit has been spent
self.state = ChannelState.UNDEFINED
self.last_signature = None
# if set, this is the absolute block_number the channel can be settled
self.settle_timeout = -1
self.ctime = time.time() # channel creation time
self.mtime = self.ctime
self.confirmed = False
self.unconfirmed_topups = {} # txhash to added deposit
def __init__(self,
channel_manager,
light_client_proxy=None
):
super().__init__()
assert isinstance(channel_manager, ChannelManager)
assert is_address(channel_manager.channel_manager_contract.address)
assert is_address(channel_manager.receiver)
self.contract_address = channel_manager.channel_manager_contract.address
self.receiver_address = channel_manager.receiver
self.channel_manager = channel_manager
self.light_client_proxy = light_client_proxy
def contract_address(self, v: str):
if v and is_address(v):
self._contract_address = to_checksum_address(v)
elif v:
raise ValueError("Invalid contract address")
else:
self._contract_address = v
def get(self, sender_address=None):
parser = reqparse.RequestParser()
parser.add_argument('status', help='filter channels by a status', default='open',
choices=('closed', 'opened', 'open', 'all'))
args = parser.parse_args()
channel_filter = self.get_channel_filter(args['status'])
# if sender exists, return all open blocks
if sender_address is not None and is_address(sender_address):
ret = self.get_all_channels(
condition=lambda k, v:
(k[0] == to_checksum_address(sender_address) and
channel_filter(v))
)
# if sender is not specified, return all open channels
else:
channels = self.get_all_channels(condition=lambda k, v:
channel_filter(v))
joined_channels = defaultdict(list)
for c in channels:
joined_channels[c['sender_address']].append(c['open_block'])
ret = [
{'sender_address': k,
'blocks': v
} for k, v in joined_channels.items()
]
return json.dumps(ret), 200
def transform_records(log_records: Iterable[Record], replacements: Dict[str, Any]):
def replace(value):
# Use `type(value)()` construction to preserve exact (sub-)type
if isinstance(value, tuple) and hasattr(value, '_fields'):
# namedtuples have a different signature, *sigh*
return type(value)(*[replace(inner) for inner in value])
if isinstance(value, (list, tuple)):
return type(value)(replace(inner) for inner in value)
elif isinstance(value, dict):
return {
replace(k): replace(v)
for k, v in value.items()
}
str_value = str(value).lower()
if isinstance(value, str):
keys_in_value = [key for key in replacement_keys if key in str_value]
for key in keys_in_value:
try:
repl_start = str_value.index(key)
except ValueError:
# Value no longer in string due to replacement
continue
value = f"{value[:repl_start]}{replacements[key]}{value[repl_start + len(key):]}"
str_value = value.lower()
return replacements.get(str_value, value)
replacements = {str(k).lower(): v for k, v in replacements.items()}
for k, v in copy(replacements).items():
# Special handling for `pex()`ed eth addresses
if isinstance(k, str) and k.startswith('0x') and is_address(k):
replacements[pex(to_canonical_address(k))] = v
replacement_keys = replacements.keys()
for record in log_records:
yield replace(record)
def test_encode_address(address_value, value_bit_size, data_byte_size):
if value_bit_size != 20 * 8:
with pytest.raises(ValueError):
AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
elif value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
if not is_address(address_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(address_value)
assert 'AddressEncoder' in str(exception_info.value)
return
expected_value = zpad(to_canonical_address(address_value), data_byte_size)
encoded_value = encoder(address_value)
assert encoded_value == expected_value
def sender_address(self, v: str):
if v and is_address(v):
self._sender_address = to_checksum_address(v)
elif v:
raise ValueError("Invalid sender address")
else:
self._sender_address = v
def __init__(self,
channel_manager: ChannelManager,
light_client_proxy=None,
paywall=None,
price: None = None,
) -> None:
super(Expensive, self).__init__()
assert isinstance(channel_manager, ChannelManager)
assert price is None or callable(price) or price > 0
self.contract_address = channel_manager.channel_manager_contract.address
self.receiver_address = channel_manager.receiver
assert is_address(self.contract_address)
assert is_address(self.receiver_address)
self.channel_manager = channel_manager
self.light_client_proxy = light_client_proxy
self._price = price
self.paywall = paywall
def input_address_formatter(addr):
iban = Iban(addr)
if iban.isValid() and iban.isDirect():
return add_0x_prefix(iban.address())
elif is_address(addr):
return to_normalized_address(addr)
raise ValueError("invalid address")
def is_encodable(_type, value):
try:
base, sub, arrlist = _type
except ValueError:
base, sub, arrlist = process_type(_type)
if arrlist:
if not is_list_like(value):
return False
if arrlist[-1] and len(value) != arrlist[-1][0]:
return False
sub_type = (base, sub, arrlist[:-1])
return all(is_encodable(sub_type, sub_value) for sub_value in value)
elif base == 'bool':
return is_boolean(value)
elif base == 'uint':
if not is_integer(value):
return False
exp = int(sub)
if value < 0 or value >= 2**exp:
return False
return True
elif base == 'int':
if not is_integer(value):
return False
exp = int(sub)
if value <= -1 * 2**(exp - 1) or value >= 2**(exp - 1):
return False
return True
elif base == 'string':
if not is_string(value):
return False
return True
elif base == 'bytes':
if not is_string(value):
return False
if not sub:
return True
max_length = int(sub)
if isinstance(value, str):
decodable = is_hex(value) and len(value) % 2 == 0
return decodable and len(decode_hex(value)) <= max_length
elif isinstance(value, bytes):
return len(value) <= max_length
else:
False
elif base == 'address':
if is_ens_name(value):
return True
elif is_address(value):
return True
else:
return False
else:
raise ValueError("Unsupported type")
def get(self, sender_address, opening_block):
if sender_address and is_address(sender_address):
sender_address = to_checksum_address(sender_address)
try:
key = (sender_address, opening_block)
sender_channel = self.channel_manager.channels[key]
except KeyError:
return "Sender address not found", 404
return sender_channel.to_dict(), 200
def f(target: str):
assert is_address(target)
ethereum_tester.send_transaction({
"from": FAUCET_ADDRESS,
"to": target,
"gas": 21000,
"value": 1 * int(units["ether"])
})
custom_token.functions.transfer(_to=target,
_value=10000).call_and_transact(
{"from": FAUCET_ADDRESS})
def test_get_swarm(agency, staking_providers, test_registry):
application_agent = ContractAgency.get_agent(PREApplicationAgent,
registry=test_registry)
swarm = application_agent.swarm()
swarm_addresses = list(swarm)
assert len(swarm_addresses) == len(staking_providers) + 1
# Grab a staker address from the swarm
provider_addr = swarm_addresses[0]
assert isinstance(provider_addr, str)
assert is_address(provider_addr)
def f(target: str):
assert is_address(target)
ethereum_tester.send_transaction({
'from': FAUCET_ADDRESS,
'to': target,
'gas': 21000,
'value': 1 * denoms.ether, # pylint: disable=E1101
})
custom_token.functions.transfer(
target,
10000,
).transact({'from': FAUCET_ADDRESS})
def test_create_filter_address_parameter(web3, emitter, Emitter, call_as_instance):
if call_as_instance:
event_filter = emitter.events.LogNoArguments.createFilter(fromBlock="latest")
else:
event_filter = Emitter.events.LogNoArguments.createFilter(fromBlock="latest")
if call_as_instance:
# Assert this is a single string value, and not a list of addresses
assert is_address(event_filter.filter_params['address'])
else:
# Undeployed contract shouldnt have address...
assert 'address' not in event_filter.filter_params
def validate_transaction(transaction):
# TODO: refactor this so that it's not gross.
if 'from' not in transaction:
raise ValidationError("Transactions must specify a 'from' address")
elif not is_address(transaction['from']):
raise ValidationError(
"transaction[from]: Unrecognized address format: {0}".format(
transaction['from'], ))
elif 'to' in transaction and not is_address(transaction['to']):
raise ValidationError(
"transaction[to]: Unrecognized address format: {0}".format(
transaction['to'], ))
extra_keys = set(transaction.keys()).difference(TRANSACTION_KEYS)
if extra_keys:
raise ValidationError(
"Transactions may only include the keys {0}. The following extra "
"keys were found: {1}".format(
",".join(sorted(TRANSACTION_KEYS)),
",".join(sorted(extra_keys)),
))
def main():
reader = csv.reader(open("snapshot/01-delphi.csv"))
balances = {
to_checksum_address(address): int(balance)
for address, balance in reader if is_address(address)
}
print("recipients:", len(balances))
print("total supply:", sum(balances.values()) / 1e18)
distribution = prepare_merkle_tree(balances)
print("merkle root:", distribution["merkleRoot"])
with open("snapshot/02-merkle.json", "wt") as f:
json.dump(distribution, f, indent=2)
def f(initial_amount: int, decimals: int, token_name: str,
token_symbol: str) -> Contract:
token_contract = deploy_token_contract(initial_amount, decimals,
token_name, token_symbol)
txid = token_network_registry_contract.functions.createERC20TokenNetwork(
token_contract.address, channel_participant_deposit_limit,
token_network_deposit_limit).call_and_transact(
{"from": CONTRACT_DEPLOYER_ADDRESS})
(tx_receipt, _) = check_successful_tx(web3, txid)
assert len(tx_receipt["logs"]) == 1
event_abi = contracts_manager.get_event_abi(
CONTRACT_TOKEN_NETWORK_REGISTRY, EVENT_TOKEN_NETWORK_CREATED)
decoded_event = get_event_data(event_abi, tx_receipt["logs"][0])
assert decoded_event is not None
assert is_address(decoded_event["args"]["token_address"])
assert is_address(decoded_event["args"]["token_network_address"])
token_network_address = decoded_event["args"]["token_network_address"]
token_network_abi = contracts_manager.get_contract_abi(
CONTRACT_TOKEN_NETWORK)
return web3.eth.contract(abi=token_network_abi,
address=token_network_address)
def f(target: str):
assert is_address(target)
ethereum_tester.send_transaction({
'from': faucet_address,
'to': target,
'gas': 21000,
'value': 1 * denoms.ether,
})
custom_token.functions.transfer(
target,
10000,
).transact({'from': faucet_address})
def check_signatures(self, monitor_request: MonitorRequest,
channel: sqlite3.Row):
"""Check if signatures set in the message are correct"""
balance_proof = monitor_request.balance_proof
participants = [channel['participant1'], channel['participant2']]
try:
return (is_address(monitor_request.reward_proof_signer)
and balance_proof.signer in participants
and monitor_request.non_closing_signer in participants and
balance_proof.signer != monitor_request.non_closing_signer)
except InvalidSignature:
return False
def assert_is_address(value: Any, name: str) -> None:
"""Assert that `value` is a valid Ethereum address.
If `value` isn't a hex string, raise a TypeError. If it isn't a valid
Ethereum address, raise a ValueError.
"""
assert_is_hex_string(value, name)
if not is_address(value):
raise ValueError(
f"Expected variable '{name}' to be a valid Ethereum"
+ " address, but it's not."
)
def validate_abi_value(abi_type, value):
"""
Helper function for validating a value against the expected abi_type
Note: abi_type 'bytes' must either be python3 'bytes' object or ''
"""
if is_array_type(abi_type) and is_list_like(value):
# validate length
specified_length = length_of_array_type(abi_type)
if specified_length is not None:
if specified_length < 1:
raise TypeError(
"Invalid abi-type: {abi_type}. Length of fixed sized arrays"
"must be greater than 0."
.format(abi_type=abi_type)
)
if specified_length != len(value):
raise TypeError(
"The following array length does not the length specified"
"by the abi-type, {abi_type}: {value}"
.format(abi_type=abi_type, value=value)
)
# validate sub_types
sub_type = sub_type_of_array_type(abi_type)
for v in value:
validate_abi_value(sub_type, v)
return
elif is_bool_type(abi_type) and is_boolean(value):
return
elif is_uint_type(abi_type) and is_integer(value) and value >= 0:
return
elif is_int_type(abi_type) and is_integer(value):
return
elif is_address_type(abi_type) and is_address(value):
return
elif is_bytes_type(abi_type):
if sys.version_info.major >= 3 and is_bytes(value):
return
elif is_string(value):
if is_0x_prefixed(value):
return
else:
raise TypeError(
"ABI values of abi-type 'bytes' must be either"
"a python3 'bytes' object or an '0x' prefixed string."
)
elif is_string_type(abi_type) and is_string(value):
return
raise TypeError(
"The following abi value is not a '{abi_type}'': {value}"
.format(abi_type=abi_type, value=value)
)
def standard_token_network_contract(web3, contracts_manager,
wait_for_transaction,
token_network_registry_contract,
standard_token_contract,
contract_deployer_address):
"""Return instance of a deployed TokenNetwork for HumanStandardToken."""
txid = token_network_registry_contract.functions.createERC20TokenNetwork(
standard_token_contract.address).transact(
{'from': contract_deployer_address})
tx_receipt = wait_for_transaction(txid)
assert len(tx_receipt['logs']) == 1
event_abi = contracts_manager.get_event_abi('TokenNetworksRegistry',
'TokenNetworkCreated')
decoded_event = get_event_data(event_abi, tx_receipt['logs'][0])
assert decoded_event is not None
assert is_address(decoded_event['args']['token_address'])
assert is_address(decoded_event['args']['token_network_address'])
token_network_address = decoded_event['args']['token_network_address']
token_network_abi = contracts_manager.get_contract_abi('TokenNetwork')
return web3.eth.contract(abi=token_network_abi,
address=token_network_address)
def test_create_filter_address_parameter(emitter, Emitter, call_as_instance):
if call_as_instance:
event_filter = emitter.events.LogNoArguments.createFilter(fromBlock="latest")
else:
event_filter = Emitter.events.LogNoArguments.createFilter(fromBlock="latest")
if call_as_instance:
# Assert this is a single string value, and not a list of addresses
assert is_address(event_filter.filter_params['address'])
else:
# Undeployed contract shouldnt have address...
assert 'address' not in event_filter.filter_params
def call(self, transaction, block_identifier=None):
# TODO: move to middleware
if 'from' not in transaction and is_address(self.defaultAccount):
transaction = assoc(transaction, 'from', self.defaultAccount)
# TODO: move to middleware
if block_identifier is None:
block_identifier = self.defaultBlock
return self.web3.manager.request_blocking(
"eth_call",
[transaction, block_identifier],
)
def check_if_address_match(address, addresses):
if addresses is None:
return True
if is_tuple(addresses):
return any(
is_same_address(address, item)
for item
in addresses
)
elif is_address(addresses):
return is_same_address(addresses, address)
else:
raise ValueError("Unrecognized address format: {0}".format(addresses))
def __init__(self, receiver: str, sender: str, deposit: int,
open_block_number):
"""
A channel between two parties.
Args:
receiver (str): receiver address
sender (str): sender address
deposit (int): channel deposit
open_block_number (int): block the channel was created in
"""
assert is_address(receiver)
assert is_address(sender)
assert deposit >= 0
assert open_block_number >= 0
self.receiver = receiver
self.sender = sender # sender address
self.deposit = deposit # deposit is maximum funds that can be used
self.open_block_number = open_block_number
self.balance = 0 # how much of the deposit has been spent
self.state = ChannelState.UNDEFINED
self.last_signature = None
# if set, this is the absolute block_number the channel can be settled
self.settle_timeout = -1
self.monitor_timeout = -1
self.ctime = time.time() # channel creation time
self.mtime = self.ctime
self.confirmed = False
self.rng = random
self.rng.seed(123456789)
self.nonce = None
self.last_nonce = None
self.next_nonce = self.rng.getrandbits(256)
self.round_number = 0
self.unconfirmed_topups = {} # txhash to added deposit
self.monitor_receipt = None
def get_money(self):
get_testnet_eth(self.clientAddress, self.web3)
print(self.web3.eth.getBalance(self.clientAddress))
Query_id, self.Query_interface = self.compiled_sol.popitem()
Delegator_id, self.Delegator_interface = self.compiled_sol.popitem()
if self.Delegator_address:
assert(is_address(self.Delegator_address))
else:
# self.Query_address = deploy_Query(self.web3, self.Query_interface, self.TEST_ACCOUNT, addr_lst)
self.Delegator_address = deploy_Master(self.web3, self.Delegator_interface, self.clientAddress)
def __init__(self,
token_network_address: Address,
target_address: Address,
value: int,
chain_id: int,
nonce: int,
paths_and_fees: list = None,
signature: str = None) -> None:
super().__init__()
assert is_address(token_network_address)
assert is_address(target_address)
assert 0 <= value <= UINT256_MAX
assert 0 <= nonce <= UINT256_MAX
self._type = 'PathsReply'
self.token_network_address = token_network_address
self.target_address = target_address
self.value = value
self.chain_id = chain_id
self.nonce = nonce
self.paths_and_fees = paths_and_fees
self.signature = signature
def __init__(
self,
balance_proof: BalanceProof,
non_closing_signature: str = None,
reward_sender_address: Address = None, # address
reward_proof_signature: bytes = None, # bytes
reward_amount: int = None, # uint192
monitor_address: Address = None
) -> None:
assert non_closing_signature is None or len(decode_hex(non_closing_signature)) == 65
assert reward_amount is None or (reward_amount >= 0) and (reward_amount <= UINT192_MAX)
# todo: validate reward proof signature
assert is_address(reward_sender_address)
assert is_address(monitor_address)
assert isinstance(balance_proof, BalanceProof)
self._balance_proof = balance_proof
self.non_closing_signature = non_closing_signature
self.reward_sender_address = to_checksum_address(reward_sender_address)
self.reward_proof_signature = reward_proof_signature
self.reward_amount = reward_amount
self.monitor_address = monitor_address
def f(initial_amount: int, decimals: int, token_name: str,
token_symbol: str):
token_contract = deploy_token_contract(initial_amount, decimals,
token_name, token_symbol)
txid = token_network_registry_contract.functions.createERC20TokenNetwork(
token_contract.address, ).transact(
{'from': contract_deployer_address})
tx_receipt = wait_for_transaction(txid)
assert len(tx_receipt['logs']) == 1
event_abi = contracts_manager.get_event_abi(
CONTRACT_TOKEN_NETWORK_REGISTRY,
EVENT_TOKEN_NETWORK_CREATED,
)
decoded_event = get_event_data(event_abi, tx_receipt['logs'][0])
assert decoded_event is not None
assert is_address(decoded_event['args']['token_address'])
assert is_address(decoded_event['args']['token_network_address'])
token_network_address = decoded_event['args']['token_network_address']
token_network_abi = contracts_manager.get_contract_abi(
CONTRACT_TOKEN_NETWORK)
return web3.eth.contract(abi=token_network_abi,
address=token_network_address)
def check_headers(self, headers):
"""Check if headers sent by the client are valid"""
price = headers.get(header.PRICE, None)
contract_address = headers.get(header.CONTRACT_ADDRESS, None)
receiver_address = headers.get(header.RECEIVER_ADDRESS, None)
sender_address = headers.get(header.SENDER_ADDRESS, None)
payment = headers.get(header.PAYMENT, None)
balance_signature = headers.get(header.BALANCE_SIGNATURE, None)
open_block = headers.get(header.OPEN_BLOCK, None)
balance = headers.get(header.BALANCE, None)
if price:
price = int(price)
if open_block:
open_block = int(open_block)
if balance:
balance = int(balance)
if price and price < 0:
raise ValueError("Price must be >= 0")
if contract_address and not is_address(contract_address):
raise ValueError("Invalid contract address")
if receiver_address and not is_address(receiver_address):
raise ValueError("Invalid receiver address")
if sender_address and not is_address(sender_address):
raise ValueError("Invalid sender address")
if payment and not isinstance(payment, int):
raise ValueError("Payment must be an integer")
if open_block and open_block < 0:
raise ValueError("Open block must be >= 0")
if balance and balance < 0:
raise ValueError("Balance must be >= 0")
self.price = price
self.contract_address = contract_address
self.receiver_address = receiver_address
self.payment = payment
self.balance_signature = balance_signature
self.sender_address = sender_address
self.open_block_number = open_block
self.balance = balance
def register():
"""Handle new recipient registration via POST request."""
new_address = (request.form.get('address')
or request.get_json().get('address'))
if not new_address:
return Response(response="no address was supplied", status=411)
if not eth_utils.is_address(new_address):
return Response(
response=
"an invalid ethereum address was supplied. please ensure the address is a proper checksum.",
status=400)
else:
new_address = eth_utils.to_checksum_address(new_address)
if new_address in self.reserved_addresses:
return Response(
response=
"sorry, that address is reserved and cannot receive funds.",
status=403)
try:
with ThreadedSession(self.db_engine) as session:
existing = Recipient.query.filter_by(
address=new_address).all()
if len(existing) > self.MAX_INDIVIDUAL_REGISTRATIONS:
# Address already exists; Abort
self.log.debug(
f"{new_address} is already enrolled {self.MAX_INDIVIDUAL_REGISTRATIONS} times."
)
return Response(
response=
f"{new_address} requested too many times - Please use another address.",
status=409)
# Create the record
recipient = Recipient(address=new_address,
joined=datetime.now())
session.add(recipient)
session.commit()
except Exception as e:
# Pass along exceptions to the logger
self.log.critical(str(e))
raise
else:
return Response(status=200) # TODO
def __init__(self,
iden,
provider,
clientAddress=None,
delegatorAddress=None):
self.web3 = provider
self.api = ipfsapi.connect('127.0.0.1', 5001)
self.PASSPHRASE = 'panda'
self.TEST_ACCOUNT = '0xb4734dCc08241B46C0D7d22D163d065e8581503e'
self.TEST_KEY = '146396092a127e4cf6ff3872be35d49228c7dc297cf34da5a0808f29cf307da1'
contract_source_path_A = "blockchain/Delegator.sol"
contract_source_path_B = "blockchain/Query.sol"
contract_source_path_C = "blockchain/DAgoraToken.sol"
self.compiled_sol = compile_files([
contract_source_path_A, contract_source_path_B,
contract_source_path_C
])
self.iden = iden
if clientAddress:
assert (is_address(clientAddress))
self.clientAddress = clientAddress
else:
#TODO: Initialize client 'container' address if it wasn't assigned one
self.clientAddress = self.web3.personal.newAccount(self.PASSPHRASE)
assert (is_address(self.clientAddress))
self.web3.personal.unlockAccount(self.clientAddress, self.PASSPHRASE)
print("Client Address:", self.clientAddress)
self.Delegator_address = delegatorAddress
self.DAgoraToken_address = self.web3.toChecksumAddress(
'0x1698215a2bea4935ba9e0f5b48347e83450a6774')
def main(db_file, token_network_address, partner_address, names_translator):
translator: Optional[Translator]
if names_translator:
translator = Translator(json.load(names_translator))
lookup = {v: k for k, v in translator.items()}
token_network_address = lookup.get(token_network_address,
token_network_address)
partner_address = lookup.get(partner_address, partner_address)
else:
translator = None
assert is_address(
token_network_address), "token_network_address must be provided"
assert is_address(partner_address), "partner_address must be provided"
with closing(SerializedSQLiteStorage(db_file,
JSONSerializer())) as storage:
replay_wal(
storage=storage,
token_network_address=to_canonical_address(token_network_address),
partner_address=to_canonical_address(partner_address),
translator=translator,
)
def _validate_args(args):
required_args = ['from', 'to', 'value', 'max_paths']
if not all(args[arg] is not None for arg in required_args):
return {
'errors': 'Required parameters: {}'.format(required_args)
}, 400
address_error = 'Invalid {} address: {}'
if not is_address(args['from']):
return {
'errors': address_error.format('initiator', args['from'])
}, 400
if not is_address(args['to']):
return {'errors': address_error.format('target', args['to'])}, 400
address_error = '{} address not checksummed: {}'
if not is_checksum_address(args['from']):
return {
'errors': address_error.format('Initiator', args['from'])
}, 400
if not is_checksum_address(args['to']):
return {'errors': address_error.format('Target', args['to'])}, 400
if args.value < 0:
return {
'errors':
'Payment value must be non-negative: {}'.format(args.value)
}, 400
if args.max_paths <= 0:
return {
'errors':
'Number of paths must be positive: {}'.format(args.max_paths)
}, 400
return None
def get_address_type(address: str) -> str:
"""
Function checks whether the input address is a Bitcoin (in mainnet) or an
Ethereum address.
:param address:
:return: btc, eth or ""
"""
try:
if eth_utils.is_address(address):
return "eth"
if is_valid_bech32_address(address) or cryptoaddress.BitcoinAddress(
address):
return "btc"
except ValueError:
return ""
def withdraw(
self,
amount: int,
destination: str,
currency: str) -> str:
if not self._config.WITHDRAWALS_ENABLED:
raise Exception("Withdrawals are disabled")
if not is_address(destination):
raise ValueError("{} is not valid ETH address".format(destination))
if currency == 'ETH':
if amount > self.get_available_eth():
raise exceptions.NotEnoughFunds(
amount,
self.get_available_eth(),
currency,
)
log.info(
"Withdrawing %f ETH to %s",
amount / denoms.ether,
destination,
)
return self._sci.transfer_eth(destination, amount)
if currency == 'GNT':
if amount > self.get_available_gnt():
raise exceptions.NotEnoughFunds(
amount,
self.get_available_gnt(),
currency,
)
log.info(
"Withdrawing %f GNT to %s",
amount / denoms.ether,
destination,
)
tx_hash = self._sci.convert_gntb_to_gnt(destination, amount)
def on_receipt(receipt) -> None:
self._gntb_withdrawn -= amount
if not receipt.status:
log.error("Failed GNTB withdrawal: %r", receipt)
self._sci.on_transaction_confirmed(tx_hash, on_receipt)
self._gntb_withdrawn += amount
return tx_hash
raise ValueError('Unknown currency {}'.format(currency))
def _rpc_request_to_filter_params(raw_params: RawFilterParams) -> FilterParams:
address: Union[None, Address, Tuple[Address, ...]]
if "address" not in raw_params:
address = None
elif raw_params["address"] is None:
address = None
elif is_address(raw_params["address"]):
address = to_canonical_address(raw_params["address"]) # type: ignore
elif isinstance(raw_params["address"], list):
address = tuple(
to_canonical_address(sub_address)
for sub_address in raw_params["address"])
else:
raise TypeError(f"Unsupported address: {raw_params['address']!r}")
topics: FilterTopics
if "topics" not in raw_params:
topics = ()
elif raw_params["topics"] is None:
topics = ()
elif isinstance(raw_params["topics"], Sequence):
topics = _normalize_topics(raw_params["topics"]) # type: ignore
else:
raise TypeError(f"Unsupported topics: {raw_params['topics']!r}")
from_block: Optional[BlockNumber]
if "fromBlock" not in raw_params:
from_block = None
elif raw_params["fromBlock"] is None:
from_block = None
elif isinstance(raw_params["fromBlock"], str):
from_block = BlockNumber(to_int(hexstr=raw_params["fromBlock"]))
else:
raise TypeError(f"Unsupported fromBlock: {raw_params['fromBlock']!r}")
to_block: Optional[BlockNumber]
if "toBlock" not in raw_params:
to_block = None
elif raw_params["toBlock"] is None:
to_block = None
elif isinstance(raw_params["toBlock"], str):
to_block = BlockNumber(to_int(hexstr=raw_params["toBlock"]))
else:
raise TypeError(f"Unsupported toBlock: {raw_params['toBlock']!r}")
return FilterParams(from_block, to_block, address, topics)
def is_encodable(_type, value):
try:
base, sub, arrlist = _type
except ValueError:
base, sub, arrlist = process_type(_type)
if arrlist:
if not is_list_like(value):
return False
if arrlist[-1] and len(value) != arrlist[-1][0]:
return False
sub_type = (base, sub, arrlist[:-1])
return all(is_encodable(sub_type, sub_value) for sub_value in value)
elif base == 'bool':
return is_boolean(value)
elif base == 'uint':
if not is_integer(value):
return False
exp = int(sub)
if value < 0 or value >= 2**exp:
return False
return True
elif base == 'int':
if not is_integer(value):
return False
exp = int(sub)
if value <= -1 * 2**(exp - 1) or value >= 2**(exp - 1):
return False
return True
elif base == 'string':
if not is_string(value):
return False
return True
elif base == 'bytes':
if not is_string(value):
return False
if not sub:
return True
max_length = int(sub)
return len(value) <= max_length
elif base == 'address':
if not is_address(value):
return False
return True
else:
raise ValueError("Unsupported type")
def delete(self, sender_address):
parser = reqparse.RequestParser()
parser.add_argument('open_block', type=int, help='block the channel was opened')
parser.add_argument('signature', help='last balance proof signature')
args = parser.parse_args()
if args.signature is None:
return "Bad signature format", 400
if args.block is None:
return "No opening block specified", 400
if sender_address and is_address(sender_address):
sender_address = to_checksum_address(sender_address)
channel = self.channel_manager.channels[sender_address, args.block]
if channel.last_signature != args.signature:
return "Invalid or outdated balance signature", 400
ret = sign_close(self.channel_manager.private_key, args.signature)
return ret, 200
def add_header_constant_call(vmc_handler, collation_header):
args = (getattr(collation_header, field[0])
for field in collation_header.fields)
# transform address from canonical to checksum_address, to comply with web3.py
args_with_checksum_address = (to_checksum_address(item)
if is_address(item) else item
for item in args)
# Here we use *args_with_checksum_address as the argument, to ensure the order of arguments
# is the same as the one of parameters of `VMC.add_header`
result = vmc_handler.call(
vmc_handler.mk_contract_tx_detail(
sender_address=vmc_handler.get_default_sender_address(),
gas=vmc_handler.config['DEFAULT_GAS'],
gas_price=1,
)).add_header(*args_with_checksum_address)
return result
def test_add_account_no_password(self, eth_tester):
account = eth_tester.add_account(PK_A)
assert is_address(account)
assert any((is_same_address(account, value)
for value in eth_tester.get_accounts()))
# Fund it
eth_tester.send_transaction({
'from': eth_tester.get_accounts()[0],
'to': account,
'value': 1 * denoms.ether,
'gas': 21000,
'gas_price': 1,
})
self._send_and_check_transaction(eth_tester, account)
def delete(self, sender_address, opening_block):
parser = reqparse.RequestParser()
parser.add_argument('balance', type=int, help='last balance proof balance')
args = parser.parse_args()
if args.balance is None:
return "Bad balance format", 400
if sender_address and is_address(sender_address):
sender_address = to_checksum_address(sender_address)
try:
close_signature = self.channel_manager.sign_close(
sender_address,
opening_block,
args.balance)
except (NoOpenChannel, InvalidBalanceProof) as e:
return str(e), 400
except KeyError:
return "Channel not found", 404
ret = {'close_signature': encode_hex(close_signature)}
return ret, 200
def __init__(self,
*args,
**kwargs):
"""Create a new smart contract proxy object.
:param address: Contract address as 0x hex string
"""
code = kwargs.pop('code', empty)
code_runtime = kwargs.pop('code_runtime', empty)
source = kwargs.pop('source', empty)
abi = kwargs.pop('abi', empty)
address = kwargs.pop('address', empty)
if self.web3 is None:
raise AttributeError(
'The `Contract` class has not been initialized. Please use the '
'`web3.contract` interface to create your contract class.'
)
arg_0, arg_1, arg_2, arg_3, arg_4 = tuple(itertools.chain(
args,
itertools.repeat(empty, 5),
))[:5]
if is_list_like(arg_0):
if abi:
raise TypeError("The 'abi' argument was found twice")
abi = arg_0
elif is_address(arg_0):
if address:
raise TypeError("The 'address' argument was found twice")
address = arg_0
if is_address(arg_1):
if address:
raise TypeError("The 'address' argument was found twice")
address = arg_1
if arg_2 is not empty:
if code:
raise TypeError("The 'code' argument was found twice")
code = arg_2
if arg_3 is not empty:
if code_runtime:
raise TypeError("The 'code_runtime' argument was found twice")
code_runtime = arg_3
if arg_4 is not empty:
if source:
raise TypeError("The 'source' argument was found twice")
source = arg_4
if any((abi, code, code_runtime, source)):
warnings.warn(DeprecationWarning(
"The arguments abi, code, code_runtime, and source have been "
"deprecated and will be removed from the Contract class "
"constructor in future releases. Update your code to use the "
"Contract.factory method."
))
if abi is not empty:
self.abi = abi
if code is not empty:
self.bytecode = code
if code_runtime is not empty:
self.bytecode_runtime = code_runtime
if source is not empty:
self._source = source
if address is not empty:
self.address = address
else:
warnings.warn(DeprecationWarning(
"The address argument is now required for contract class "
"instantiation. Please update your code to reflect this change"
))
def delete(self, sender_address, opening_block):
if sender_address and is_address(sender_address):
sender_address = to_checksum_address(sender_address)
self.channel_manager.force_close_channel(sender_address, opening_block)
return "force closed (%s, %d)" % (sender_address, opening_block), 200
def validate_value(cls, value):
if not is_address(value):
cls.invalidate_value(value)
def main(**kwargs):
rpc_provider = kwargs['rpc_provider']
json_file = kwargs['json']
owner = kwargs['owner']
supply = kwargs['supply']
token_name = kwargs['token_name']
token_decimals = kwargs['token_decimals']
token_symbol = kwargs['token_symbol']
token_address = kwargs['token_address']
supply *= 10**(token_decimals)
txn_wait = kwargs['wait']
gas_price = kwargs['gas_price']
print('''Make sure chain is running, you can connect to it and it is synced,
or you'll get timeout''')
web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60}))
print('Web3 provider is', web3.providers[0])
owner = owner or web3.eth.accounts[0]
assert owner and is_address(owner), 'Invalid owner provided.'
owner = to_checksum_address(owner)
print('Owner is', owner)
assert web3.eth.getBalance(owner) > 0, 'Account with insuficient funds.'
transaction = {'from': owner}
if gas_price == 0:
transaction['gasPrice'] = gas_price
with open(json_file) as json_data:
contracts_compiled_data = json.load(json_data)
if not token_address:
token_address = deploy_contract(
web3,
contracts_compiled_data,
'CustomToken',
transaction,
txn_wait,
[supply, token_decimals, token_name, token_symbol]
)
assert token_address and is_address(token_address)
token_address = to_checksum_address(token_address)
secret_registry_address = deploy_contract(
web3,
contracts_compiled_data,
'SecretRegistry',
transaction,
txn_wait
)
token_network_registry_address = deploy_contract(
web3,
contracts_compiled_data,
'TokenNetworksRegistry',
transaction,
txn_wait,
[secret_registry_address, int(web3.version.network)]
)
token_network_registry = instantiate_contract(
web3,
contracts_compiled_data,
'TokenNetworksRegistry',
token_network_registry_address
)
txhash = token_network_registry.transact(transaction).createERC20TokenNetwork(
token_address
)
receipt = check_succesful_tx(web3, txhash, txn_wait)
print('TokenNetwork address: {0}. Gas used: {1}'.format(
token_network_registry.call().token_to_token_networks(token_address),
receipt['gasUsed'])
)
def test_eth_accounts(web3):
accounts = web3.eth.accounts
assert len(accounts) >= 1
assert all(is_address(addr) for addr in accounts)
