def validate(req):
request_json = req.context["data"]
if request_json is None:
raise InvalidParameterError
validator = Validator({
"exchange_contract_name": {
"type":
"string",
"required":
True,
"nullable":
False,
"allowed": [
"IbetStraightBondExchange", "IbetMembershipExchange",
"IbetCouponExchange"
]
},
"account_address_list": {
"type": "list",
"schema": {
"type": "string"
},
"empty": False,
"required": True
}
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
for account_address in request_json["account_address_list"]:
if not Web3.isAddress(account_address):
raise InvalidParameterError("invalid account address")
return request_json
def validate(req):
request_json = req.context["data"]
if request_json is None:
raise InvalidParameterError
validator = Validator({
"account_address_list": {
"type": "list",
"schema": {
"type": "string"
},
"empty": False,
"required": True
}
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
for account_address in request_json["account_address_list"]:
if not Web3.isAddress(account_address):
raise InvalidParameterError
return request_json
def validate_post(req):
request_json = req.context["data"]
if request_json is None:
raise InvalidParameterError
validator = Validator({
"address": {
"type": "string",
"required": True,
"empty": False,
},
"is_read": {
"type": "boolean",
"required": True,
}
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
if not Web3.isAddress(request_json["address"]):
raise InvalidParameterError
return validator.document
def on_payment_requested(self, method: str, url: str, response: Response,
**kwargs) -> bool:
receiver = response.headers[HTTPHeaders.RECEIVER_ADDRESS]
if receiver and Web3.isAddress(receiver):
receiver = Web3.toChecksumAddress(receiver)
price = int(response.headers[HTTPHeaders.PRICE])
assert price > 0
log.debug('Preparing payment of price {} to {}.'.format(
price, receiver))
if self.channel is None or self.channel.state != Channel.State.open:
new_channel = self.client.get_suitable_channel(
receiver, price, self.initial_deposit, self.topup_deposit)
if self.channel is not None and new_channel != self.channel:
# This should only happen if there are multiple open channels to the target or a
# channel has been closed while the session is still being used.
log.warning(
'Channels switched. Previous balance proofs not applicable to new channel.'
)
self.channel = new_channel
elif not self.channel.is_suitable(price):
self.channel.topup(self.topup_deposit(price))
if self.channel is None:
log.error("No channel could be created or sufficiently topped up.")
return False
self.channel.create_transfer(price)
log.debug(
'Sending new balance proof. New channel balance: {}/{}'.format(
self.channel.balance, self.channel.deposit))
return True
def deploy(self, **kwargs):
""" 编译和部署合约 """
deploy_conf = self.conf["deploy"]
# 加载账户
accounts = deploy_conf['account_address']
for name in accounts:
account = accounts[name]
if account == "self":
account = self.account.address
self.addresses[name] = Web3.toChecksumAddress(account)
sortkeys = deploy_conf["sortkeys"]
if not isinstance(sortkeys, list):
raise ValueError('"sortkeys" value error. ')
sortfiles = [
os.path.join(self.spath, key + ".sol") for key in sortkeys
]
compileds = compile_files(sortfiles)
print("Smart contracts are being deployed...\n")
for cname in sortkeys:
cv = None
for ck in compileds.keys():
if ck.endswith(cname):
cv = compileds[ck]
break
if not cv:
raise ValueError(
"No {} compilation results can be found".format(ck))
abi_file = os.path.join(self.abi_dir, cname + ".abi")
bin_file = os.path.join(self.bin_dir, cname + ".bin")
abi_content = cv.get("abi")
bin_content = cv.get("bin")
self.save_file(abi_file, abi_content)
self.save_file(bin_file, bin_content)
factory = self.w3.eth.contract(abi=abi_content,
bytecode=bin_content)
arg = deploy_conf.get(cname)
if Web3.isAddress(arg):
deplpyed_contract_address = Web3.toChecksumAddress(arg)
self.addresses[cname] = deplpyed_contract_address
print("<{} | {}> has been deployed, continue.".format(
cname, deplpyed_contract_address))
continue
contract_address_args, constructor_args = arg
args = []
for name in contract_address_args:
ca = self.addresses.get(name, None)
if not ca:
raise ValueError(
"Cannot find {} contract address".format(name))
args.append(ca)
constructor_args = [
Web3.toChecksumAddress(c) if Web3.isAddress(c) else c
for c in constructor_args
]
args.extend(constructor_args)
print("{} args: {}".format(cname, args))
print("nonce: {}".format(self._nonce()))
func = factory.constructor(*args)
tx = self._build_transaction(func, **kwargs)
tx_hash = self._sign_and_send_rawtransaction(transaction=tx)
print("Waiting for [{} | {}] contract receipt...".format(
cname, tx_hash))
receipt = self.w3.eth.waitForTransactionReceipt(tx_hash,
timeout=600)
contractAddress = receipt["contractAddress"]
self.addresses[cname] = contractAddress
print("{} >>> txHash: {} | contractAddress: {}\n".format(
cname, tx_hash, contractAddress))
time.sleep(0.5) # 预防获取nonce(交易数)时,请求太快而不准确
self.save_file(os.path.join(USER_DATA_DIR, "contractAddresses.json"),
self.addresses)
print("All contracts are deployed.")
self.activate()
async def get_market(sid, data):
current_block = App().web3.eth.getBlock("latest")["number"]
token = data["token"] if "token" in data and Web3.isAddress(
data["token"]) else None
user = data["user"] if "user" in data and Web3.isAddress(
data["user"]) else None
response = {"returnTicker": format_tickers(await get_tickers())}
if token:
trades = await get_trades(token)
orders_buys = await get_orders(ZERO_ADDR,
token,
state=OrderState.OPEN.name,
with_available_volume=True,
sort="(amount_give / amount_get) DESC",
expires_after=current_block)
orders_sells = await get_orders(token,
ZERO_ADDR,
state=OrderState.OPEN.name,
with_available_volume=True,
sort="(amount_get / amount_give) ASC",
expires_after=current_block)
response.update({
"trades": [format_trade(trade) for trade in trades],
"orders": {
"buys": [format_order(order) for order in orders_buys],
"sells": [format_order(order) for order in orders_sells]
}
})
if user:
my_trades = await get_trades(token, user)
my_funds = await get_transfers(token, user)
my_orders_buys = await get_orders(
ZERO_ADDR,
token,
user_hexstr=user,
state=OrderState.OPEN.name,
sort="(amount_give / amount_get) DESC",
expires_after=current_block)
my_orders_sells = await get_orders(
token,
ZERO_ADDR,
user_hexstr=user,
state=OrderState.OPEN.name,
sort="(amount_get / amount_give) ASC",
expires_after=current_block)
response.update({
"myTrades": [format_trade(trade) for trade in my_trades],
"myFunds":
[format_transfer(transfer) for transfer in my_funds],
"myOrders": {
"buys": [format_order(order) for order in my_orders_buys],
"sells":
[format_order(order) for order in my_orders_sells]
}
})
await sio.emit('market', response, room=sid)
def is_address(address):
return Web3.isAddress(address) and Web3.isChecksumAddress(address)
def parse_address(raw_address):
raw_address = BPoolLogCallParser.strip_leading_0_add_0x(raw_address)
if not Web3.isAddress(raw_address):
raise Exception('NOT ADDRESS', raw_address)
return Web3.toChecksumAddress(raw_address)
def _check_addresses(self, addresses):
self._check_strings(addresses)
for address_name in addresses if isinstance(addresses, (list, tuple)) else (addresses, ):
if not Web3.isAddress(self._conf[address_name]):
raise ValueError(address_name + ' is incorrect')
def getSToken(self, address):
address = Web3.toHex(hexstr=address)
if not Web3.isAddress(address):
raise Exception('address not valid')
return self.contract_instance.getSToken(address)
def test_create_account(self):
address, private_key = self.obj_utils.create_account()
assert (Web3.isAddress(address) == True)
return address, private_key
def test_addresses(configuration):
wallet = Wallet(configuration)
wallet.create('eXtR4 EntroPy Str1Ng')
assert Web3.isAddress(wallet.get_address())
assert Web3.isChecksumAddress(wallet.get_address())
def sanitize_addresses(addresses):
return [Web3.toChecksumAddress(a) for a in addresses if Web3.isAddress(a)]
def _validate_address(address):
if not Web3.isAddress(address):
abort(400, 'bad address')
return address
def is_address_valid(address):
return Web3.isAddress(address)
def check_token_address(keeper, token_address):
if token_address == '0x0' or token_address == ZERO_ADDRESS:
return ZERO_ADDRESS
elif not Web3.isAddress(token_address):
return keeper.token.address
return token_address
def checkAddress(self, address):
if (Web3.isAddress(address)):
return True
else:
return False
def validate_get(req):
request_json = {
"address": req.get_param("address"),
"notification_type": req.get_param("notification_type"),
"priority": req.get_param("priority"),
"sort_item": req.get_param("sort_item"),
"sort_order": req.get_param("sort_order"),
"offset": req.get_param("offset"),
"limit": req.get_param("limit"),
}
validator = Validator({
"address": {
"type": "string",
"required": True,
"empty": False,
},
"notification_type": {
"type": "string",
"required": False,
"nullable": True,
"allowed": ["NewOrder", "NewOrderCounterpart", "CancelOrder", "CancelOrderCounterpart", "BuyAgreement",
"BuySettlementOK", "BuySettlementNG", "SellAgreement", "SellSettlementOK",
"SellSettlementNG", "StartInitialOffering", "StopInitialOffering", "StartOffering",
"StopOffering", "Redeem", "Suspend", "ApplyForOffering", "Allot", "Transfer",
"PaymentAccountRegister", "PaymentAccountApprove", "PaymentAccountUnapprove",
"PaymentAccountWarn", "PaymentAccountBan"],
},
"priority": {
"type": "integer",
"coerce": int,
"min": 0,
"max": 2,
"required": False,
"nullable": True,
},
"sort_item": {
"type": "string",
"required": False,
"nullable": True,
"allowed": ["notification_type", "priority", "block_timestamp", "created"],
},
# NOTE: 0:asc, 1:desc
"sort_order": {
"type": "integer",
"coerce": int,
"min": 0,
"max": 1,
"required": False,
"nullable": True,
},
"offset": {
"type": "integer",
"coerce": int,
"min": 0,
"required": False,
"nullable": True,
},
'limit': {
"type": "integer",
"coerce": int,
"min": 0,
"required": False,
"nullable": True,
},
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
if not Web3.isAddress(request_json["address"]):
raise InvalidParameterError
return validator.document
def get_gas_spent(address):
if not Web3.isAddress(address.lower()):
return "Address " + str(address.lower()) + " not valid."
else:
gas_spent = requests_util.get_gas_spent(address)
return gas_spent.to_string()
async def get_market(sid, data):
start_time = time()
if sid not in sid_environ:
logger.error(
"received getMarket from sid=%s, but it is not in environs", sid)
# Force a disconnect
await sio.disconnect(sid)
return
if not isinstance(data, dict):
logger.warn("event=getMarket sid=%s data='%s'", sid, data)
await sio.emit('exception', {
"errorCode": 400,
"errorMessage": "getMarket payload must be an object"
},
room=sid)
return
token = data["token"].lower() if "token" in data and Web3.isAddress(
data["token"]) else None
user = data["user"].lower() if "user" in data and Web3.isAddress(
data["user"]) and data["user"].lower() != ED_CONTRACT_ADDR else None
response = {"returnTicker": format_tickers(await get_tickers())}
if token:
trades = await get_trades(token)
response.update({"trades": safe_list_render(trades, format_trade)})
if token not in STOPPED_TOKENS:
orders_buys = await get_orders(
ZERO_ADDR,
token,
state=OrderState.OPEN.name,
with_available_volume=True,
sort="(amount_give / amount_get) DESC",
expires_after=get_current_block())
orders_sells = await get_orders(
token,
ZERO_ADDR,
state=OrderState.OPEN.name,
with_available_volume=True,
sort="(amount_get / amount_give) ASC",
expires_after=get_current_block())
response.update({
"orders": {
"buys": safe_list_render(orders_buys, format_order),
"sells": safe_list_render(orders_sells, format_order)
}
})
else:
response.update({"orders": {"buys": [], "sells": []}})
if user:
my_trades = await get_trades(token, user)
my_funds = await get_transfers(token, user)
my_orders_buys = await get_orders(
ZERO_ADDR,
token,
user_hexstr=user,
state=OrderState.OPEN.name,
sort="(amount_give / amount_get) DESC",
expires_after=get_current_block())
my_orders_sells = await get_orders(
token,
ZERO_ADDR,
user_hexstr=user,
state=OrderState.OPEN.name,
sort="(amount_get / amount_give) ASC",
expires_after=get_current_block())
response.update({
"myTrades":
safe_list_render(my_trades, format_trade),
"myFunds":
safe_list_render(my_funds, format_transfer),
"myOrders": {
"buys": safe_list_render(my_orders_buys, format_order),
"sells": safe_list_render(my_orders_sells, format_order)
}
})
await sio.emit('market', response, room=sid)
logger.debug(
'event=getMarket sid=%s ip=%s token=%s user=%s current_block=%i duration=%f',
sid, sid_environ[sid].get('HTTP_X_REAL_IP'), token, user,
get_current_block(),
time() - start_time)
def post(self):
post_data = request.get_json()
uuid = post_data.get('uuid')
created = post_data.get('created')
transfer_use = post_data.get('transfer_use')
try:
use_ids = transfer_use.split(',') # passed as '3,4' etc.
except AttributeError:
use_ids = transfer_use
transfer_mode = post_data.get('transfer_mode')
transfer_amount = round(Decimal(post_data.get('transfer_amount', 0)), 6)
transfer_random_key = post_data.get('transfer_random_key')
pin = post_data.get('pin')
nfc_serial_number = post_data.get('nfc_id')
user_id = post_data.get('user_id')
public_identifier = post_data.get('public_identifier')
transfer_account_id = post_data.get('transfer_account_id')
qr_data = post_data.get('qr_data')
if qr_data is not None:
qr_data = str(qr_data).strip(" ").strip("\t")
my_transfer_account_id = post_data.get("my_transfer_account_id")
is_sending = post_data.get('is_sending', False)
transfer_card = None
my_transfer_account = None
authorised = False
if transfer_account_id:
counterparty_transfer_account = TransferAccount.query.get(transfer_account_id)
else:
counterparty_transfer_account = None
if uuid:
existing_transfer = CreditTransfer.query.filter_by(uuid=uuid).first()
if existing_transfer:
# We return a 201 here so that the client removes the uuid from the cache
response_object = {
'message': 'Transfer already in cache',
'data': {
'credit_transfer': me_credit_transfer_schema.dump(existing_transfer).data,
}
}
return make_response(jsonify(response_object)), 201
if qr_data:
split_qr_data = qr_data.split('-')
transfer_amount = int(split_qr_data[0])
transfer_account_id = int(split_qr_data[1])
user_id = int(split_qr_data[2])
qr_hash = split_qr_data[3]
counterparty_user = User.query.get(user_id)
if not counterparty_user:
response_object = {
'message': 'No such user for ID {}'.format(user_id),
'feedback': True,
}
return make_response(jsonify(response_object)), 404
counterparty_transfer_account = TransferAccount.query.get(transfer_account_id)
if not counterparty_transfer_account:
response_object = {
'message': 'No such Transfer Account for ID {}'.format(transfer_account_id),
'feedback': True,
}
return make_response(jsonify(response_object)), 404
if counterparty_transfer_account not in counterparty_user.transfer_accounts:
if not counterparty_transfer_account:
response_object = {
'message': 'User {} not authorised for Transfer Account {}.'
.format(user_id, transfer_account_id),
'feedback': True,
}
return make_response(jsonify(response_object)), 401
my_transfer_account = find_transfer_accounts_with_matching_token(
g.user, counterparty_transfer_account.token
)
user_secret = counterparty_user.secret
if not check_for_any_valid_hash(transfer_amount, transfer_account_id, user_secret, qr_hash):
response_object = {
'message': 'Invalid QR Code',
'feedback': True,
}
return make_response(jsonify(response_object)), 401
authorised = True
elif nfc_serial_number:
# We treat NFC serials differently because they're automatically authorised under the current version
transfer_card = TransferCard.query.filter_by(nfc_serial_number=nfc_serial_number).first()
if transfer_card:
counterparty_user = transfer_card.user
counterparty_transfer_account = transfer_card.transfer_account
if not transfer_card or not counterparty_user or not counterparty_transfer_account:
response_object = {
'message': 'Card not found',
'feedback': True
}
return make_response(jsonify(response_object)), 404
authorised = True
else:
try:
counterparty_user, _ = find_user_with_transfer_account_from_identifiers(
user_id,
public_identifier,
transfer_account_id)
except (NoTransferAccountError, UserNotFoundError) as e:
if not Web3.isAddress(public_identifier.strip('ethereum:')) or not is_sending:
response_object = {
'message': str(e),
'feedback': True
}
return make_response(jsonify(response_object)), 400
my_transfer_account = TransferAccount.query.get(my_transfer_account_id)
if not my_transfer_account:
response_object = {
'message': 'Transfer Account not found for my_transfer_account_id {}'.format(
my_transfer_account_id)
}
return make_response(jsonify(response_object)), 400
#We're sending directly to a blockchain address
return handle_transfer_to_blockchain_address(transfer_amount,
my_transfer_account,
public_identifier.strip('ethereum:'),
transfer_use,
transfer_mode=TransferModeEnum.EXTERNAL,
uuid=uuid)
if not counterparty_user:
response_object = {
'message': 'User not found',
'feedback': True
}
return make_response(jsonify(response_object)), 400
authorised = counterparty_user.verify_password(str(pin))
if is_sending:
authorised = True
if not authorised:
response_object = {
'message': 'Not Authorised',
'feedback': True,
}
return make_response(jsonify(response_object)), 401
if not my_transfer_account:
if not my_transfer_account_id:
response_object = {
'message': 'You must provide your Transfer Account ID',
}
return make_response(jsonify(response_object)), 400
my_transfer_account = TransferAccount.query.get(my_transfer_account_id)
if not my_transfer_account:
response_object = {
'message': 'Transfer Account not found for my_transfer_account_id {}'.format(my_transfer_account_id)
}
return make_response(jsonify(response_object)), 400
if my_transfer_account not in g.user.transfer_accounts:
response_object = {
'message': 'Transfer account provided does not belong to user',
}
return make_response(jsonify(response_object)), 401
if is_sending:
send_user = g.user
send_transfer_account = my_transfer_account
receive_user = counterparty_user
receive_transfer_account = counterparty_transfer_account
else:
if counterparty_transfer_account is None:
response_object = {
'message': 'Counterparty Transfer Account not specified'
}
return make_response(jsonify(response_object)), 400
send_user = counterparty_user
send_transfer_account = counterparty_transfer_account
receive_user = g.user
receive_transfer_account = my_transfer_account
if transfer_amount == 0 or transfer_amount > send_transfer_account.balance:
db.session.commit()
response_object = {
'message': 'Insufficient funds',
'feedback': True,
}
return make_response(jsonify(response_object)), 400
try:
transfer = make_payment_transfer(transfer_amount=transfer_amount,
send_user=send_user,
send_transfer_account=send_transfer_account,
receive_user=receive_user,
receive_transfer_account=receive_transfer_account,
transfer_use=transfer_use,
transfer_mode=transfer_mode,
uuid=uuid,
transfer_card=transfer_card)
except AccountNotApprovedError as e:
db.session.commit()
if e.is_sender is True:
response_object = {
'message': "Sender is not approved",
'feedback': True,
}
return make_response(jsonify(response_object)), 400
elif e.is_sender is False:
response_object = {
'message': "Recipient is not approved",
'feedback': True,
}
return make_response(jsonify(response_object)), 400
else:
response_object = {
'message': "Account is not approved",
'feedback': True,
}
return make_response(jsonify(response_object)), 400
except InsufficientBalanceError as e:
db.session.commit()
response_object = {
'message': "Insufficient balance",
'feedback': True,
}
return make_response(jsonify(response_object)), 400
if created:
try:
transfer.created = datetime.datetime.strptime(created, "%Y-%m-%dT%H:%M:%S.%fz")
except ValueError as e:
pass
if is_sending:
push_user_transfer_confirmation(receive_user, transfer_random_key)
db.session.commit()
response_object = {
'message': 'Payment Successful',
'first_name': counterparty_user.first_name,
'last_name': counterparty_user.last_name,
'feedback': True,
'data': {
'credit_transfer': me_credit_transfer_schema.dump(transfer).data
}
}
return make_response(jsonify(response_object)), 201
def valid_address(address):
"""验证是否是一个以太坊地址, 用EIP55校验和返回给定的地址。"""
if not Web3.isAddress(address):
return None
address = Web3.toChecksumAddress(address)
return address
def create_request_as_payer(self, id_addresses, amounts,
payment_addresses, payer_refund_address, payer_id_address,
data=None,
creation_payments=None, additional_payments=None):
"""
:param id_addresses:
:param amounts:
:param payment_addresses:
:param payer_refund_address:
:param payer_id_address:
:param data:
:param creation_payments: Amount to pay when Request is created
:param additional_payments: Additional amount to pay each payee, on top of expected amount
:param options:
:return:
"""
payment_addresses = [
Web3.toChecksumAddress(a) if a else EMPTY_BYTES_20 for a in payment_addresses
]
creation_payments = creation_payments if creation_payments else []
additional_payments = additional_payments if additional_payments else []
ipfs_hash = store_ipfs_data(data) if data else ''
# TODO better validation, more DRY
# Validate Request parameters
if len(id_addresses) != len(amounts):
raise InvalidRequestParameters(
'payees and amounts must be the same size'
)
if payment_addresses and len(id_addresses) < len(payment_addresses):
raise InvalidRequestParameters(
'payees can not be larger than payee_payment_addresses'
)
if creation_payments and len(id_addresses) < len(creation_payments):
raise InvalidRequestParameters(
'payees can not be larger than creation_payments'
)
if additional_payments and len(id_addresses) < len(additional_payments):
raise InvalidRequestParameters(
'payees can not be larger than additional_payments'
)
for amount in amounts:
if int(amount) < 0:
raise InvalidRequestParameters(
'amounts must be positive integers'
)
for amount in creation_payments:
if int(amount) < 0:
raise InvalidRequestParameters(
'amounts must be positive integers'
)
for address in id_addresses + payment_addresses:
if not Web3.isAddress(address):
raise InvalidRequestParameters(
'{} is not a valid Ethereum address'.format(address)
)
# call fee estimator, set as value for tx
currency_contract_data = self._get_currency_contract_data()
currency_contract = currency_contract_data['instance']
estimated_value = currency_contract.functions.collectEstimation(
_expectedAmount=sum(a for a in creation_payments)
).call()
transaction_options = {
'from': payer_id_address,
'value': estimated_value
}
tx_hash = currency_contract.functions.createRequestAsPayer(
_payeesIdAddress=id_addresses,
_expectedAmounts=amounts,
_payerRefundAddress=payer_refund_address,
_payeeAmounts=creation_payments,
_additionals=additional_payments,
_data=ipfs_hash
).transact(transaction_options)
return Web3.toHex(tx_hash)
async def get_market(sid, data):
if sid not in sid_environ:
logger.error(
"received getMarket from sid=%s, but it is not in environs", sid)
# Force a disconnect
await sio.disconnect(sid)
return
if not isinstance(data, dict):
logger.warn("event=getMarket sid=%s data='%s'", sid, data)
await sio.emit('exception', {
"errorCode": 400,
"errorMessage": "getMarket payload must be an object"
},
room=sid)
return
logger.debug('event=getMarket sid=%s ip=%s token=%s user=%s', sid,
sid_environ[sid].get('HTTP_X_REAL_IP'), data.get('token'),
data.get('user'))
current_block = App().web3.eth.getBlock("latest")["number"]
token = data["token"] if "token" in data and Web3.isAddress(
data["token"]) else None
user = data["user"] if "user" in data and Web3.isAddress(
data["user"]) and data["user"].lower() != ED_CONTRACT_ADDR else None
response = {"returnTicker": format_tickers(await get_tickers())}
if token:
trades = await get_trades(token)
orders_buys = await get_orders(ZERO_ADDR,
token,
state=OrderState.OPEN.name,
with_available_volume=True,
sort="(amount_give / amount_get) DESC",
expires_after=current_block)
orders_sells = await get_orders(token,
ZERO_ADDR,
state=OrderState.OPEN.name,
with_available_volume=True,
sort="(amount_get / amount_give) ASC",
expires_after=current_block)
response.update({
"trades": [format_trade(trade) for trade in trades],
"orders": {
"buys": [format_order(order) for order in orders_buys],
"sells": [format_order(order) for order in orders_sells]
}
})
if user:
my_trades = await get_trades(token, user)
my_funds = await get_transfers(token, user)
my_orders_buys = await get_orders(
ZERO_ADDR,
token,
user_hexstr=user,
state=OrderState.OPEN.name,
sort="(amount_give / amount_get) DESC",
expires_after=current_block)
my_orders_sells = await get_orders(
token,
ZERO_ADDR,
user_hexstr=user,
state=OrderState.OPEN.name,
sort="(amount_get / amount_give) ASC",
expires_after=current_block)
response.update({
"myTrades": [format_trade(trade) for trade in my_trades],
"myFunds":
[format_transfer(transfer) for transfer in my_funds],
"myOrders": {
"buys": [format_order(order) for order in my_orders_buys],
"sells":
[format_order(order) for order in my_orders_sells]
}
})
await sio.emit('market', response, room=sid)
def get_my_sites(request, data):
# verify information
if not Web3.isAddress(data["trainer_address"]):
log.warn("send_to_address_invalid|data=%s", data)
return api_response_result(request, ResultCode.ERROR_PARAMS, {"error_message": "invald_send_to_address"})
trainer_address = data["trainer_address"].lower()
response_data = {
"total_balance": {
"eth_amount": 0,
"emont_amount": 0
},
"vote": {
"explore_eth_fee": 0.01,
"explore_emont_fee": 15,
"challenge_eth_fee": 0.01,
"challenge_emont_fee": 15
},
"sites": [],
"claimable_sites": []
}
response_data["vote"] = get_adventure_vote(trainer_address)
token_records = get_sites_by_trainer(trainer_address)
for record in token_records:
if record.token_id <= 1080:
name = get_adv_site_name(record.class_id, data["_client_language"])
image = get_adv_site_image_url(record.class_id)
desc = get_adv_site_description(record.class_id, data["_client_language"])
else:
name = ""
image = ""
desc = ""
eth_revenue, emont_revenue = get_site_token_balance(record.class_id, record.token_id)
eth_revenue = round(eth_revenue, 6)
emont_revenue = round(emont_revenue, 6)
response_data["total_balance"]["eth_amount"] += eth_revenue
response_data["total_balance"]["emont_amount"] += emont_revenue
response_data["sites"].append({
"token_id": record.token_id,
"owner": record.owner,
"item_class": record.class_id,
"item_value": record.value,
"image": image,
"name": name,
"desc": desc,
"eth_amount": eth_revenue,
"emont_amount": emont_revenue,
"total_visit": count_explore_by_site(record.class_id)
})
claimable_records = get_pending_claim_sites(trainer_address)
for claimable_record in claimable_records:
bid_price = claimable_record.bid_amount
if claimable_record.site_id < 53:
bid_price = bid_price * 1.0 / (10 ** 18)
else:
bid_price = bid_price * 1.0 / (10 ** 8)
response_data["claimable_sites"].append({
"site_id": claimable_record.site_id,
"site_index": claimable_record.site_index,
"bid_price": bid_price
})
return api_response_result(request, ResultCode.SUCCESS, response_data)
def checkAddressIsValid(address):
checkSumAddr = Web3.toChecksumAddress(address)
return Web3.isAddress(checkSumAddr)
def main():
if len(sys.argv) > 1 and sys.argv[1] in ('help', '-h', '--help'):
print("""
Usage:
step 1: ctl.py init_account - initializes new account to use for minting
step 1.1: * send ether to and periodically refill balance of minting account
step 2: ctl.py deploy_contract <token_address> - deploy ReenterableMinter contract needed for minting
step 2.1: * make sure deployed ReenterableMinter contract have permissions to mint token
step 3: * use wsgi_app:app as a WSGI app (to mint and check minting status)
step 4: ctl.py recover_ether <address_to_send_ether_to> - recover ether remaining on minting account
""".strip())
sys.exit(0)
if len(sys.argv) > 1 and 'init_account' == sys.argv[1]:
logging.basicConfig(level=logging.INFO)
try:
print('Generated new account: {}'.format(
MinterService(conf_filename,
contracts_directory).init_account()))
except UsageError as exc:
_fatal('{}', exc.message)
elif len(sys.argv) > 1 and 'deploy_contract' == sys.argv[1]:
logging.basicConfig(level=logging.INFO)
if len(sys.argv) != 3:
_fatal('usage: {} deploy_contract <token_address>', sys.argv[0])
token_address = sys.argv[2]
if not Web3.isAddress(token_address):
_fatal('bad token address: {}', token_address)
try:
print('ReenterableMinter deployed at: {}'.format(
MinterService(
conf_filename,
contracts_directory).deploy_contract(token_address)))
except UsageError as exc:
_fatal('{}', exc.message)
elif len(sys.argv) > 1 and 'recover_ether' == sys.argv[1]:
logging.basicConfig(level=logging.INFO)
if len(sys.argv) != 3:
_fatal('usage: {} recover_ether <address_to_send_ether_to>',
sys.argv[0])
target_address = sys.argv[2]
if not Web3.isAddress(target_address):
_fatal('bad address: {}', target_address)
try:
tx_hash = MinterService(
conf_filename,
contracts_directory).recover_ether(target_address)
if tx_hash is None:
print("Nothing could be sent")
else:
print("Mined transaction: {}".format(tx_hash))
except UsageError as exc:
_fatal('{}', exc.message)
else:
_fatal('no command given, see {} help', sys.argv[0])
def is_address(addr):
return Web3.isAddress(addr)
def post(self):
post_data = request.get_json()
uuid = post_data.get('uuid')
created = post_data.get('created')
transfer_use = post_data.get('transfer_use')
transfer_amount = round(float(post_data.get('transfer_amount', 0)), 6)
transfer_random_key = post_data.get('transfer_random_key')
pin = post_data.get('pin')
nfc_serial_number = post_data.get('nfc_id')
user_id = post_data.get('user_id')
public_identifier = post_data.get('public_identifier')
transfer_account_id = post_data.get('transfer_account_id')
qr_data = post_data.get('qr_data')
if qr_data is not None:
qr_data = str(qr_data).strip(" ").strip("\t")
is_sending = post_data.get('is_sending', False)
authorised = False
if uuid:
existing_transfer = CreditTransfer.query.filter_by(
uuid=uuid).first()
if existing_transfer:
# We return a 201 here so that the client removes the uuid from the cache
response_object = {
'message': 'Transfer already in cache',
'data': {
'credit_transfer':
me_credit_transfer_schema.dump(existing_transfer).data,
}
}
return make_response(jsonify(response_object)), 201
if qr_data:
split_qr_data = qr_data.split('-')
if len(split_qr_data) == 1:
# No hyphen, so assume qr code encode the public serial number
counterparty_user = User.query.filter(
func.lower(User.public_serial_number) == func.lower(
qr_data)).first()
else:
user_id = int(split_qr_data[1])
counterparty_user = User.query.get(user_id)
if not counterparty_user:
response_object = {
'message': 'No such user for ID {}'.format(user_id),
'feedback': True,
}
return make_response(jsonify(response_object)), 400
if not is_sending:
transfer_amount = int(split_qr_data[0])
qr_hash = split_qr_data[2]
user_secret = counterparty_user.secret
if not check_for_any_valid_hash(transfer_amount,
user_secret, qr_hash):
response_object = {
'message': 'Invalid QR Code',
'feedback': True,
}
return make_response(jsonify(response_object)), 401
authorised = True
elif nfc_serial_number:
# We treat NFC serials differently because they're automatically authorised under the current version
counterparty_user = User.query.filter_by(
nfc_serial_number=nfc_serial_number).first()
authorised = True
if not counterparty_user:
response_object = {
'message':
'No such user for NFC serial number {}'.format(
nfc_serial_number),
'feedback':
True
}
return make_response(jsonify(response_object)), 400
else:
try:
counterparty_user = find_user_with_transfer_account_from_identifiers(
user_id, public_identifier, transfer_account_id)
except (NoTransferAccountError, UserNotFoundError) as e:
if not Web3.isAddress(public_identifier.strip(
'ethereum:')) or not is_sending:
response_object = {'message': str(e), 'feedback': True}
return make_response(jsonify(response_object)), 400
#We're sending directly to a blockchain address
return handle_transfer_to_blockchain_address(
transfer_amount,
g.user,
public_identifier.strip('ethereum:'),
transfer_use,
uuid=uuid)
if not counterparty_user:
response_object = {
'message': 'User not found',
'feedback': True
}
return make_response(jsonify(response_object)), 400
authorised = counterparty_user.verify_password(str(pin))
if is_sending:
authorised = True
if not authorised:
responseObject = {
'message': 'Not Authorised',
'feedback': True,
}
return make_response(jsonify(responseObject)), 401
if is_sending:
send_user = g.user
receive_user = counterparty_user
else:
send_user = counterparty_user
receive_user = g.user
if transfer_amount == 0 or transfer_amount > send_user.transfer_account.balance:
db.session.commit()
responseObject = {
'message': 'Insufficient funds',
'feedback': True,
}
return make_response(jsonify(responseObject)), 400
try:
transfer = make_payment_transfer(transfer_amount,
send_user,
receive_user,
transfer_use,
uuid=uuid)
except AccountNotApprovedError as e:
db.session.commit()
if e.is_sender is True:
responseObject = {
'message': "Sender is not approved",
'feedback': True,
}
return make_response(jsonify(responseObject)), 400
elif e.is_sender is False:
responseObject = {
'message': "Recipient is not approved",
'feedback': True,
}
return make_response(jsonify(responseObject)), 400
else:
responseObject = {
'message': "Account is not approved",
'feedback': True,
}
return make_response(jsonify(responseObject)), 400
except InsufficientBalanceError as e:
db.session.commit()
responseObject = {
'message': "Insufficient balance",
'feedback': True,
}
return make_response(jsonify(responseObject)), 400
if created:
try:
transfer.created = datetime.datetime.strptime(
created, "%Y-%m-%dT%H:%M:%S.%fz")
except ValueError as e:
pass
if is_sending:
push_user_transfer_confirmation(receive_user, transfer_random_key)
db.session.commit()
responseObject = {
'message': 'Payment Successful',
'first_name': counterparty_user.first_name,
'last_name': counterparty_user.last_name,
'feedback': True,
'data': {
'credit_transfer':
me_credit_transfer_schema.dump(transfer).data
}
}
return make_response(jsonify(responseObject)), 201
def __main__():
args = parser.parse_args()
provider = Web3.WebsocketProvider('wss://mainnet.infura.io/ws/')
# provider = Web3.HTTPProvider('https://mainnet.infura.io/')
# provider = Web3.IPCProvider()
w3 = Web3(provider)
if args.start_block:
start_block = args.start_block
else:
start_block = 0
if args.end_block:
end_block = args.end_block
else:
end_block = w3.eth.blockNumber
client = MongoClient()
dbnames = client.list_database_names()
if args.drop and args.database in dbnames:
if not args.skip_confirmation:
if not query_yes_no('Are you sure you want to drop existing DB: '+args.database, default='no'):
sys.exit()
client.drop_database(args.database)
db = client[args.database]
block_collection = db['blocks']
tx_collection = db['transactions']
txreceipt_collection = db['txreceipts']
filtered_addrs = []
if args.addr:
filtered_addrs += args.addr.split(',')
elif args.file:
filtered_addrs += open(args.file, 'r').read().split('\n')
filtered_addrs = [i.lower() for i in filtered_addrs if Web3.isAddress(i)]
bar = progressbar.ProgressBar(max_value=end_block-start_block)
tx_count = 0
for idx in range(start_block, end_block+1):
bar.update(idx-start_block)
block = w3.eth.getBlock(idx, full_transactions=True)
block_without_tx = block_to_dict(block)
if 'transactions' in block_without_tx:
del block_without_tx['transactions']
block_collection.insert_one(block_without_tx)
txs = block.transactions
lines = []
for n, tx in enumerate(txs):
if tx['to']:
to_matches = tx['to'].lower() in filtered_addrs
else:
to_matches = False
if tx['from']:
from_matches = tx['from'].lower() in filtered_addrs
else:
from_matches = False
if to_matches or from_matches or filtered_addrs == []:
# print('Found tx: %s'%tx['hash'].hex())
tx_collection.insert_one(tx_to_dict(tx))
tx_receipt = w3.eth.getTransactionReceipt(tx['hash'])
txreceipt_collection.insert_one(tx_to_dict(tx_receipt))
tx_count += 1
bar.finish()
txreceipt_collection.create_index('transactionHash')
logging.info('Finished importing %d txs from %d blocks'%(tx_count, end_block-start_block))
