def create_reserve_token(app):
print_section_title("Setting up Reserve Token")
reserve_token_address = app.config.get('RESERVE_TOKEN_ADDRESS')
reserve_token_name = app.config.get('RESERVE_TOKEN_NAME')
reserve_token_symbol = app.config.get('RESERVE_TOKEN_SYMBOL')
# reserve_token_decimals = app.config.get('RESERVE_TOKEN_DECIMALS')
if reserve_token_address:
reserve_token = Token.query.filter_by(
address=reserve_token_address).first()
print('Existing token not found, creating')
if not reserve_token:
reserve_token = Token(address=reserve_token_address,
name=reserve_token_name,
symbol=reserve_token_symbol,
token_type=TokenType.RESERVE)
db.session.add(reserve_token)
db.session.commit()
print(f'Reserve token: {reserve_token}')
return reserve_token
print('No token address, skipping')
return None
def deploy_and_add_smart_token(name, symbol, reserve_ratio_ppm, exchange_contract=None):
smart_token_result = bt.deploy_smart_token(
deploying_address=deploying_address,
name=name, symbol=symbol, decimals=18,
reserve_deposit_wei=10,
issue_amount_wei=1000,
contract_registry_address=registry_address,
reserve_token_address=reserve_token.address,
reserve_ratio_ppm=reserve_ratio_ppm
)
smart_token_address = smart_token_result['smart_token_address']
subexchange_address = smart_token_result['subexchange_address']
smart_token = Token(address=smart_token_address, name=name, symbol=symbol, token_type=TokenType.LIQUID)
smart_token.decimals = 18
db.session.add(smart_token)
if exchange_contract is None:
exchange_contract = ExchangeContract(
blockchain_address=subexchange_address,
contract_registry_blockchain_address=registry_address
)
exchange_contract.add_reserve_token(reserve_token)
exchange_contract.add_token(smart_token, subexchange_address, reserve_ratio_ppm)
return smart_token, exchange_contract
def checkout(id): # noqa: E501
"""checkout
Checks out the arm for a session. # noqa: E501
:param id: The id of the meArm.
:type id: str
:rtype: Token
"""
if id not in me_arm.get_names():
return 'meArm with name %s is not known' % id, 400
if common.token[id] is not None:
return common.status[id], 403
common.token[id] = uuid.uuid4()
common.status[id] = Status(common.HOSTNAME, common.VERSION, True,
datetime.datetime.now(), 0, None)
arm = me_arm.get(id)
arm.turn_on()
_restart_timeout(id)
response = Token(common.token[id])
return response
def post(self):
"""
Dev function for creating a reserve token AFTER master organisation setup, and then binding to master org
"""
post_data = request.get_json()
name = post_data['name']
symbol = post_data['symbol']
fund_amount_wei = post_data['fund_amount_wei']
deploying_address = g.user.primary_blockchain_address
if not Organisation.query.filter_by(is_master=True).first():
response_object = {'message': 'Master organisation not found'}
return make_response(jsonify(response_object)), 400
token = Token(name=name, symbol=symbol, token_type=TokenType.RESERVE)
db.session.add(token)
db.session.flush()
deploy_data = dict(
deploying_address=deploying_address,
name=name,
symbol=symbol,
fund_amount_wei=fund_amount_wei,
)
@copy_current_request_context
def deploy(_deploy_data, _token_id):
# TODO: Work out why execution options doesn't work
g.show_all = True
reserve_token_address = bt.deploy_and_fund_reserve_token(
**_deploy_data)
_token = Token.query.get(_token_id)
_token.address = reserve_token_address
master_org = Organisation.query.filter_by(
is_master=True).execution_options(show_all=True).first()
master_org.bind_token(_token)
master_org.org_level_transfer_account.balance = int(
_deploy_data['fund_amount_wei'] / 1e16)
db.session.commit()
t = threading.Thread(target=deploy, args=(deploy_data, token.id))
t.daemon = True
t.start()
response_object = {
'message': 'success',
'data': {
'reserve_token_id': token.id
}
}
return make_response(jsonify(response_object)), 201
def post(self):
"""
This endpoint is for registering a token with an existing smart contract on the system,
rather than creating a new contract.
To create a new token contract, use api/contract/token/.
"""
post_data = request.get_json()
name = post_data['name']
symbol = post_data['symbol']
decimals = post_data.get('decimals', 18)
address = post_data.get('address')
is_reserve = post_data.get('is_reserve', True)
chain = post_data.get('chain', 'ETHEREUM')
token = Token.query.filter_by(address=address).first()
if token:
response_object = {
'message': 'Token already exists',
'data': {
'token': token_schema.dump(token).data
}
}
return make_response(jsonify(response_object)), 400
if not address or not name or not symbol:
return make_response(
jsonify({
'message':
'Must include address, name and symbol to create token'
})), 400
token_type = TokenType.RESERVE if is_reserve else TokenType.LIQUID
token = Token(address=address,
name=name,
symbol=symbol,
token_type=token_type,
chain=chain)
token.decimals = decimals
db.session.add(token)
response_object = {
'message': 'success',
'data': {
'token': token_schema.dump(token).data
}
}
return make_response(jsonify(response_object)), 201
def get_or_create_reserve_token(deploying_address, name, symbol):
reserve_token = Token.query.filter_by(symbol=symbol).first()
if reserve_token:
return reserve_token
else:
reserve_token_address = bt.deploy_and_fund_reserve_token(
deploying_address=deploying_address,
name=name,
symbol=symbol,
fund_amount_wei=0
)
reserve_token = Token(address=reserve_token_address, name=name, symbol=symbol, token_type=TokenType.RESERVE)
reserve_token.decimals = 18
db.session.add(reserve_token)
return reserve_token
def external_reserve_token(test_client, init_database, loaded_master_wallet_address):
from server.models.token import Token
from server import bt
name = "AUD Reserve Token"
symbol = "AUD"
reserve_token_address = bt.deploy_and_fund_reserve_token(
deploying_address=loaded_master_wallet_address,
name=name,
symbol=symbol,
fund_amount_wei=4 * 10 ** 18
)
reserve_token = Token(address=reserve_token_address, name=name, symbol=symbol, token_type=TokenType.RESERVE)
reserve_token.decimals = 18
db.session.add(reserve_token)
db.session.commit()
return reserve_token
def deploy_cic_token(post_data, creating_org=None):
name = post_data['name']
symbol = post_data['symbol']
decimals = post_data.get('decimals', 18)
issue_amount_wei = int(post_data['issue_amount_wei'])
reserve_deposit_wei = int(post_data['reserve_deposit_wei'])
exchange_contract_id = post_data['exchange_contract_id']
reserve_ratio_ppm = post_data.get('reserve_ratio_ppm', 250000)
if creating_org:
deploying_address = creating_org.primary_blockchain_address
else:
deploying_address = g.user.primary_blockchain_address
if not exchange_contract_id:
response_object = {
'message': 'Must supply exchange contract id if deploying smart token contract'
}
return response_object, 400
exchange_contract = ExchangeContract.query.get(exchange_contract_id)
if not exchange_contract:
response_object = {
'message': 'Exchange contract not found for id {}'.format(exchange_contract_id)
}
return response_object, 400
balance_wei = bt.get_wallet_balance(deploying_address, exchange_contract.reserve_token)
if balance_wei < reserve_deposit_wei:
load_amount = int((reserve_deposit_wei - balance_wei) / 1e16)
master_org = Organisation.master_organisation()
print(f'Insufficient reserve funds (balance in wei: {balance_wei}), loading')
if master_org.org_level_transfer_account.balance < load_amount:
response_object = {
'message': f'Insufficient reserve funds for both deploying account ({balance_wei} wei), '
f'and master ({master_org.org_level_transfer_account.balance * 1e16} wei)'
}
return response_object, 400
load_task_uuid = bt.make_token_transfer(
signing_address=master_org.primary_blockchain_address,
token=exchange_contract.reserve_token,
from_address=master_org.primary_blockchain_address,
to_address=deploying_address,
amount=load_amount
)
try:
bt.await_task_success(load_task_uuid)
except TimeoutError:
response_object = {
'message': f'Insufficient reserve funds (balance in wei: {balance_wei}), and could not load from master'
}
return response_object, 400
master_org.org_level_transfer_account.balance -= load_amount
token = Token(name=name, symbol=symbol, token_type=TokenType.LIQUID)
db.session.add(token)
db.session.flush()
deploy_data = dict(
deploying_address=deploying_address,
name=name, symbol=symbol, decimals=decimals,
reserve_deposit_wei=reserve_deposit_wei,
issue_amount_wei=issue_amount_wei,
contract_registry_address=exchange_contract.contract_registry_blockchain_address,
reserve_token_address=exchange_contract.reserve_token.address,
reserve_ratio_ppm=reserve_ratio_ppm
)
@copy_current_request_context
def deploy(_deploy_data, _token_id, _exchange_contract_id, _creating_org_id=None):
smart_token_result = bt.deploy_smart_token(**_deploy_data)
address = smart_token_result['smart_token_address']
subexchange_address = smart_token_result['subexchange_address']
_token = Token.query.get(_token_id)
_token.address = address
_exchange_contract = ExchangeContract.query.get(_exchange_contract_id)
_exchange_contract.add_token(_token, subexchange_address, reserve_ratio_ppm)
if _creating_org_id:
_creating_org = Organisation.query.get(_creating_org_id)
_creating_org.bind_token(_token)
_creating_org.org_level_transfer_account.balance = int(_deploy_data['issue_amount_wei'] / 1e16)
bal = bt.get_wallet_balance(_creating_org.primary_blockchain_address, _token)
print(f'Balance is {bal}')
db.session.commit()
if creating_org:
creating_org_id = creating_org.id
else:
creating_org_id = None
t = threading.Thread(target=deploy,
args=(deploy_data, token.id, exchange_contract_id, creating_org_id))
t.daemon = True
t.start()
response_object = {
'message': 'success',
'data': {
'token_id': token.id
}
}
return response_object, 201
