def trades_post():
request = app.current_request
data = request.json_body
tradeData = {
"investorId": data["investorId"],
"tokenId": data["tokenId"],
"executionDate": data["executionDate"],
"expirationTimestampInSec": data["expirationTimestampInSec"],
"salt": data["salt"]
}
trade = Database.find_one("Trade", tradeData)
if trade: return toObject(trade)
tradeData['state'] = 0
Database.insert("Trade", tradeData)
trade = Database.find_one("Trade", tradeData)
data['id'] = trade['id']
for brokerId, ik, ek, nominalAmount in zip(data['brokers'],data['iks'],data['eks'],data['nominalAmounts']):
tradeBrokerData = {"tradeId": trade['id'],"brokerId": brokerId, "ik": ik, "ek": ek, "nominalAmount": nominalAmount}
tradeBroker = Database.find_one("TradeBroker", tradeBrokerData)
if tradeBroker: continue
tradeBrokerData['state'] = 0
Database.insert("TradeBroker", tradeBrokerData)
tradeBroker = Database.find_one("TradeBroker", tradeBrokerData)
# Socket, should be pushing to a message queue of some kind
r = passWithoutError(requests.post)(socket_uri + "trade-created", data=data)
return toObject(trade)
def test_find(self):
with patch.dict('os.environ', env):
Database.insert("User", {'name': 'tom'})
users = Database.find("User", {'name': 'tom'})
self.assertEqual(len(users), 1)
self.assertEqual(users[0]['name'], 'tom')
def test_update(self):
with patch.dict('os.environ', env):
Database.insert("User", {'name': 'tom'})
Database.update("User", [[('name','=','tom')]], {'name': 'tom2'})
user = Database.find_one("User", {'name': 'tom'})
self.assertEqual(user, None)
user = Database.find_one("User", {'name': 'tom2'})
self.assertEqual(user['name'], 'tom2')
def test_update_multiple_with_or(self):
with patch.dict('os.environ', env):
Database.insert("User", {'name': 'tom'})
Database.insert("User", {'name': 'tom2'})
Database.update("User", [[('name','=','tom')],[('name','=','tom2')]], {'name': 'tom3'})
user = Database.find_one("User", {'name': 'tom'})
self.assertEqual(user, None)
user = Database.find_one("User", {'name': 'tom2'})
self.assertEqual(user, None)
users = Database.find("User", {'name': 'tom3'})
self.assertEqual(len(users), 2)
self.assertEqual(users[0]['name'], 'tom3')
self.assertEqual(users[1]['name'], 'tom3')
def tokens_nav_update():
print('\n\n\n\n')
request = app.current_request
data = request.json_body
token = Database.find_one("Token", {"address": data["token"]})
time = data["time"]
executionDate = arrow.get(time).format('YYYY-MM-DD')
nav = Database.insert("NAVTimestamp", {
"tokenId": token['id'],
"price": data['value'],
"executionDate": executionDate
},
return_inserted=True)
# First need to collect the trades
print(token['id'])
trades = Database.find("Trade", {"state": 1, "tokenId": token["id"]})
print(trades)
# Need to go through each trade and get the NAV+price
supplyUpdate = 0
for trade in trades:
decryptedNominalAmount = Cryptor.decryptInput(
trade['nominalAmount'], trade['sk'])
amountInvested = int(decryptedNominalAmount.split(':')[1])
price = Cryptor.decryptInput(trade['price'], trade['sk'])
price = float(price)
print("amountInvested: ", amountInvested)
print("price: ", price)
effectiveNAV = (1.0 + float(price) / 100) * nav['price']
print("supplyUpdate", int(amountInvested * 1.0 / effectiveNAV))
# supplyUpdate += int(amountInvested * math.pow(10, token['decimals']) / nav['price'])
supplyUpdate += int(amountInvested *
math.pow(10, token['decimals']) / effectiveNAV)
tokenContract = Web3Helper.getContract("ETT.json", token['address'])
# Update trades to be ready for claiming
tradeQuery = [[('id', '=', t['id'])] for t in trades]
trades = Database.update("Trade",
tradeQuery, {'state': 4},
return_updated=True)
for trade in trades:
# Take funds
takeFunds(trade)
tx = Web3Helper.transact(
tokenContract,
'updateTotalSupply',
supplyUpdate,
'', # we are ignoring this for now
executionDate)
# tx = b''
print(tx.hex())
return toObject(nav)
def orders_post():
request = app.current_request
data = request.json_body
trades = data['trades']
order = {
"brokerId": request.user["id"],
"signature": data["signature"],
"tokenId": data["token"],
"salt": data["salt"],
"amount": data["amount"],
"executionDate": data["executionDate"],
"hash": data["hash"],
"state": 0
}
order = Database.insert("Order", order)
for orderHolding in data['orderHoldings']:
security = Database.find_one("Security", {"id": orderHolding["securityId"]}, insert=True)
amount = 1 if orderHolding["direction"] == "Buy" else -1
amount *= int(orderHolding["amount"])
orderHolding = {
"securityId": security["id"],
"orderId": order["id"],
"amount": amount,
"cost": int(orderHolding["cost"]) if "cost" in orderHolding else 0
}
orderHolding = Database.insert("OrderHolding", orderHolding, return_inserted=True)
for trade in trades:
Database.update("Trade", {"id": trade["id"]},{"sk": trade["sk"]})
orderTrade = {
"orderId": order["id"],
"tradeId": trade["id"]
}
orderTrade = Database.insert("OrderTrade", orderTrade, return_inserted=True)
return toObject(order)
def token_post_dividend(tokenId):
request = app.current_request
user = request.user
data = request.json_body
amount = data["amount"]
currency = data["currency"]
paymentDate = data["paymentDate"]
exDividendDate = data["exDividendDate"]
dividend = {
"amount": amount,
"tokenId": tokenId,
"currency": currency,
"paymentDate": paymentDate,
"exDividendDate": exDividendDate
}
dividend = Database.insert("Dividend", dividend, return_inserted=True)
return toObject(dividend)
def auth_signup():
request = app.current_request
data = request.json_body
email = data['email']
name = data['name']
password = data['password']
# addressLine1 = data['addressLine1']
# addressLine2 = data['addressLine2']
# city = data['city']
# postcode = data['postcode']
# country = data['country']
# juristiction = data['juristiction']
print(data)
role = data['role'] if 'role' in data else 'investor'
user = Database.find_one("User", {'email': email})
if not user:
password_hash = pbkdf2_sha256.hash(password)
user = Database.insert(
"User",
{
'name': name,
'email': email,
'password': password_hash,
'role': role,
# 'addressLine1': addressLine1,
# 'addressLine2': addressLine2,
# 'city': city,
# 'postcode': postcode,
# 'country': country,
# 'juristiction': juristiction,
'type': 'institutional',
},
return_inserted=True)
return toObject(user, [
'id', 'name', 'address', 'role', 'ik', 'spk', 'signature',
'truelayerAccountId'
])
def test_find_one(self):
with patch.dict('os.environ', env):
Database.insert("User", {'name': 'tom'})
user = Database.find_one("User", {'name': 'tom'})
self.assertEqual(user['name'], 'tom')
def test_insert(self):
with patch.dict('os.environ', env):
user = Database.insert("User", {'name': 'tom'}, return_inserted = True)
self.assertEqual(user['name'], 'tom')
def createToken(data):
owner = None
ownerId = data["ownerId"] if "ownerId" in data else None
if not ownerId:
owner = Database.find_one("User", {"address": Web3Helper.account()})
ownerId = owner["id"]
else:
owner = Database.find_one("User", {"id": ownerId})
if not owner: raise NotFoundError('No user found')
token_data = {
"fundId": data["fundId"],
"decimals": data["decimals"],
"symbol": data["symbol"],
"cutoffTime": int(data["cutoffTime"]),
"fee": int(data["fee"]),
"ownerId": ownerId,
"name": data["name"],
"totalSupply": data["initialAmount"],
"incomeCategory": data["incomeCategory"],
"minimumOrder": data["minimumOrder"],
"currency": data["minimumOrder"],
}
if "fundId" in data: token_data["fundId"] = data["fundId"]
# Check if a token with the same symbol already exists
symbolToken = Database.find_one("Token", {"symbol": token_data["symbol"]})
if (symbolToken): raise ForbiddenError("Already a token with this symbol")
token = Database.find_one("Token", token_data, insert=True)
tokenHoldings = Database.find_one(
"TokenHoldings", {
"tokenId": token['id'],
"executionDate": str(datetime.today().date())
},
insert=True)
if 'nav' in data:
# Create a NAV timestamp
executionDate = arrow.now().format('YYYY-MM-DD')
Database.insert(
"NAVTimestamp", {
"tokenId": token['id'],
"price": data['nav'],
"executionDate": executionDate
})
holdings = []
if 'holdings' in data:
for holding in data['holdings']:
# get the correct security
security = Database.find_one("Security",
{"symbol": holding["symbol"]})
if (security):
Database.update("Security", {"id": security["id"]}, {
"name": holding["name"],
"currency": holding["currency"],
"country": holding["country"],
"sector": holding["sector"],
"class": holding["class"]
})
else:
security = Database.find_one("Security", {
"symbol": holding["symbol"],
"name": holding["name"],
"currency": holding["currency"],
"country": holding["country"],
"sector": holding["sector"],
"class": holding["class"]
},
insert=True)
price = holding['price'] if 'price' in holding else '0'
securityTimestamp = Database.find_one('SecurityTimestamp', {
'securityId': security["id"],
'price': price
},
order_by='-createdAt',
insert=True)
tokenHolding = Database.find_one(
"TokenHolding", {
"securityId": security["id"],
"securityAmount": holding["amount"],
"tokenHoldingsId": tokenHoldings["id"]
},
insert=True)
holdings.append(tokenHolding)
holdingsString = createHoldingsString(holdings)
try:
tx = Web3Helper.transact(
token_factory_contract,
'createETT',
token_data["name"],
token_data["decimals"],
token_data["symbol"],
int(data["initialAmount"]),
holdingsString,
token_data["cutoffTime"],
token_data["fee"],
Web3Helper.toChecksumAddress(owner['address']),
)
print(tx.hex())
except Exception as e:
print(e)
pass
