def main(**kwargs):
project = Project()
chain_name = kwargs['chain']
owner = kwargs['owner']
challenge_period = kwargs['challenge_period']
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 = 250
assert challenge_period >= 500, 'Challenge period should be >= 500 blocks'
if chain_name == 'rinkeby':
txn_wait = 500
print(
'''Make sure {} chain is running, you can connect to it and it is synced,
or you'll get timeout'''.format(chain_name))
with project.get_chain(chain_name) as chain:
web3 = chain.web3
print('Web3 provider is', web3.currentProvider)
owner = owner or web3.eth.accounts[0]
assert owner
assert web3.eth.getBalance(
owner) > 0, 'Account with insuficient funds.'
print('Owner is', owner)
token = chain.provider.get_contract_factory('CustomToken')
if not token_address:
txhash = token.deploy(
args=[supply, token_name, token_symbol, token_decimals],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
token_address = receipt['contractAddress']
print(token_name, 'address is', token_address)
microraiden_contract = chain.provider.get_contract_factory(
'RaidenMicroTransferChannels')
txhash = microraiden_contract.deploy(
args=[token_address, challenge_period])
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
microraiden_address = receipt['contractAddress']
print('RaidenMicroTransferChannels address is', microraiden_address)
abi_encoded_args = encode_hex(
pad_left(pack(remove_0x_prefix(token_address), challenge_period),
128, '0'))
print('RaidenMicroTransferChannels arguments', token_address,
challenge_period)
print('RaidenMicroTransferChannels abi encoded constructor arguments:',
abi_encoded_args)
def main(**kwargs):
project = Project()
chain_name = kwargs['chain']
owner = kwargs['owner']
challenge_period = kwargs['challenge_period']
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 = 250
assert challenge_period >= 500, 'Challenge period should be >= 500 blocks'
if chain_name == 'rinkeby':
txn_wait = 500
print(
'''Make sure {} chain is running, you can connect to it and it is synced,
or you'll get timeout'''.format(chain_name))
with project.get_chain(chain_name) as chain:
web3 = chain.web3
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.'
token = chain.provider.get_contract_factory('CustomToken')
if not token_address:
txhash = token.deploy(
args=[supply, token_name, token_symbol, token_decimals],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
token_address = receipt['contractAddress']
assert token_address and is_address(token_address)
token_address = to_checksum_address(token_address)
print(token_name, 'address is', token_address)
microraiden_contract = chain.provider.get_contract_factory(
'RaidenMicroTransferChannels')
txhash = microraiden_contract.deploy(
args=[token_address, challenge_period, []],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
microraiden_address = receipt['contractAddress']
print('RaidenMicroTransferChannels address is', microraiden_address)
def getTokens(**kwargs):
project = Project()
# print(kwargs)
chain_name = kwargs['chain']
owner = kwargs['owner']
challenge_period = kwargs['challenge_period']
supply = kwargs['supply']
senders = kwargs['senders']
sender_addresses = kwargs['sender_addresses']
token_name = kwargs['token_name']
token_decimals = kwargs['token_decimals']
token_symbol = kwargs['token_symbol']
token_address = kwargs['token_address']
if sender_addresses:
sender_addresses = sender_addresses.split(',')
else:
sender_addresses = []
supply *= 10**(token_decimals)
txn_wait = 250
event_wait = 50
if chain_name == 'rinkeby':
txn_wait = 500
event_wait = 500
print(
'''Make sure {} chain is running, you can connect to it and it is synced,
or you'll get timeout'''.format(chain_name))
with project.get_chain(chain_name) as chain:
web3 = chain.web3
owner = owner or web3.eth.accounts[0]
print('Web3 provider is', web3.currentProvider)
token = chain.provider.get_contract_factory('CustomToken')
if not token_address:
txhash = token.deploy(
args=[supply, token_name, token_symbol, token_decimals],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
token_address = receipt['contractAddress']
print(token_name, ' address is', token_address)
channel_factory = chain.provider.get_contract_factory(
'RaidenMicroTransferChannels')
txhash = channel_factory.deploy(args=[token_address, challenge_period])
print('RaidenMicroTransferChannels arguments', token_address,
challenge_period)
padded_token_address = pad_left(remove_0x_prefix(token_address), 64,
'0')
print('RaidenMicroTransferChannels abi encoded arguments:',
encode_hex(pack(padded_token_address, challenge_period)))
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
cf_address = receipt['contractAddress']
print('RaidenMicroTransferChannels address is', cf_address)
if senders > 0 or len(sender_addresses) > 0:
priv_keys = []
addresses = []
token_assign = int(supply / (len(sender_addresses) + senders))
# we cannot retrieve private keys from configured chains
# therefore: create 5 wallets (sample addresses with private keys)
# store in separate arrays
for i in range(senders - 1):
priv_key, address = createWallet()
priv_keys.append(priv_key)
addresses.append('0x' + address)
# send tokens to each new wallet
for sender in addresses:
token(token_address).transact({
'from': owner
}).transfer(sender, token_assign)
# also send tokens to sender addresses
for sender in sender_addresses:
token(token_address).transact({
'from': owner
}).transfer(sender, token_assign)
print('Senders have each been issued', token_assign, ' tokens')
# check if it works:
# 1. get message balance hash for address[0]
balance_msg = "Receiver: " + addresses[
0] + ", Balance: 10000, Channel ID: 100"
# 2. sign the hash with private key corresponding to address[0]
balance_msg_sig, addr = sign.check(
balance_msg,
binascii.unhexlify(remove_0x_prefix(priv_keys[0])))
# 3. check if ECVerify and ec_recovered address are equal
ec_recovered_addr = channel_factory(
cf_address).call().verifyBalanceProof(addresses[0], 100, 10000,
balance_msg_sig)
print('EC_RECOVERED_ADDR:', ec_recovered_addr)
print('FIRST WALLET ADDR:', addresses[0])
assert ec_recovered_addr == addresses[0]
print('Wait for confirmation...')
transfer_filter = token.on('Transfer')
wait(transfer_filter, event_wait)
print('BALANCE:',
token(token_address).call().balanceOf(addresses[0]))
assert token(token_address).call().balanceOf(addresses[0]) > 0
# return arrays with generated wallets
# (private keys first, then addresses, so that priv_key[0] <-> address[0]
return (priv_keys, addresses, token(token_address))
def main(**kwargs):
project = Project()
chain_name = kwargs['chain']
owner = kwargs['owner']
challenge_period = kwargs['challenge_period']
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 = 250
assert challenge_period >= 500, 'Challenge period should be >= 500 blocks'
if chain_name == 'rinkeby':
txn_wait = 500
print(
'''Make sure {} chain is running, you can connect to it and it is synced,
or you'll get timeout'''.format(chain_name))
with project.get_chain(chain_name) as chain:
web3 = chain.web3
print('Web3 provider is', web3.providers[0])
# Temporary fix for Rinkeby; PoA adds bytes to extraData, which is not yellow-paper-compliant
# https://github.com/ethereum/web3.py/issues/549
if int(web3.version.network) == 4:
txn_wait = 500
size_extraData_for_poa = 200 # can change
pythonic_middleware.__closure__[2].cell_contents[
'eth_getBlockByNumber'].args[1].args[0][
'extraData'] = to_hexbytes(size_extraData_for_poa,
variable_length=True)
pythonic_middleware.__closure__[2].cell_contents[
'eth_getBlockByHash'].args[1].args[0][
'extraData'] = to_hexbytes(size_extraData_for_poa,
variable_length=True)
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.'
token = chain.provider.get_contract_factory('TestMOS')
if not token_address:
txhash = token.deploy(
args=[supply, token_name, token_symbol, token_decimals],
transaction={'from': owner})
time.sleep(180)
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
token_address = receipt['contractAddress']
assert token_address and is_address(token_address)
token_address = to_checksum_address(token_address)
print(token_name, 'address is', token_address)
microraiden_contract = chain.provider.get_contract_factory(
'RaidenMicroTransferChannels')
txhash = microraiden_contract.deploy(
args=[token_address, challenge_period, []],
transaction={'from': owner})
time.sleep(180)
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
microraiden_address = receipt['contractAddress']
print('RaidenMicroTransferChannels address is', microraiden_address)
def main(**kwargs):
project = Project()
chain_name = kwargs['chain']
owner = kwargs['owner']
challenge_period = kwargs['challenge_period']
supply = kwargs['supply']
token_name = kwargs['token_name']
token_decimals = kwargs['token_decimals']
token_symbol = kwargs['token_symbol']
token_address = kwargs['token_address']
output_json = kwargs['output_json']
delta_settle = kwargs['delta_settle']
delta_withdraw = kwargs['delta_withdraw']
supply *= 10**(token_decimals)
txn_wait = 250
#assert challenge_period >= 500, 'Challenge period should be >= 500 blocks'
# PART OF TEMP FIX TO ISSUE 414 IN PULL REQUEST: https://github.com/raiden-network/microraiden/pull/416
# if chain_name == 'rinkeby':
# txn_wait = 500
# end
print(
'''Make sure {} chain is running, you can connect to it and it is synced,
or you'll get timeout'''.format(chain_name))
with project.get_chain(chain_name) as chain:
web3 = chain.web3
print('Web3 provider is', web3.providers[0])
# Temporary fix for Rinkeby; PoA adds bytes to extraData, which is not yellow-paper-compliant
# https://github.com/ethereum/web3.py/issues/549
if int(web3.version.network) == 4:
txn_wait = 500
size_extraData_for_poa = 200
pythonic_middleware.__closure__[2].cell_contents[
'eth_getBlockByNumber'].args[1].args[0][
'extraData'] = to_hexbytes(size_extraData_for_poa,
variable_length=True)
pythonic_middleware.__closure__[2].cell_contents[
'eth_getBlockByHash'].args[1].args[0][
'extraData'] = to_hexbytes(size_extraData_for_poa,
variable_length=True)
# end
owner = 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.'
token = chain.provider.get_contract_factory('CustomToken')
if not token_address:
print("Trying to deploy token.")
txhash = token.deploy(
args=[supply, token_name, token_symbol, token_decimals],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
token_address = receipt['contractAddress']
assert token_address and is_address(token_address)
token_address = to_checksum_address(token_address)
print(token_name, 'address is', token_address)
print(token_name, 'tx is', encode_hex(txhash))
print('Giving address %s some tokens.' % web3.eth.accounts[1])
txid = token.transact({
'from': web3.eth.accounts[1],
'value': web3.toWei(100, 'finney'),
'to': token_address
}).mint()
print('Minting transaction: %s' % txid)
receipt = check_succesful_tx(web3, txid, txn_wait)
print('Minting transaction finished')
microraiden_contract = chain.provider.get_contract_factory(
'RaidenMicroTransferChannels')
txhash = microraiden_contract.deploy(
args=[token_address, challenge_period, []],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
microraiden_address = receipt['contractAddress']
print('RaidenMicroTransferChannels txid is', encode_hex(txhash))
print('RaidenMicroTransferChannels address is', microraiden_address)
owner = web3.eth.accounts[1]
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.'
guardian_contract = chain.provider.get_contract_factory(
'StateGuardian')
txhash = guardian_contract.deploy(args=[delta_withdraw, delta_settle],
transaction={
'from': owner,
'value': 10000
})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
guardian_address = receipt['contractAddress']
print('StateGuardian tx is', encode_hex(txhash))
print('StateGuardian address is', guardian_address)
if output_json:
d = json.load(open(output_json))
d['token'] = token_address
d['manager'] = microraiden_address
d['monitor'] = guardian_address
json.dump(d, open(output_json, 'w'))