def load(cls, filename: str):
"""Load a previously stored state."""
assert filename is not None
assert isinstance(filename, str)
recover_filename = filename + '.tmp'
if os.path.isfile(filename) is False:
log.error("State file %s doesn't exist" % filename)
return None
if not check_permission_safety(filename):
raise InsecureStateFile(filename)
if os.path.getsize(filename) == 0:
log.warning("Empty state file. Trying to recover from %s" % recover_filename)
return ChannelManagerState.load(recover_filename)
json_state = json.loads(open(filename, 'r').read())
json_state['filename'] = filename
json_state['tmp_filename'] = recover_filename
ret = cls.from_dict(json_state)
log.debug("loaded saved state. head_number=%d receiver=%s" %
(ret.confirmed_head_number, ret.receiver))
for sender, block in ret.channels.keys():
log.debug("loaded channel info from the saved state sender=%s open_block=%s" %
(sender, block))
return ret
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 load(cls, filename):
"""Load a previously stored state."""
assert filename is not None
assert isinstance(filename, str)
if not check_permission_safety(filename):
raise InsecureStateFile(filename)
json_state = json.loads(open(filename, 'r').read())
ret = cls.from_dict(json_state)
log.debug("loaded saved state. head_number=%d receiver=%s" %
(ret.confirmed_head_number, ret.receiver))
for sender, block in ret.channels.keys():
log.debug(
"loaded channel info from the saved state sender=%s open_block=%s"
% (sender, block))
return ret
def load(cls, filename: str, check_permissions=True):
"""Load a previously stored state."""
assert filename and isinstance(filename, str)
if filename != ':memory:':
if os.path.isfile(filename) is False:
log.error("State file %s doesn't exist" % filename)
return None
if check_permissions and not check_permission_safety(filename):
raise InsecureStateFile(filename)
ret = cls(filename)
log.debug("loaded saved state. head_number=%s receiver=%s" %
(ret.confirmed_head_number, ret.receiver))
# for sender, block in ret.channels.keys():
# log.debug("loaded channel info from the saved state sender=%s open_block=%s" %
# (sender, block))
return ret
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)
