async def get_transfer_count(request: RetrieveTransactionCountRequest,
startDate: Optional[datetime.datetime] = None,
endDate: Optional[datetime.datetime] = None):
startDate = request.startDate.replace(
tzinfo=None) if request.startDate else date_util.start_of_day()
endDate = request.endDate.replace(
tzinfo=None) if request.endDate else date_util.start_of_day(
dt=date_util.datetime_from_datetime(dt=startDate, days=1))
count = await notdManager.get_transfer_count(startDate=startDate,
endDate=endDate)
return RetrieveTransactionCountResponse(count=count)
async def get_collection_daily_activities(
self, address: str) -> List[CollectionDailyActivity]:
address = chain_util.normalize_address(address)
endDate = date_util.datetime_from_now()
startDate = date_util.datetime_from_datetime(dt=endDate, days=-90)
collectionActivities = await self.retriever.list_collections_activity(
fieldFilters=[
StringFieldFilter(
fieldName=CollectionHourlyActivityTable.c.address.key,
eq=address),
DateFieldFilter(
fieldName=CollectionHourlyActivityTable.c.date.key,
gte=startDate),
DateFieldFilter(
fieldName=CollectionHourlyActivityTable.c.date.key,
lt=endDate),
])
delta = datetime.timedelta(days=1)
collectionActivitiesPerDay = []
currentDate = startDate
while date_util.start_of_day(currentDate) <= date_util.start_of_day(
endDate):
saleCount = 0
totalValue = 0
transferCount = 0
minimumValue = 0
maximumValue = 0
for collectionActivity in collectionActivities:
if date_util.start_of_day(
currentDate) == date_util.start_of_day(
collectionActivity.date):
if collectionActivity.saleCount > 0:
saleCount += collectionActivity.saleCount
totalValue += collectionActivity.totalValue
minimumValue = min(
minimumValue, collectionActivity.minimumValue
) if minimumValue > 0 else collectionActivity.minimumValue
maximumValue = max(maximumValue,
collectionActivity.maximumValue)
transferCount += collectionActivity.transferCount
averageValue = totalValue / saleCount if saleCount > 0 else 0
collectionActivitiesPerDay.append(
CollectionDailyActivity(date=currentDate,
transferCount=transferCount,
saleCount=saleCount,
totalValue=totalValue,
minimumValue=minimumValue,
maximumValue=maximumValue,
averageValue=averageValue))
currentDate += delta
return collectionActivitiesPerDay
async def retrieve_random_transfer(
request: RetrieveRandomTransferRequest,
startDate: Optional[datetime.datetime] = None,
endDate: Optional[datetime.datetime] = None):
startDate = request.startDate.replace(
tzinfo=None) if request.startDate else date_util.start_of_day()
endDate = request.endDate.replace(
tzinfo=None) if request.endDate else date_util.start_of_day(
dt=date_util.datetime_from_datetime(dt=startDate, days=1))
randomTokenTransfer = await notdManager.retrieve_random_transfer(
startDate=startDate, endDate=endDate)
return RetrieveRandomTransferResponse(
transfer=(await responseBuilder.token_transfer_from_model(
tokenTransfer=randomTokenTransfer)))
async def retrieve_most_traded_token_transfer(
request: RetrieveMostTradedRequest,
startDate: Optional[datetime.datetime] = None,
endDate: Optional[datetime.datetime] = None):
startDate = request.startDate.replace(
tzinfo=None) if request.startDate else date_util.start_of_day()
endDate = request.endDate.replace(
tzinfo=None) if request.endDate else date_util.start_of_day(
dt=date_util.datetime_from_datetime(dt=startDate, days=1))
mostTradedToken = await notdManager.retrieve_most_traded_token_transfer(
startDate=startDate, endDate=endDate)
return RetrieveMostTradedResponse(
tradedToken=(await responseBuilder.traded_token_from_model(
tradedToken=mostTradedToken)))
async def update_activity_for_all_collections(self) -> None:
# TODO(femi-ogunkola): Account for deleted transactions
collectionActivity = await self.retriever.list_collections_activity(
orders=[
Order(fieldName=CollectionHourlyActivityTable.c.date.key,
direction=Direction.DESCENDING)
],
limit=1)
if len(collectionActivity) > 0:
lastestProcessedDate = collectionActivity[0].date
else:
lastestProcessedDate = date_util.start_of_day()
newTokenTransfers = await self.retriever.list_token_transfers(
fieldFilters=[
DateFieldFilter(fieldName=BlocksTable.c.updatedDate.key,
gte=lastestProcessedDate)
])
registryDatePairs = {(tokenTransfer.registryAddress,
date_hour_from_datetime(tokenTransfer.blockDate))
for tokenTransfer in newTokenTransfers}
logging.info(
f'Scheduling processing for {len(registryDatePairs)} collection, hour pairs'
)
messages = [
UpdateActivityForCollectionMessageContent(
address=address, startDate=startDate).to_message()
for (address, startDate) in registryDatePairs
]
await self.tokenQueue.send_messages(messages=messages)
async def get_collection_statistics(self,
address: str) -> CollectionStatistics:
address = chain_util.normalize_address(value=address)
startDate = date_util.start_of_day()
endDate = date_util.start_of_day(
dt=date_util.datetime_from_datetime(dt=startDate, days=1))
itemCount = len(
await self.retriever.list_token_metadatas(fieldFilters=[
StringFieldFilter(
fieldName=TokenMetadatasTable.c.registryAddress.key,
eq=address),
]))
holderCount = len(
await self.retriever.list_token_ownerships(fieldFilters=[
StringFieldFilter(
fieldName=TokenOwnershipsTable.c.registryAddress.key,
eq=address)
]))
allCollectionActivities = await self.retriever.list_collections_activity(
fieldFilters=[
StringFieldFilter(
fieldName=CollectionHourlyActivityTable.c.address.key,
eq=address)
])
totalTradeVolume = sum([
collectionActivity.totalValue
for collectionActivity in allCollectionActivities
])
dayCollectionActivities = await self.retriever.list_collections_activity(
fieldFilters=[
StringFieldFilter(
fieldName=CollectionHourlyActivityTable.c.address.key,
eq=address),
DateFieldFilter(
fieldName=CollectionHourlyActivityTable.c.date.key,
gte=startDate,
lt=endDate),
])
saleCount = 0
transferCount = 0
tradeVolume24Hours = 0
lowestSaleLast24Hours = 0
highestSaleLast24Hours = 0
for collectionActivity in dayCollectionActivities:
saleCount += collectionActivity.saleCount
tradeVolume24Hours += collectionActivity.totalValue
lowestSaleLast24Hours = min(
lowestSaleLast24Hours, collectionActivity.minimumValue
) if lowestSaleLast24Hours > 0 else collectionActivity.minimumValue
highestSaleLast24Hours = max(highestSaleLast24Hours,
collectionActivity.maximumValue)
transferCount += collectionActivity.transferCount
return CollectionStatistics(
itemCount=itemCount,
holderCount=holderCount,
saleCount=saleCount,
transferCount=transferCount,
totalTradeVolume=totalTradeVolume,
lowestSaleLast24Hours=lowestSaleLast24Hours,
highestSaleLast24Hours=highestSaleLast24Hours,
tradeVolume24Hours=tradeVolume24Hours,
)