def __init__(self,
web3,
contract_proxy,
token_contract,
private_key: str,
state_filename=None,
n_confirmations=1) -> None:
gevent.Greenlet.__init__(self)
self.blockchain = Blockchain(web3,
contract_proxy,
self,
n_confirmations=n_confirmations)
self.receiver = privkey_to_addr(private_key)
self.private_key = private_key
self.contract_proxy = contract_proxy
self.token_contract = token_contract
self.n_confirmations = n_confirmations
self.log = logging.getLogger('channel_manager')
network_id = web3.version.network
assert privkey_to_addr(self.private_key) == self.receiver.lower()
channel_contract_address = contract_proxy.contract.address
if state_filename is not None and os.path.isfile(state_filename):
self.state = ChannelManagerState.load(state_filename)
else:
self.state = ChannelManagerState(channel_contract_address,
self.receiver,
network_id,
filename=state_filename)
assert self.state is not None
if state_filename is not None:
self.lock_state = filelock.FileLock(state_filename)
try:
self.lock_state.acquire(timeout=0)
except filelock.Timeout:
raise StateFileLocked(
"state file %s is locked by another process" %
state_filename)
if network_id != self.state.network_id:
raise NetworkIdMismatch(
"Network id mismatch: state=%d, backend=%d" %
(self.state.network_id, network_id))
if not is_same_address(self.receiver, self.state.receiver):
raise StateReceiverAddrMismatch(
'%s != %s' % (self.receiver.lower(), self.state.receiver))
if not is_same_address(self.state.contract_address,
channel_contract_address):
raise StateContractAddrMismatch(
'%s != %s' % (channel_contract_address.lower(),
self.state.contract_address.lower()))
self.log.debug(
'setting up channel manager, receiver=%s channel_contract=%s' %
(self.receiver, channel_contract_address))
def sweep_account(privkey, make_token_proxy, web3, wait_for_transaction):
address = privkey_to_addr(privkey)
token_proxy = make_token_proxy(privkey)
token_balance = token_proxy.contract.call().balanceOf(address)
if token_balance > 0:
tx = token_proxy.create_signed_transaction('transfer',
[decode_hex(FAUCET_ADDRESS), token_balance])
try:
tx_hash = web3.eth.sendRawTransaction(tx)
except ValueError as e:
if e.args[0]['message'].startswith('Insufficient funds.'):
pass
else:
raise
else:
wait_for_transaction(tx_hash)
balance = web3.eth.getBalance(address, 'pending')
if balance < 21000 * GAS_PRICE:
return
tx = Transaction(
nonce=web3.eth.getTransactionCount(address, 'pending'),
gasprice=GAS_PRICE,
startgas=21000,
to=FAUCET_ADDRESS,
value=balance - 21000 * GAS_PRICE,
data=b'',
v=0, r=0, s=0
)
sign_transaction(tx, privkey, web3.version.network)
tx_hash = web3.eth.sendRawTransaction(encode_hex(rlp.encode(tx)))
wait_for_transaction(tx_hash)
assert web3.eth.getBalance(address, 'pending') == 0, ('sweeping of account {} '
'(private key {}) failed')
def __init__(self,
web3: Web3,
privkey,
contract_address,
abi,
gas_price,
gas_limit,
tester_mode=False) -> None:
self.web3 = web3
self.privkey = privkey
self.caller_address = privkey_to_addr(privkey)
if self.web3.eth.defaultAccount == web3_empty:
self.web3.eth.defaultAccount = self.caller_address
self.address = contract_address
self.abi = abi
self.contract = self.web3.eth.contract(abi=self.abi,
address=contract_address)
self.gas_price = gas_price
self.gas_limit = gas_limit
self.tester_mode = tester_mode
bytecode = web3.eth.getCode(contract_address)
if bytecode == '0x':
raise ValueError(
'No contract deployed at address {}'.format(contract_address))
def close_all_channels_cooperatively(
client: Client, privkey_receiver: str, contract_address: str, balance: int=None
):
receiver_addr = privkey_to_addr(privkey_receiver)
client.sync_channels()
channels = [c for c in client.channels
if c.state != Channel.State.closed and c.receiver == receiver_addr]
for channel in channels:
close_channel_cooperatively(channel, privkey_receiver, contract_address, balance)
def main(
ctx,
channel_manager_address,
ssl_key,
ssl_cert,
state_file,
private_key,
paywall_info,
rpc_provider,
):
if private_key is None:
log.fatal("No private key provided")
sys.exit(1)
if utils.check_permission_safety(private_key) is False:
log.fatal("Private key file %s must be readable only by its owner." %
(private_key))
sys.exit(1)
with open(private_key) as keyfile:
private_key = keyfile.readline()[:-1]
if not is_hex(private_key) or len(decode_hex(private_key)) != 32:
log.fatal("Private key must be specified as 32 hex encoded bytes")
sys.exit(1)
receiver_address = privkey_to_addr(private_key)
channel_manager_address = channel_manager_address or config.CHANNEL_MANAGER_ADDRESS
if not state_file:
state_file_name = "%s_%s.json" % (channel_manager_address[:10],
receiver_address[:10])
app_dir = click.get_app_dir('microraiden')
if not os.path.exists(app_dir):
os.makedirs(app_dir)
state_file = os.path.join(app_dir, state_file_name)
config.paywall_html_dir = paywall_info
web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60}))
try:
app = make_paywalled_proxy(private_key, state_file, web3=web3)
except StateFileLocked as ex:
log.fatal('Another uRaiden process is already running (%s)!' % str(ex))
sys.exit(1)
except InsecureStateFile as ex:
msg = (
'The permission bits of the state file (%s) are set incorrectly (others can '
'read or write) or you are not the owner. For reasons of security, '
'startup is aborted.' % state_file)
log.fatal(msg)
sys.exit(1)
except NetworkIdMismatch as ex:
log.fatal(str(ex))
sys.exit(1)
except requests.exceptions.ConnectionError as ex:
log.fatal("Ethereum node refused connection: %s" % str(ex))
sys.exit(1)
ctx.obj = app
def test_channel_opening(client, web3, make_account,
make_channel_manager_proxy, token_contract,
mine_sync_event, wait_for_blocks, use_tester):
receiver1_privkey = make_account(RECEIVER_ETH_ALLOWANCE,
RECEIVER_TOKEN_ALLOWANCE)
receiver2_privkey = make_account(RECEIVER_ETH_ALLOWANCE,
RECEIVER_TOKEN_ALLOWANCE)
receiver_address = privkey_to_addr(receiver1_privkey)
channel_manager1 = ChannelManager(
web3,
make_channel_manager_proxy(receiver1_privkey),
token_contract,
receiver1_privkey,
n_confirmations=5)
start_channel_manager(channel_manager1, use_tester, mine_sync_event)
channel_manager2 = ChannelManager(
web3,
make_channel_manager_proxy(receiver2_privkey),
token_contract,
receiver2_privkey,
n_confirmations=5)
start_channel_manager(channel_manager2, use_tester, mine_sync_event)
channel_manager1.wait_sync()
channel_manager2.wait_sync()
blockchain = channel_manager1.blockchain
channel = client.open_channel(receiver_address, 10)
# should be in unconfirmed channels
wait_for_blocks(1)
gevent.sleep(blockchain.poll_interval)
assert (channel.sender, channel.block) not in channel_manager1.channels
assert (channel.sender,
channel.block) in channel_manager1.unconfirmed_channels
channel_rec = channel_manager1.unconfirmed_channels[channel.sender,
channel.block]
assert is_same_address(channel_rec.receiver, receiver_address)
assert is_same_address(channel_rec.sender, channel.sender)
assert channel_rec.mtime == channel_rec.ctime
# should be confirmed after n blocks
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
assert (channel.sender, channel.block) in channel_manager1.channels
channel_rec = channel_manager1.channels[channel.sender, channel.block]
assert is_same_address(channel_rec.receiver, receiver_address)
assert is_same_address(channel_rec.sender, channel.sender)
assert channel_rec.balance == 0
assert channel_rec.last_signature is None
assert channel_rec.is_closed is False
assert channel_rec.settle_timeout == -1
# should not appear in other channel manager
assert (channel.sender, channel.block) not in channel_manager2.channels
assert (channel.sender,
channel.block) not in channel_manager2.unconfirmed_channels
def start_proxy(receiver_privkey: str) -> PaywalledProxy:
state_file_name = '{}_{}.json'.format(CHANNEL_MANAGER_ADDRESS,
privkey_to_addr(receiver_privkey))
app_dir = click.get_app_dir('microraiden')
if not os.path.exists(app_dir):
os.makedirs(app_dir)
app = make_paywalled_proxy(receiver_privkey,
os.path.join(app_dir, state_file_name))
app.run()
return app
def __init__(self, web3: Web3, privkey, contract_address, abi, gas_price, gas_limit,
tester_mode=False) -> None:
self.web3 = web3
self.privkey = privkey
self.caller_address = privkey_to_addr(privkey)
if self.web3.eth.defaultAccount == web3_empty:
self.web3.eth.defaultAccount = self.caller_address
self.address = contract_address
self.abi = abi
self.contract = self.web3.eth.contract(abi=self.abi, address=contract_address)
self.gas_price = gas_price
self.gas_limit = gas_limit
self.tester_mode = tester_mode
def main(
ctx,
channel_manager_address,
ssl_key,
ssl_cert,
state_file,
private_key,
private_key_password_file,
paywall_info,
rpc_provider,
):
private_key = utils.get_private_key(private_key, private_key_password_file)
if private_key is None:
sys.exit(1)
receiver_address = privkey_to_addr(private_key)
channel_manager_address = channel_manager_address or config.CHANNEL_MANAGER_ADDRESS
if not state_file:
state_file_name = "%s_%s.db" % (channel_manager_address[:10],
receiver_address[:10])
app_dir = click.get_app_dir('microraiden')
if not os.path.exists(app_dir):
os.makedirs(app_dir)
state_file = os.path.join(app_dir, state_file_name)
config.paywall_html_dir = paywall_info
web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60}))
try:
app = make_paywalled_proxy(private_key,
state_file,
contract_address=channel_manager_address,
web3=web3)
except StateFileLocked as ex:
log.fatal('Another uRaiden process is already running (%s)!' % str(ex))
sys.exit(1)
except InsecureStateFile as ex:
msg = (
'The permission bits of the state file (%s) are set incorrectly (others can '
'read or write) or you are not the owner. For reasons of security, '
'startup is aborted.' % state_file)
log.fatal(msg)
sys.exit(1)
except NetworkIdMismatch as ex:
log.fatal(str(ex))
sys.exit(1)
except requests.exceptions.ConnectionError as ex:
log.fatal("Ethereum node refused connection: %s" % str(ex))
sys.exit(1)
ctx.obj = app
def start_proxy(receiver_privkey: str) -> PaywalledProxy:
state_file_name = '{}_{}.json'.format(CHANNEL_MANAGER_ADDRESS,
privkey_to_addr(receiver_privkey))
app_dir = click.get_app_dir('microraiden')
if not os.path.exists(app_dir):
os.makedirs(app_dir)
app = make_paywalled_proxy(receiver_privkey,
os.path.join(app_dir, state_file_name))
app.add_content(
PaywalledProxyUrl("[A-Z]{6}", 1 * TKN_DECIMALS,
'http://api.bitfinex.com/v1/pubticker/',
[r'[A-Z]{6}']))
app.run()
return app
def account_factory(eth_allowance, token_allowance):
privkey = random_private_key(1000)
address = privkey_to_addr(privkey)
if use_tester:
ethereum.tester.accounts.append(decode_hex(address))
ethereum.tester.keys.append(decode_hex(privkey))
fund_account(privkey, eth_allowance, token_allowance, make_token_proxy, web3,
wait_for_transaction)
def finalize():
sweep_account(privkey, make_token_proxy, web3, wait_for_transaction)
if use_tester:
ethereum.tester.accounts.remove(decode_hex(address))
ethereum.tester.keys.remove(decode_hex(privkey))
request.addfinalizer(finalize)
return privkey
def main(private_key, state_file, channel_manager_address):
if private_key is None:
log.fatal("No private key provided")
sys.exit(1)
if utils.check_permission_safety(private_key) is False:
log.fatal("Private key file %s must be readable only by its owner." %
(private_key))
sys.exit(1)
with open(private_key) as keyfile:
private_key = keyfile.readline()[:-1]
print(len(decode_hex(private_key)), is_hex(private_key))
if not is_hex(private_key) or len(decode_hex(private_key)) != 32:
log.fatal("Private key must be specified as 32 hex encoded bytes")
sys.exit(1)
receiver_address = privkey_to_addr(private_key)
channel_manager_address = channel_manager_address or config.CHANNEL_MANAGER_ADDRESS
if not state_file:
state_file_name = "%s_%s.json" % (channel_manager_address[:10],
receiver_address[:10])
app_dir = click.get_app_dir('microraiden')
state_file = os.path.join(app_dir, state_file_name)
web3 = Web3(config.WEB3_PROVIDER)
web3.eth.defaultAccount = receiver_address
contract_proxy = make_contract_proxy(web3, private_key,
config.CHANNEL_MANAGER_ADDRESS)
try:
click.echo('Loading state file from {}'.format(state_file))
state = ChannelManagerState.load(state_file)
except StateFileException:
click.echo('Error reading state file')
traceback.print_exc()
sys.exit(1)
if not is_same_address(state.receiver, receiver_address):
click.echo('Private key does not match receiver address in state file')
sys.exit(1)
elif not is_same_address(state.contract_address, channel_manager_address):
click.echo('Channel manager contract address mismatch')
sys.exit(1)
click.echo('Closing all open channels with valid balance proofs for '
'receiver {}'.format(receiver_address))
close_open_channels(state, contract_proxy)
def test_eth_sign_typed_data_eip():
# Test cases from the EIP:
# https://github.com/0xProject/EIPs/blob/01dfc0f9a4122d8ad8817c503447cab8efa8a6c4/EIPS/eip-signTypedData.md#test-cases
privkey = 'f2f48ee19680706196e2e339e5da3491186e0c4c5030670656b0e0164837257d'
addr = '0x5409ed021d9299bf6814279a6a1411a7e866a631'
assert addr == privkey_to_addr(privkey)
typed_data = [('string', 'message', 'Hi, Alice!')]
msg = eth_sign_typed_data_message_eip(typed_data)
assert encode_hex(
msg
) == '0xe18794748cc6d73634d578f6a83f752bee11a0c9853d76bd0111d67a9b555a2c'
sig = eth_sign_typed_data_eip(privkey, typed_data)
sig_expected = '0x1a4ca93acf066a580f097690246e6c85d1deeb249194f6d3c2791f3aecb6adf8' \
'714ca4a0f12512ddd2a4f2393ea0c3b2c856279ba4929a5a34ae6859689428061b'
assert encode_hex(sig) == sig_expected
typed_data = [('uint', 'value', 42)]
msg = eth_sign_typed_data_message_eip(typed_data)
assert encode_hex(
msg
) == '0x6cb1c2645d841a0a3d142d1a2bdaa27015cc77f442e17037015b0350e468a957'
sig = eth_sign_typed_data_eip(privkey, typed_data)
sig_expected = '0x87c5b6a9f3a758babcc9140a96ae07957c6c9109af65bf139266cded52da49e6' \
'3df6af6f7daef588218e156bc83b95e0bfcfa8e72843cf4cf8c67c3ca11c3fd11b'
assert encode_hex(sig) == sig_expected
typed_data = [('uint', 'value', 42), ('string', 'message', 'Hi, Alice!'),
('bool', 'removed', False)]
msg = eth_sign_typed_data_message_eip(typed_data)
assert encode_hex(
msg
) == '0x36c3ed8591950e33dc4777bb455ab1a3e4223f84c42172a1ff2e200d5e25ee2e'
sig = eth_sign_typed_data_eip(privkey, typed_data)
sig_expected = '0x466a5a021225b681836e9951d2e603a37a605850ca26da0692ca532d4d1581d6' \
'031e2e3754fe31036e3a56d7e37fb6f598f7ab7a5cdd87aa04c9811c8b6209f31b'
assert encode_hex(sig) == sig_expected
def fund_account(privkey, eth_allowance, token_allowance, make_token_proxy, web3,
wait_for_transaction):
address = privkey_to_addr(privkey)
tx = Transaction(
nonce=web3.eth.getTransactionCount(FAUCET_ADDRESS, 'pending'),
gasprice=GAS_PRICE,
startgas=21000,
to=decode_hex(address),
value=eth_allowance,
data=b'',
v=0, r=0, s=0
)
sign_transaction(tx, FAUCET_PRIVKEY, web3.version.network)
tx_hash = web3.eth.sendRawTransaction(encode_hex(rlp.encode(tx)))
wait_for_transaction(tx_hash)
if token_allowance > 0:
faucet_token_proxy = make_token_proxy(FAUCET_PRIVKEY)
tx = faucet_token_proxy.create_signed_transaction('transfer',
[decode_hex(address), token_allowance])
tx_hash = web3.eth.sendRawTransaction(tx)
wait_for_transaction(tx_hash)
def main(private_key, private_key_password_file, state_file,
channel_manager_address):
private_key = utils.get_private_key(private_key, private_key_password_file)
if private_key is None:
sys.exit(1)
receiver_address = privkey_to_addr(private_key)
channel_manager_address = channel_manager_address or config.CHANNEL_MANAGER_ADDRESS
if not state_file:
state_file_name = "%s_%s.json" % (channel_manager_address[:10],
receiver_address[:10])
app_dir = click.get_app_dir('microraiden')
state_file = os.path.join(app_dir, state_file_name)
web3 = Web3(config.WEB3_PROVIDER)
web3.eth.defaultAccount = receiver_address
contract_proxy = make_contract_proxy(web3, private_key,
config.CHANNEL_MANAGER_ADDRESS)
try:
click.echo('Loading state file from {}'.format(state_file))
state = ChannelManagerState.load(state_file)
except StateFileException:
click.echo('Error reading state file')
traceback.print_exc()
sys.exit(1)
if not is_same_address(state.receiver, receiver_address):
click.echo('Private key does not match receiver address in state file')
sys.exit(1)
elif not is_same_address(state.contract_address, channel_manager_address):
click.echo('Channel manager contract address mismatch')
sys.exit(1)
click.echo('Closing all open channels with valid balance proofs for '
'receiver {}'.format(receiver_address))
close_open_channels(state, contract_proxy)
def test_different_receivers(web3, make_account, make_channel_manager_proxy,
token_contract, mine_sync_event, client,
sender_address, wait_for_blocks, use_tester,
state_db_path):
receiver1_privkey = make_account(RECEIVER_ETH_ALLOWANCE,
RECEIVER_TOKEN_ALLOWANCE)
receiver2_privkey = make_account(RECEIVER_ETH_ALLOWANCE,
RECEIVER_TOKEN_ALLOWANCE)
receiver1_address = privkey_to_addr(receiver1_privkey)
channel_manager1 = ChannelManager(
web3,
make_channel_manager_proxy(receiver1_privkey),
token_contract,
receiver1_privkey,
n_confirmations=5,
state_filename=state_db_path)
start_channel_manager(channel_manager1, use_tester, mine_sync_event)
channel_manager2 = ChannelManager(
web3,
make_channel_manager_proxy(receiver2_privkey),
token_contract,
receiver2_privkey,
n_confirmations=5,
state_filename=state_db_path)
start_channel_manager(channel_manager2, use_tester, mine_sync_event)
channel_manager1.wait_sync()
channel_manager2.wait_sync()
blockchain = channel_manager1.blockchain
assert channel_manager2.blockchain.n_confirmations == blockchain.n_confirmations
assert channel_manager2.blockchain.poll_interval == blockchain.poll_interval
# unconfirmed open
channel = client.open_channel(receiver1_address, 10)
wait_for_blocks(1)
gevent.sleep(blockchain.poll_interval)
assert (sender_address,
channel.block) in channel_manager1.unconfirmed_channels
assert (sender_address,
channel.block) not in channel_manager2.unconfirmed_channels
# confirmed open
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
assert (sender_address, channel.block) in channel_manager1.channels
assert (sender_address, channel.block) not in channel_manager2.channels
# unconfirmed topup
channel.topup(5)
wait_for_blocks(1)
gevent.sleep(blockchain.poll_interval)
channel_rec = channel_manager1.channels[sender_address, channel.block]
assert len(channel_rec.unconfirmed_topups) == 1
assert channel_rec.deposit == 10
# confirmed topup
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
channel_rec = channel_manager1.channels[sender_address, channel.block]
assert len(channel_rec.unconfirmed_topups) == 0
assert channel_rec.deposit == 15
# closing
channel.close()
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
channel_rec = channel_manager1.channels[sender_address, channel.block]
assert channel_rec.is_closed is True
# settlement
block_before = web3.eth.blockNumber
wait_for_blocks(channel_rec.settle_timeout - block_before)
channel.settle()
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
assert (sender_address, channel.block) not in channel_manager1.channels
channel_manager1.stop()
channel_manager2.stop()
def __init__(self,
privkey: str = None,
key_path: str = None,
key_password_path: str = None,
channel_manager_address: str = CHANNEL_MANAGER_ADDRESS,
web3: Web3 = None,
channel_manager_proxy: ChannelContractProxy = None,
token_proxy: ContractProxy = None,
contract_metadata: dict = CONTRACT_METADATA) -> None:
assert privkey or key_path
assert not privkey or isinstance(privkey, str)
# Plain copy initializations.
self.privkey = privkey
self.channel_manager_address = channel_manager_address
self.web3 = web3
self.channel_manager_proxy = channel_manager_proxy
self.token_proxy = token_proxy
# Load private key from file if none is specified on command line.
if not privkey:
self.privkey = get_private_key(key_path, key_password_path)
assert self.privkey is not None
self.account = privkey_to_addr(self.privkey)
self.channels = [] # type: List[Channel]
# Create web3 context if none is provided, either by using the proxies' context or creating
# a new one.
if not web3:
if channel_manager_proxy:
self.web3 = channel_manager_proxy.web3
self.channel_manager_address = channel_manager_proxy.address
elif token_proxy:
self.web3 = token_proxy.web3
else:
self.web3 = Web3(RPCProvider())
# Create missing contract proxies.
if not channel_manager_proxy:
channel_manager_abi = contract_metadata[CHANNEL_MANAGER_ABI_NAME][
'abi']
self.channel_manager_proxy = ChannelContractProxy(
self.web3, self.privkey, channel_manager_address,
channel_manager_abi, GAS_PRICE, GAS_LIMIT)
token_address = self.channel_manager_proxy.contract.call().token()
if not token_proxy:
token_abi = contract_metadata[TOKEN_ABI_NAME]['abi']
self.token_proxy = ContractProxy(self.web3, self.privkey,
token_address, token_abi,
GAS_PRICE, GAS_LIMIT)
else:
assert is_same_address(self.token_proxy.address, token_address)
assert self.web3
assert self.channel_manager_proxy
assert self.token_proxy
assert self.channel_manager_proxy.web3 == self.web3 == self.token_proxy.web3
self.sync_channels()
def __init__(
self,
privkey: str = None,
key_path: str = None,
key_password_path: str = None,
datadir: str = click.get_app_dir('microraiden'),
channel_manager_address: str = CHANNEL_MANAGER_ADDRESS,
web3: Web3 = None,
channel_manager_proxy: ChannelContractProxy = None,
token_proxy: ContractProxy = None,
contract_metadata: dict = CONTRACT_METADATA
) -> None:
assert privkey or key_path
assert not privkey or isinstance(privkey, str)
# Plain copy initializations.
self.privkey = privkey
self.datadir = datadir
self.channel_manager_address = channel_manager_address
self.web3 = web3
self.channel_manager_proxy = channel_manager_proxy
self.token_proxy = token_proxy
# Load private key from file if none is specified on command line.
if not privkey:
self.privkey = get_private_key(key_path, key_password_path)
assert self.privkey is not None
os.makedirs(datadir, exist_ok=True)
assert os.path.isdir(datadir)
self.account = privkey_to_addr(self.privkey)
self.channels = [] # type: List[Channel]
# Create web3 context if none is provided, either by using the proxies' context or creating
# a new one.
if not web3:
if channel_manager_proxy:
self.web3 = channel_manager_proxy.web3
self.channel_manager_address = channel_manager_proxy.address
elif token_proxy:
self.web3 = token_proxy.web3
else:
self.web3 = Web3(RPCProvider())
# Create missing contract proxies.
if not channel_manager_proxy:
channel_manager_abi = contract_metadata[CHANNEL_MANAGER_ABI_NAME]['abi']
self.channel_manager_proxy = ChannelContractProxy(
self.web3,
self.privkey,
channel_manager_address,
channel_manager_abi,
GAS_PRICE,
GAS_LIMIT
)
token_address = self.channel_manager_proxy.contract.call().token()
if not token_proxy:
token_abi = contract_metadata[TOKEN_ABI_NAME]['abi']
self.token_proxy = ContractProxy(
self.web3, self.privkey, token_address, token_abi, GAS_PRICE, GAS_LIMIT
)
else:
assert is_same_address(self.token_proxy.address, token_address)
assert self.web3
assert self.channel_manager_proxy
assert self.token_proxy
assert self.channel_manager_proxy.web3 == self.web3 == self.token_proxy.web3
netid = self.web3.version.network
self.balances_filename = 'balances_{}_{}.json'.format(
NETWORK_NAMES.get(netid, netid), self.account[:10]
)
self.filelock = filelock.FileLock(os.path.join(self.datadir, self.balances_filename))
self.filelock.acquire(timeout=0)
self.load_channels()
self.sync_channels()
from microraiden import config
from microraiden.crypto import privkey_to_addr
# private key of the content provider
PRIVATE_KEY = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
RECEIVER_ADDRESS = privkey_to_addr(PRIVATE_KEY)
# host and port Parity/Geth serves RPC requests on
RPC_PROVIDER = 'http://172.17.0.1:8180'
# state file to store proxy state and balance proofs
STATE_FILE = "/files/%s_%s.json" % (config.CHANNEL_MANAGER_ADDRESS[:10],
RECEIVER_ADDRESS[:10])
SLEEP_RELOAD = 2
def __init__(self, receiver1_privkey):
self._address = privkey_to_addr(receiver1_privkey)
def deployer_address(deployer_privkey):
return privkey_to_addr(deployer_privkey)
def __init__(
self,
privkey: str = None,
key_path: str = None,
datadir: str = click.get_app_dir('microraiden'),
channel_manager_address: str = CHANNEL_MANAGER_ADDRESS,
token_address: str = TOKEN_ADDRESS,
rpc: RPCProvider = None,
web3: Web3 = None,
channel_manager_proxy: ChannelContractProxy = None,
token_proxy: ContractProxy = None,
rpc_endpoint: str = 'localhost',
rpc_port: int = 8545,
contract_abi_path: str = os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'data/contracts.json')
) -> None:
assert privkey or key_path
assert not privkey or isinstance(privkey, str)
# Plain copy initializations.
self.privkey = privkey
self.datadir = datadir
self.channel_manager_address = channel_manager_address
self.token_address = token_address
self.web3 = web3
self.channel_manager_proxy = channel_manager_proxy
self.token_proxy = token_proxy
# Load private key from file if none is specified on command line.
if not privkey:
with open(key_path) as keyfile:
self.privkey = keyfile.readline()[:-1]
os.makedirs(datadir, exist_ok=True)
assert os.path.isdir(datadir)
self.account = privkey_to_addr(self.privkey)
self.channels = [] # type: List[Channel]
# Create web3 context if none is provided, either by using the proxies' context or creating
# a new one.
if not web3:
if channel_manager_proxy:
self.web3 = channel_manager_proxy.web3
elif token_proxy:
self.web3 = token_proxy.web3
else:
if not rpc:
rpc = RPCProvider(rpc_endpoint, rpc_port)
self.web3 = Web3(rpc)
# Create missing contract proxies.
if not channel_manager_proxy or not token_proxy:
with open(contract_abi_path) as abi_file:
contract_abis = json.load(abi_file)
if not channel_manager_proxy:
channel_manager_abi = contract_abis[CHANNEL_MANAGER_ABI_NAME][
'abi']
self.channel_manager_proxy = ChannelContractProxy(
self.web3, self.privkey, channel_manager_address,
channel_manager_abi, GAS_PRICE, GAS_LIMIT)
if not token_proxy:
token_abi = contract_abis[TOKEN_ABI_NAME]['abi']
self.token_proxy = ContractProxy(self.web3, self.privkey,
token_address, token_abi,
GAS_PRICE, GAS_LIMIT)
assert self.web3
assert self.channel_manager_proxy
assert self.token_proxy
assert self.channel_manager_proxy.web3 == self.web3 == self.token_proxy.web3
netid = self.web3.version.network
self.balances_filename = 'balances_{}_{}.json'.format(
NETWORK_NAMES.get(netid, netid), self.account[:10])
self.filelock = filelock.FileLock(
os.path.join(self.datadir, self.balances_filename))
self.filelock.acquire(timeout=0)
self.load_channels()
self.sync_channels()
import os
from eth_utils import denoms
from microraiden.crypto import privkey_to_addr
CHANNEL_MANAGER_ADDRESS = '0xeb244b0502a2d3867e5cab2347c6e1cdeb5e1eef'
API_PATH = "/api/1"
GAS_LIMIT = 200000
GAS_PRICE = 5 * denoms.gwei
MICRORAIDEN_DIR = os.path.abspath(
os.path.join(os.path.dirname(__file__), '../..'))
HTML_DIR = os.path.join(MICRORAIDEN_DIR, 'microraiden', 'webui')
JSLIB_DIR = os.path.join(HTML_DIR, 'js')
FAUCET_PRIVKEY = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
FAUCET_ADDRESS = privkey_to_addr(FAUCET_PRIVKEY)
FAUCET_ALLOWANCE = 10**23
INITIAL_TOKEN_SUPPLY = 10**25
SENDER_ETH_ALLOWANCE = int(0.02 * denoms.ether)
SENDER_TOKEN_ALLOWANCE = 10**20
RECEIVER_ETH_ALLOWANCE = int(0.02 * denoms.ether)
RECEIVER_TOKEN_ALLOWANCE = 0
def client_address(client_privkey):
return privkey_to_addr(client_privkey)
from microraiden.crypto import (
privkey_to_addr,
sha3_hex,
sign,
pubkey_to_addr,
get_balance_message,
sign_balance_proof,
verify_balance_proof,
eth_sign,
sha3,
addr_from_sig,
eth_verify
)
SENDER_PRIVATE_KEY = '0xa0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0'
SENDER_ADDR = privkey_to_addr(SENDER_PRIVATE_KEY)
RECEIVER_PRIVATE_KEY = '0xb1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1'
RECEIVER_ADDR = privkey_to_addr(RECEIVER_PRIVATE_KEY)
def test_encode_hex():
assert isinstance(encode_hex(b''), str)
assert isinstance(decode_hex(''), bytes)
def test_sha3():
addr1 = '0x1212121212121212121212121212121212121212'
addr2 = '0x3434343434343434343434343434343434343434'
assert sha3_hex('a') == '0x3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb'
assert sha3_hex('0x0a') == '0x0ef9d8f8804d174666011a394cab7901679a8944d24249fd148a6a36071151f8'
def sender_address(sender_privkey):
return privkey_to_addr(sender_privkey)
def receiver_address(receiver_privkey):
return privkey_to_addr(receiver_privkey)
