diff --git a/backend/moonstream/api.py b/backend/moonstream/api.py index 122bf309..15bf4f4a 100644 --- a/backend/moonstream/api.py +++ b/backend/moonstream/api.py @@ -3,28 +3,71 @@ The Moonstream HTTP API """ import logging import time +from typing import Dict from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from . import actions from . import data -from .middleware import MoonstreamHTTPException -from .routes.address_info import app as addressinfo_api -from .routes.nft import app as nft_api -from .routes.whales import app as whales_api -from .routes.subscriptions import app as subscriptions_api -from .routes.streams import app as streams_api -from .routes.txinfo import app as txinfo_api -from .routes.users import app as users_api -from .settings import ORIGINS +from .routes.address_info import router as addressinfo_router +from .routes.nft import router as nft_router +from .routes.streams import router as streams_router +from .routes.subscriptions import router as subscriptions_router +from .routes.txinfo import router as txinfo_router +from .routes.users import router as users_router +from .routes.whales import router as whales_router +from .middleware import BroodAuthMiddleware, MoonstreamHTTPException +from .settings import DOCS_TARGET_PATH, ORIGINS from .version import MOONSTREAM_VERSION logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) -app = FastAPI(openapi_url=None) +tags_metadata = [ + {"name": "addressinfo", "description": "Blockchain addresses public information."}, + { + "name": "labels", + "description": "Labels for transactions, addresses with additional information.", + }, + {"name": "nft", "description": "NFT market summaries."}, + {"name": "streams", "description": "Operations with data streams and filters."}, + {"name": "subscriptions", "description": "Operations with user subscriptions."}, + {"name": "time", "description": "Server timestamp endpoints."}, + {"name": "tokens", "description": "Operations with user tokens."}, + {"name": "txinfo", "description": "Ethereum transactions info."}, + {"name": "users", "description": "Operations with users."}, + {"name": "whales", "description": "Whales summaries"}, +] + +app = FastAPI( + title=f"Moonstream API", + description="Moonstream API endpoints.", + version=MOONSTREAM_VERSION, + openapi_tags=tags_metadata, + openapi_url="/openapi.json", + docs_url=None, + redoc_url=f"/{DOCS_TARGET_PATH}", +) + +whitelist_paths: Dict[str, str] = {} +whitelist_paths.update( + { + "/ping": "GET", + "/version": "GET", + "/now": "GET", + "/docs": "GET", + "/openapi.json": "GET", + "/streams/info": "GET", + "/subscriptions/types": "GET", + "/users": "POST", + "/users/token": "POST", + "/users/password/reset_initiate": "POST", + "/users/password/reset_complete": "POST", + } +) +app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) app.add_middleware( CORSMiddleware, allow_origins=ORIGINS, @@ -36,23 +79,32 @@ app.add_middleware( @app.get("/ping", response_model=data.PingResponse) async def ping_handler() -> data.PingResponse: + """ + Check server status. + """ return data.PingResponse(status="ok") @app.get("/version", response_model=data.VersionResponse) async def version_handler() -> data.VersionResponse: + """ + Get server version. + """ return data.VersionResponse(version=MOONSTREAM_VERSION) @app.get("/now", tags=["time"]) async def now_handler() -> data.NowResponse: + """ + Get server current time. + """ return data.NowResponse(epoch_time=time.time()) @app.get("/status", response_model=data.StatusResponse) async def status_handler() -> data.StatusResponse: """ - Get latest records and their creation timestamp for crawlers: + Find latest crawlers records with creation timestamp: - ethereum_txpool - ethereum_trending """ @@ -70,10 +122,10 @@ async def status_handler() -> data.StatusResponse: ) -app.mount("/subscriptions", subscriptions_api) -app.mount("/users", users_api) -app.mount("/streams", streams_api) -app.mount("/txinfo", txinfo_api) -app.mount("/address_info", addressinfo_api) -app.mount("/nft", nft_api) -app.mount("/whales", whales_api) +app.include_router(addressinfo_router) +app.include_router(nft_router) +app.include_router(streams_router) +app.include_router(subscriptions_router) +app.include_router(txinfo_router) +app.include_router(users_router) +app.include_router(whales_router) diff --git a/backend/moonstream/middleware.py b/backend/moonstream/middleware.py index 5e089aa6..4fa84a2f 100644 --- a/backend/moonstream/middleware.py +++ b/backend/moonstream/middleware.py @@ -4,7 +4,6 @@ from typing import Any, Awaitable, Callable, Dict, Optional from bugout.data import BugoutUser from bugout.exceptions import BugoutResponseException from fastapi import HTTPException, Request, Response -from starlette.background import BackgroundTask from starlette.middleware.base import BaseHTTPMiddleware from .reporter import reporter diff --git a/backend/moonstream/routes/address_info.py b/backend/moonstream/routes/address_info.py index a2bcbf65..49c0fb78 100644 --- a/backend/moonstream/routes/address_info.py +++ b/backend/moonstream/routes/address_info.py @@ -1,50 +1,22 @@ import logging -from typing import Dict, List, Optional +from typing import Optional -from sqlalchemy.sql.expression import true - -from fastapi import FastAPI, Depends, Query -from fastapi.middleware.cors import CORSMiddleware +from fastapi import APIRouter, Depends, Query from moonstreamdb.db import yield_db_session from sqlalchemy.orm import Session from .. import actions from .. import data -from ..middleware import BroodAuthMiddleware, MoonstreamHTTPException -from ..settings import DOCS_TARGET_PATH, ORIGINS, DOCS_PATHS -from ..version import MOONSTREAM_VERSION +from ..middleware import MoonstreamHTTPException logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "addressinfo", "description": "Address public information."}, - {"name": "labels", "description": "Addresses label information."}, -] - -app = FastAPI( - title=f"Moonstream users API.", - description="User, token and password handlers.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", +router = APIRouter( + prefix="/address_info", ) -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) -whitelist_paths: Dict[str, str] = {} -whitelist_paths.update(DOCS_PATHS) -app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) - - -@app.get( +@router.get( "/ethereum_blockchain", tags=["addressinfo"], response_model=data.EthereumAddressInfo, @@ -61,9 +33,9 @@ async def addressinfo_handler( return response -@app.get( +@router.get( "/labels/ethereum_blockchain", - tags=["labels bul"], + tags=["labels"], response_model=data.AddressListLabelsResponse, ) async def addresses_labels_bulk_handler( diff --git a/backend/moonstream/routes/nft.py b/backend/moonstream/routes/nft.py index c5eda166..9ad48e2e 100644 --- a/backend/moonstream/routes/nft.py +++ b/backend/moonstream/routes/nft.py @@ -3,55 +3,29 @@ Moonstream's /nft endpoints. These endpoints provide public access to NFT market summaries. No authentication required. """ -from datetime import datetime import logging from typing import Optional -from bugout.data import BugoutResource - -from fastapi import Depends, FastAPI, Query -from moonstreamdb import db +from fastapi import APIRouter, Depends, Query from fastapi.middleware.cors import CORSMiddleware +from moonstreamdb import db from sqlalchemy.orm import Session from .. import data from ..providers.bugout import nft_summary_provider from ..settings import ( bugout_client, - DOCS_TARGET_PATH, MOONSTREAM_ADMIN_ACCESS_TOKEN, MOONSTREAM_DATA_JOURNAL_ID, - ORIGINS, ) from ..stream_queries import StreamQuery -from ..version import MOONSTREAM_VERSION logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "nft", "description": "NFT market summaries"}, -] - -app = FastAPI( - title=f"Moonstream /nft API", - description="User, token and password handlers.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", -) - -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) +router = APIRouter(prefix="/nft") -@app.get("/", tags=["streams"], response_model=data.GetEventsResponse) +@router.get("/", tags=["streams"], response_model=data.GetEventsResponse) async def stream_handler( start_time: int = Query(0), end_time: Optional[int] = Query(None), diff --git a/backend/moonstream/routes/streams.py b/backend/moonstream/routes/streams.py index 14fab19e..8e592329 100644 --- a/backend/moonstream/routes/streams.py +++ b/backend/moonstream/routes/streams.py @@ -5,14 +5,12 @@ import logging from typing import Any, Dict, List, Optional from bugout.data import BugoutResource -from fastapi import FastAPI, Request, Query, Depends -from fastapi.middleware.cors import CORSMiddleware +from fastapi import APIRouter, Request, Query, Depends from moonstreamdb import db from sqlalchemy.orm import Session - from .. import data -from ..middleware import BroodAuthMiddleware, MoonstreamHTTPException +from ..middleware import MoonstreamHTTPException from ..providers import ( ReceivingEventsException, event_providers, @@ -22,47 +20,20 @@ from ..providers import ( previous_event, ) from ..settings import ( - DOCS_TARGET_PATH, MOONSTREAM_ADMIN_ACCESS_TOKEN, MOONSTREAM_DATA_JOURNAL_ID, - ORIGINS, - DOCS_PATHS, bugout_client as bc, BUGOUT_REQUEST_TIMEOUT_SECONDS, ) from .. import stream_queries from .subscriptions import BUGOUT_RESOURCE_TYPE_SUBSCRIPTION -from ..version import MOONSTREAM_VERSION logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "streams", "description": "Operations with data stream and filters."}, -] - -app = FastAPI( - title=f"Moonstream streams API.", - description="Streams endpoints.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", +router = APIRouter( + prefix="/streams", ) -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) - -whitelist_paths: Dict[str, str] = {"/streams/info": "GET"} -whitelist_paths.update(DOCS_PATHS) -whitelist_paths.update() -app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) - def get_user_subscriptions(token: str) -> Dict[str, List[BugoutResource]]: """ @@ -89,7 +60,7 @@ def get_user_subscriptions(token: str) -> Dict[str, List[BugoutResource]]: return user_subscriptions -@app.get("/info", tags=["streams"]) +@router.get("/info", tags=["streams"]) async def info_handler() -> Dict[str, Any]: info = { event_type: { @@ -102,7 +73,7 @@ async def info_handler() -> Dict[str, Any]: return info -@app.get("/", tags=["streams"], response_model=data.GetEventsResponse) +@router.get("/", tags=["streams"], response_model=data.GetEventsResponse) async def stream_handler( request: Request, q: str = Query(""), @@ -159,7 +130,7 @@ async def stream_handler( return response -@app.get("/latest", tags=["streams"]) +@router.get("/latest", tags=["streams"]) async def latest_events_handler( request: Request, q=Query(""), db_session: Session = Depends(db.yield_db_session) ) -> List[data.Event]: @@ -201,7 +172,7 @@ async def latest_events_handler( return events -@app.get("/next", tags=["stream"]) +@router.get("/next", tags=["stream"]) async def next_event_handler( request: Request, q: str = Query(""), @@ -256,7 +227,7 @@ async def next_event_handler( return event -@app.get("/previous", tags=["stream"]) +@router.get("/previous", tags=["stream"]) async def previous_event_handler( request: Request, q: str = Query(""), diff --git a/backend/moonstream/routes/subscriptions.py b/backend/moonstream/routes/subscriptions.py index b76887e3..18b6fd5f 100644 --- a/backend/moonstream/routes/subscriptions.py +++ b/backend/moonstream/routes/subscriptions.py @@ -2,60 +2,31 @@ The Moonstream subscriptions HTTP API """ import logging -from typing import Dict, List, Optional +from typing import List, Optional from bugout.data import BugoutResource, BugoutResources from bugout.exceptions import BugoutResponseException -from fastapi import FastAPI, Request, Form -from fastapi.middleware.cors import CORSMiddleware +from fastapi import APIRouter, Request, Form from ..admin import subscription_types from .. import data -from ..middleware import BroodAuthMiddleware, MoonstreamHTTPException +from ..middleware import MoonstreamHTTPException from ..reporter import reporter from ..settings import ( - DOCS_TARGET_PATH, - DOCS_PATHS, MOONSTREAM_APPLICATION_ID, - ORIGINS, bugout_client as bc, ) -from ..version import MOONSTREAM_VERSION logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "subscriptions", "description": "Operations with subscriptions."}, -] - -app = FastAPI( - title=f"Moonstream subscriptions API.", - description="User subscriptions endpoints.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", +router = APIRouter( + prefix="/subscriptions", ) -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) - -whitelist_paths: Dict[str, str] = {} -whitelist_paths.update(DOCS_PATHS) -whitelist_paths.update({"/subscriptions/types": "GET"}) -app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) - - BUGOUT_RESOURCE_TYPE_SUBSCRIPTION = "subscription" -@app.post("/", tags=["subscriptions"], response_model=data.SubscriptionResourceData) +@router.post("/", tags=["subscriptions"], response_model=data.SubscriptionResourceData) async def add_subscription_handler( request: Request, # subscription_data: data.CreateSubscriptionRequest = Body(...) address: str = Form(...), @@ -118,7 +89,7 @@ async def add_subscription_handler( ) -@app.delete( +@router.delete( "/{subscription_id}", tags=["subscriptions"], response_model=data.SubscriptionResourceData, @@ -148,7 +119,7 @@ async def delete_subscription_handler(request: Request, subscription_id: str): ) -@app.get("/", tags=["subscriptions"], response_model=data.SubscriptionsListResponse) +@router.get("/", tags=["subscriptions"], response_model=data.SubscriptionsListResponse) async def get_subscriptions_handler(request: Request) -> data.SubscriptionsListResponse: """ Get user's subscriptions. @@ -186,7 +157,7 @@ async def get_subscriptions_handler(request: Request) -> data.SubscriptionsListR ) -@app.put( +@router.put( "/{subscription_id}", tags=["subscriptions"], response_model=data.SubscriptionResourceData, @@ -236,7 +207,7 @@ async def update_subscriptions_handler( ) -@app.get( +@router.get( "/types", tags=["subscriptions"], response_model=data.SubscriptionTypesListResponse ) async def list_subscription_types() -> data.SubscriptionTypesListResponse: diff --git a/backend/moonstream/routes/txinfo.py b/backend/moonstream/routes/txinfo.py index 9178adc5..c840c360 100644 --- a/backend/moonstream/routes/txinfo.py +++ b/backend/moonstream/routes/txinfo.py @@ -6,54 +6,24 @@ transactions, etc.) with side information and return objects that are better sui end users. """ import logging -from typing import Dict, Optional +from typing import Optional -from fastapi import FastAPI, Depends -from fastapi.middleware.cors import CORSMiddleware +from fastapi import APIRouter, Depends from moonstreamdb.db import yield_db_session -from moonstreamdb.models import EthereumAddress from sqlalchemy.orm import Session from ..abi_decoder import decode_abi from .. import actions from .. import data -from ..middleware import BroodAuthMiddleware -from ..settings import DOCS_TARGET_PATH, ORIGINS, DOCS_PATHS -from ..version import MOONSTREAM_VERSION logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "txinfo", "description": "Ethereum transactions info."}, -] - -app = FastAPI( - title=f"Moonstream /txinfo API.", - description="User, token and password handlers.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", -) - -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) - -whitelist_paths: Dict[str, str] = {} -whitelist_paths.update(DOCS_PATHS) -app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) - +router = APIRouter(prefix="/txinfo") # TODO(zomglings): Factor out the enrichment logic into a separate action, because it may be useful # independently from serving API calls (e.g. data processing). # TODO(kompotkot): Re-organize function to be able handle each steps with exceptions. -@app.post( +@router.post( "/ethereum_blockchain", tags=["txinfo"], response_model=data.TxinfoEthereumBlockchainResponse, diff --git a/backend/moonstream/routes/users.py b/backend/moonstream/routes/users.py index 237f031e..acd8c328 100644 --- a/backend/moonstream/routes/users.py +++ b/backend/moonstream/routes/users.py @@ -8,66 +8,28 @@ import uuid from bugout.data import BugoutToken, BugoutUser, BugoutResource, BugoutUserTokens from bugout.exceptions import BugoutResponseException from fastapi import ( + APIRouter, Body, - FastAPI, Form, Request, ) -from fastapi.middleware.cors import CORSMiddleware from .. import data -from ..middleware import BroodAuthMiddleware, MoonstreamHTTPException +from ..middleware import MoonstreamHTTPException from ..settings import ( MOONSTREAM_APPLICATION_ID, - DOCS_TARGET_PATH, - ORIGINS, - DOCS_PATHS, bugout_client as bc, BUGOUT_REQUEST_TIMEOUT_SECONDS, ) -from ..version import MOONSTREAM_VERSION from ..actions import create_onboarding_resource logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "users", "description": "Operations with users."}, - {"name": "tokens", "description": "Operations with user tokens."}, -] - -app = FastAPI( - title=f"Moonstream users API.", - description="User, token and password handlers.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", -) - -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) - -whitelist_paths: Dict[str, str] = {} -whitelist_paths.update(DOCS_PATHS) -whitelist_paths.update( - { - "/users": "POST", - "/users/token": "POST", - "/users/password/reset_initiate": "POST", - "/users/password/reset_complete": "POST", - } -) -app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) +router = APIRouter(prefix="/users") -@app.post("/", tags=["users"], response_model=BugoutUser) +@router.post("/", tags=["users"], response_model=BugoutUser) async def create_user_handler( username: str = Form(...), email: str = Form(...), password: str = Form(...) ) -> BugoutUser: @@ -85,13 +47,13 @@ async def create_user_handler( return user -@app.get("/", tags=["users"], response_model=BugoutUser) +@router.get("/", tags=["users"], response_model=BugoutUser) async def get_user_handler(request: Request) -> BugoutUser: user: BugoutUser = request.state.user return user -@app.post("/password/reset_initiate", tags=["users"], response_model=Dict[str, Any]) +@router.post("/password/reset_initiate", tags=["users"], response_model=Dict[str, Any]) async def restore_password_handler(email: str = Form(...)) -> Dict[str, Any]: try: response = bc.restore_password(email=email) @@ -102,7 +64,7 @@ async def restore_password_handler(email: str = Form(...)) -> Dict[str, Any]: return response -@app.post("/password/reset_complete", tags=["users"], response_model=BugoutUser) +@router.post("/password/reset_complete", tags=["users"], response_model=BugoutUser) async def reset_password_handler( reset_id: str = Form(...), new_password: str = Form(...) ) -> BugoutUser: @@ -115,7 +77,7 @@ async def reset_password_handler( return response -@app.post("/password/change", tags=["users"], response_model=BugoutUser) +@router.post("/password/change", tags=["users"], response_model=BugoutUser) async def change_password_handler( request: Request, current_password: str = Form(...), new_password: str = Form(...) ) -> BugoutUser: @@ -131,7 +93,7 @@ async def change_password_handler( return user -@app.delete("/", tags=["users"], response_model=BugoutUser) +@router.delete("/", tags=["users"], response_model=BugoutUser) async def delete_user_handler( request: Request, password: str = Form(...) ) -> BugoutUser: @@ -146,7 +108,7 @@ async def delete_user_handler( return user -@app.post("/token", tags=["tokens"], response_model=BugoutToken) +@router.post("/token", tags=["tokens"], response_model=BugoutToken) async def login_handler( username: str = Form(...), password: str = Form(...), @@ -167,7 +129,7 @@ async def login_handler( return token -@app.get("/tokens", tags=["tokens"], response_model=BugoutUserTokens) +@router.get("/tokens", tags=["tokens"], response_model=BugoutUserTokens) async def tokens_handler(request: Request) -> BugoutUserTokens: token = request.state.token try: @@ -181,9 +143,9 @@ async def tokens_handler(request: Request) -> BugoutUserTokens: return response -@app.put("/token", tags=["tokens"], response_model=BugoutToken) +@router.put("/token", tags=["tokens"], response_model=BugoutToken) async def token_update_handler( - request: Request, token_note: str = Form(...), access_token: str = Form(...) + token_note: str = Form(...), access_token: str = Form(...) ) -> BugoutToken: try: response = bc.update_token(token=access_token, token_note=token_note) @@ -194,7 +156,7 @@ async def token_update_handler( return response -@app.post("/revoke/{access_token}", tags=["tokens"], response_model=uuid.UUID) +@router.post("/revoke/{access_token}", tags=["tokens"], response_model=uuid.UUID) async def delete_token_by_id_handler( request: Request, access_token: uuid.UUID ) -> uuid.UUID: @@ -212,7 +174,7 @@ async def delete_token_by_id_handler( return response -@app.delete("/token", tags=["tokens"], response_model=uuid.UUID) +@router.delete("/token", tags=["tokens"], response_model=uuid.UUID) async def logout_handler(request: Request) -> uuid.UUID: token = request.state.token try: @@ -224,7 +186,7 @@ async def logout_handler(request: Request) -> uuid.UUID: return token_id -@app.post("/onboarding", tags=["users"], response_model=data.OnboardingState) +@router.post("/onboarding", tags=["users"], response_model=data.OnboardingState) async def set_onboarding_state( request: Request, onboarding_data: data.OnboardingState = Body(...), @@ -270,7 +232,7 @@ async def set_onboarding_state( return result -@app.get("/onboarding", tags=["users"], response_model=data.OnboardingState) +@router.get("/onboarding", tags=["users"], response_model=data.OnboardingState) async def get_onboarding_state(request: Request) -> data.OnboardingState: token = request.state.token try: @@ -305,7 +267,7 @@ async def get_onboarding_state(request: Request) -> data.OnboardingState: return result -@app.delete("/onboarding", tags=["users"], response_model=data.OnboardingState) +@router.delete("/onboarding", tags=["users"], response_model=data.OnboardingState) async def delete_onboarding_state(request: Request) -> data.OnboardingState: token = request.state.token try: diff --git a/backend/moonstream/routes/whales.py b/backend/moonstream/routes/whales.py index 2c089f4c..56d8a5f8 100644 --- a/backend/moonstream/routes/whales.py +++ b/backend/moonstream/routes/whales.py @@ -3,55 +3,28 @@ Moonstream's /whales endpoints. These endpoints provide public access to whale watch summaries. No authentication required. """ -from datetime import datetime import logging from typing import Optional -from bugout.data import BugoutResource - -from fastapi import Depends, FastAPI, Query +from fastapi import APIRouter, Depends, Query from moonstreamdb import db -from fastapi.middleware.cors import CORSMiddleware from sqlalchemy.orm import Session from .. import data from ..providers.bugout import whalewatch_provider from ..settings import ( bugout_client, - DOCS_TARGET_PATH, MOONSTREAM_ADMIN_ACCESS_TOKEN, MOONSTREAM_DATA_JOURNAL_ID, - ORIGINS, ) from ..stream_queries import StreamQuery -from ..version import MOONSTREAM_VERSION logger = logging.getLogger(__name__) -tags_metadata = [ - {"name": "whales", "description": "Whales summaries"}, -] - -app = FastAPI( - title=f"Moonstream /whales API", - description="User, token and password handlers.", - version=MOONSTREAM_VERSION, - openapi_tags=tags_metadata, - openapi_url="/openapi.json", - docs_url=None, - redoc_url=f"/{DOCS_TARGET_PATH}", -) - -app.add_middleware( - CORSMiddleware, - allow_origins=ORIGINS, - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) +router = APIRouter(prefix="/whales") -@app.get("/", tags=["whales"], response_model=data.GetEventsResponse) +@router.get("/", tags=["whales"], response_model=data.GetEventsResponse) async def stream_handler( start_time: int = Query(0), end_time: Optional[int] = Query(None), diff --git a/backend/moonstream/settings.py b/backend/moonstream/settings.py index d18bb852..982229e4 100644 --- a/backend/moonstream/settings.py +++ b/backend/moonstream/settings.py @@ -34,15 +34,6 @@ ORIGINS = RAW_ORIGINS.split(",") # OpenAPI DOCS_TARGET_PATH = "docs" -MOONSTREAM_OPENAPI_LIST = [] -MOONSTREAM_OPENAPI_LIST_RAW = os.environ.get("MOONSTREAM_OPENAPI_LIST") -if MOONSTREAM_OPENAPI_LIST_RAW is not None: - MOONSTREAM_OPENAPI_LIST = MOONSTREAM_OPENAPI_LIST_RAW.split(",") - -DOCS_PATHS = {} -for path in MOONSTREAM_OPENAPI_LIST: - DOCS_PATHS[f"/{path}/{DOCS_TARGET_PATH}"] = "GET" - DOCS_PATHS[f"/{path}/{DOCS_TARGET_PATH}/openapi.json"] = "GET" DEFAULT_STREAM_TIMEINTERVAL = 5 * 60 diff --git a/backend/sample.env b/backend/sample.env index 6c44a369..2f994334 100644 --- a/backend/sample.env +++ b/backend/sample.env @@ -1,5 +1,4 @@ export MOONSTREAM_CORS_ALLOWED_ORIGINS="http://localhost:3000,https://moonstream.to,https://www.moonstream.to" -export MOONSTREAM_OPENAPI_LIST="users,subscriptions,txinfo" export MOONSTREAM_APPLICATION_ID="" export MOONSTREAM_DATA_JOURNAL_ID="" export MOONSTREAM_DB_URI="postgresql://:@:/" diff --git a/crawlers/deploy/deploy.bash b/crawlers/deploy/deploy.bash index 1f038ce5..2aa1d355 100755 --- a/crawlers/deploy/deploy.bash +++ b/crawlers/deploy/deploy.bash @@ -14,7 +14,6 @@ PARAMETERS_ENV_PATH="${SECRETS_DIR}/app.env" AWS_SSM_PARAMETER_PATH="${AWS_SSM_PARAMETER_PATH:-/moonstream/prod}" SCRIPT_DIR="$(realpath $(dirname $0))" PARAMETERS_SCRIPT="${SCRIPT_DIR}/parameters.py" -ETHEREUM_GETH_SERVICE="ethereum-node.service" ETHEREUM_SYNCHRONIZE_SERVICE="ethereum-synchronize.service" ETHEREUM_TRENDING_SERVICE="ethereum-trending.service" ETHEREUM_TRENDING_TIMER="ethereum-trending.service" @@ -51,22 +50,6 @@ echo "Retrieving deployment parameters" mkdir -p "${SECRETS_DIR}" AWS_DEFAULT_REGION="${AWS_DEFAULT_REGION}" "${PYTHON}" "${PARAMETERS_SCRIPT}" extract -p "${AWS_SSM_PARAMETER_PATH}" -o "${PARAMETERS_ENV_PATH}" -echo -echo -echo "Deploy Geth service if not running already" -if systemctl is-active --quiet "${ETHEREUM_GETH_SERVICE}" -then - echo "Ethereum Geth service ${ETHEREUM_GETH_SERVICE} already running" -else - echo "Replacing Ethereum Geth service definition with ${ETHEREUM_GETH_SERVICE}" - chmod 644 "${SCRIPT_DIR}/${ETHEREUM_GETH_SERVICE}" - cp "${SCRIPT_DIR}/${ETHEREUM_GETH_SERVICE}" "/etc/systemd/system/${ETHEREUM_GETH_SERVICE}" - systemctl daemon-reload - systemctl disable "${ETHEREUM_GETH_SERVICE}" - systemctl restart "${ETHEREUM_GETH_SERVICE}" - sleep 10 -fi - echo echo echo "Replacing existing Ethereum block with transactions syncronizer service definition with ${ETHEREUM_SYNCHRONIZE_SERVICE}" diff --git a/crawlers/deploy/ethereum-node.service b/crawlers/deploy/ethereum-node.service deleted file mode 100644 index 4c22b89d..00000000 --- a/crawlers/deploy/ethereum-node.service +++ /dev/null @@ -1,16 +0,0 @@ -[Unit] -Description=Ethereum node Geth client -After=network.target - -[Service] -User=ubuntu -Group=www-data -ExecStart=/usr/bin/geth --syncmode full \ - --port 41381 --datadir /mnt/disks/nodes/ethereum \ - --txpool.globalslots 450000 --txpool.globalqueue 50000 \ - --http --http.port 18375 --http.api eth,web3,txpool -ExecStop=/bin/kill -s SIGINT -$MAINPID -SyslogIdentifier=ethereum-node - -[Install] -WantedBy=multi-user.target \ No newline at end of file diff --git a/crawlers/mooncrawl/mooncrawl/ethcrawler.py b/crawlers/mooncrawl/mooncrawl/ethcrawler.py index 48c396d9..373612a2 100644 --- a/crawlers/mooncrawl/mooncrawl/ethcrawler.py +++ b/crawlers/mooncrawl/mooncrawl/ethcrawler.py @@ -97,20 +97,6 @@ def ethcrawler_blocks_sync_handler(args: argparse.Namespace) -> None: if latest_stored_block_number is None: latest_stored_block_number = 0 - block_number_difference = latest_block_number - 1 - latest_stored_block_number - - if args.start is None: - if block_number_difference < args.confirmations: - logger.info( - f"Synchronization is unnecessary for blocks {latest_stored_block_number}-{latest_block_number - 1}" - ) - time.sleep(5) - continue - else: - bottom_block_number = latest_block_number - args.confirmations - else: - bottom_block_number = max(latest_stored_block_number + 1, args.start) - if latest_stored_block_number >= latest_block_number: logger.info( f"Synchronization is unnecessary for blocks {latest_stored_block_number}-{latest_block_number - 1}" @@ -118,6 +104,25 @@ def ethcrawler_blocks_sync_handler(args: argparse.Namespace) -> None: time.sleep(5) continue + block_number_difference = latest_block_number - 1 - latest_stored_block_number + if block_number_difference >= 70: + logger.warning( + f"Block difference is too large: {block_number_difference}, crawling {args.confirmations + 1} latest blocks" + ) + bottom_block_number = latest_block_number - args.confirmations - 1 + else: + if args.start is None: + if block_number_difference < args.confirmations: + logger.info( + f"Synchronization is unnecessary for blocks {latest_stored_block_number}-{latest_block_number - 1}" + ) + time.sleep(5) + continue + else: + bottom_block_number = latest_stored_block_number + 1 + else: + bottom_block_number = max(latest_stored_block_number + 1, args.start) + for blocks_numbers_list in yield_blocks_numbers_lists( f"{bottom_block_number}-{latest_block_number}", order=args.order, diff --git a/datasets/nfts/.gitignore b/datasets/nfts/.gitignore new file mode 100644 index 00000000..5f4df389 --- /dev/null +++ b/datasets/nfts/.gitignore @@ -0,0 +1,167 @@ + +# Created by https://www.toptal.com/developers/gitignore/api/python,visualstudiocode +# Edit at https://www.toptal.com/developers/gitignore?templates=python,visualstudiocode + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +### VisualStudioCode ### +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history +.ionide + +# End of https://www.toptal.com/developers/gitignore/api/python,visualstudiocode + +.venv/ +.nfts/ +venv/ +.secrets/ +.analysis/ diff --git a/datasets/nfts/README.md b/datasets/nfts/README.md new file mode 100644 index 00000000..2aed63c1 --- /dev/null +++ b/datasets/nfts/README.md @@ -0,0 +1,7 @@ +# The Moonstream NFTs dataset + +This directory contains all the code needed to construct the Moonstream NFTs dataset. These scripts +may require access to: +1. The Moonstream database +2. Moonstream Bugout data stores +3. A web3 provider diff --git a/datasets/nfts/nfts/__init__.py b/datasets/nfts/nfts/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py new file mode 100644 index 00000000..d0ea90b4 --- /dev/null +++ b/datasets/nfts/nfts/cli.py @@ -0,0 +1,319 @@ +import argparse +import contextlib +import logging +import os +import sqlite3 +from shutil import copyfile +from typing import Optional + +from moonstreamdb.db import yield_db_session_ctx + +from .enrich import EthereumBatchloader, enrich +from .data import EventType, event_types, nft_event, BlockBounds +from .datastore import setup_database, import_data, filter_data +from .derive import ( + current_owners, + current_market_values, + current_values_distribution, + transfer_statistics_by_address, + quantile_generating, + mint_holding_times, + ownership_transitions, + transfer_holding_times, + transfers_mints_connection_table, +) +from .materialize import create_dataset + + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +derive_functions = { + "current_owners": current_owners, + "current_market_values": current_market_values, + "current_values_distribution": current_values_distribution, + "mint_holding_times": mint_holding_times, + "ownership_transitions": ownership_transitions, + "quantile_generating": quantile_generating, + "transfer_holding_times": transfer_holding_times, + "transfers_mints_connection_table": transfers_mints_connection_table, + "transfer_statistics_by_address": transfer_statistics_by_address, +} + + +def handle_initdb(args: argparse.Namespace) -> None: + with contextlib.closing(sqlite3.connect(args.datastore)) as conn: + setup_database(conn) + + +def handle_import_data(args: argparse.Namespace) -> None: + event_type = nft_event(args.type) + with contextlib.closing( + sqlite3.connect(args.target) + ) as target_conn, contextlib.closing(sqlite3.connect(args.source)) as source_conn: + import_data(target_conn, source_conn, event_type, args.batch_size) + + +def handle_filter_data(args: argparse.Namespace) -> None: + + with contextlib.closing(sqlite3.connect(args.source)) as source_conn: + + if args.target == args.source and args.source is not None: + sqlite_path = f"{args.target}.dump" + else: + sqlite_path = args.target + + print(f"Creating new database:{sqlite_path}") + + copyfile(args.source, sqlite_path) + + # do connection + with contextlib.closing(sqlite3.connect(sqlite_path)) as source_conn: + print("Start filtering") + filter_data( + source_conn, + start_time=args.start_time, + end_time=args.end_time, + ) + print("Filtering end.") + for index, function_name in enumerate(derive_functions.keys()): + print( + f"Derive process {function_name} {index+1}/{len(derive_functions.keys())}" + ) + derive_functions[function_name](source_conn) + + # Apply derive to new data + + +def handle_materialize(args: argparse.Namespace) -> None: + event_type = nft_event(args.type) + bounds: Optional[BlockBounds] = None + if args.start is not None: + bounds = BlockBounds(starting_block=args.start, ending_block=args.end) + elif args.end is not None: + raise ValueError("You cannot set --end unless you also set --start") + + batch_loader = EthereumBatchloader(jsonrpc_url=args.jsonrpc) + + logger.info(f"Materializing NFT events to datastore: {args.datastore}") + logger.info(f"Block bounds: {bounds}") + + with yield_db_session_ctx() as db_session, contextlib.closing( + sqlite3.connect(args.datastore) + ) as moonstream_datastore: + create_dataset( + moonstream_datastore, + db_session, + event_type, + bounds, + args.batch_size, + ) + + +def handle_enrich(args: argparse.Namespace) -> None: + + batch_loader = EthereumBatchloader(jsonrpc_url=args.jsonrpc) + + logger.info(f"Enriching NFT events in datastore: {args.datastore}") + + with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: + enrich( + moonstream_datastore, + EventType.TRANSFER, + batch_loader, + args.batch_size, + ) + + enrich( + moonstream_datastore, + EventType.MINT, + batch_loader, + args.batch_size, + ) + + +def handle_derive(args: argparse.Namespace) -> None: + with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: + calling_functions = [] + if not args.derive_functions: + calling_functions.extend(derive_functions.keys()) + else: + calling_functions.extend(args.derive_functions) + + for function_name in calling_functions: + if function_name in calling_functions: + derive_functions[function_name](moonstream_datastore) + logger.info("Done!") + + +def main() -> None: + """ + "nfts" command handler. + + When reading this code, to find the definition of any of the "nfts" subcommands, grep for comments + of the form: + # Command: nfts + """ + default_web3_provider = os.environ.get("MOONSTREAM_WEB3_PROVIDER") + if default_web3_provider is not None and not default_web3_provider.startswith( + "http" + ): + raise ValueError( + f"Please either unset MOONSTREAM_WEB3_PROVIDER environment variable or set it to an HTTP/HTTPS URL. Current value: {default_web3_provider}" + ) + + parser = argparse.ArgumentParser( + description="Tools to work with the Moonstream NFTs dataset" + ) + subcommands = parser.add_subparsers(title="Subcommands") + + # Command: nfts initdb + parser_initdb = subcommands.add_parser( + "initdb", + description="Initialize an SQLite datastore for the Moonstream NFTs dataset", + ) + parser_initdb.add_argument("datastore") + parser_initdb.set_defaults(func=handle_initdb) + + # Command: nfts materialize + parser_materialize = subcommands.add_parser( + "materialize", description="Create/update the NFTs dataset" + ) + parser_materialize.add_argument( + "-d", + "--datastore", + required=True, + help="Path to SQLite database representing the dataset", + ) + parser_materialize.add_argument( + "--jsonrpc", + default=default_web3_provider, + type=str, + help=f"Http uri provider to use when collecting data directly from the Ethereum blockchain (default: {default_web3_provider})", + ) + parser_materialize.add_argument( + "-t", + "--type", + choices=event_types, + help="Type of event to materialize intermediate data for", + ) + parser_materialize.add_argument( + "--start", type=int, default=None, help="Starting block number" + ) + parser_materialize.add_argument( + "--end", type=int, default=None, help="Ending block number" + ) + parser_materialize.add_argument( + "-n", + "--batch-size", + type=int, + default=1000, + help="Number of events to process per batch", + ) + parser_materialize.set_defaults(func=handle_materialize) + + parser_derive = subcommands.add_parser( + "derive", description="Create/updated derived data in the dataset" + ) + parser_derive.add_argument( + "-d", + "--datastore", + required=True, + help="Path to SQLite database representing the dataset", + ) + parser_derive.add_argument( + "-f", + "--derive-functions", + required=False, + nargs="+", + help=f"Functions wich will call from derive module availabel {list(derive_functions.keys())}", + ) + parser_derive.set_defaults(func=handle_derive) + + parser_import_data = subcommands.add_parser( + "import-data", + description="Import data from another source NFTs dataset datastore. This operation is performed per table, and replaces the existing table in the target datastore.", + ) + parser_import_data.add_argument( + "--target", + required=True, + help="Datastore into which you want to import data", + ) + parser_import_data.add_argument( + "--source", required=True, help="Datastore from which you want to import data" + ) + parser_import_data.add_argument( + "--type", + required=True, + choices=event_types, + help="Type of data you would like to import from source to target", + ) + parser_import_data.add_argument( + "-N", + "--batch-size", + type=int, + default=10000, + help="Batch size for database commits into target datastore.", + ) + parser_import_data.set_defaults(func=handle_import_data) + + # Create dump of filtered data + + parser_filtered_copy = subcommands.add_parser( + "filter-data", + description="Create copy of database with applied filters.", + ) + parser_filtered_copy.add_argument( + "--target", + required=True, + help="Datastore into which you want to import data", + ) + parser_filtered_copy.add_argument( + "--source", required=True, help="Datastore from which you want to import data" + ) + parser_filtered_copy.add_argument( + "--start-time", + required=False, + type=int, + help="Start timestamp.", + ) + parser_filtered_copy.add_argument( + "--end-time", + required=False, + type=int, + help="End timestamp.", + ) + + parser_filtered_copy.set_defaults(func=handle_filter_data) + + parser_enrich = subcommands.add_parser( + "enrich", description="enrich dataset from geth node" + ) + parser_enrich.add_argument( + "-d", + "--datastore", + required=True, + help="Path to SQLite database representing the dataset", + ) + parser_enrich.add_argument( + "--jsonrpc", + default=default_web3_provider, + type=str, + help=f"Http uri provider to use when collecting data directly from the Ethereum blockchain (default: {default_web3_provider})", + ) + parser_enrich.add_argument( + "-n", + "--batch-size", + type=int, + default=1000, + help="Number of events to process per batch", + ) + parser_enrich.set_defaults(func=handle_enrich) + + args = parser.parse_args() + args.func(args) + + +if __name__ == "__main__": + main() diff --git a/datasets/nfts/nfts/data.py b/datasets/nfts/nfts/data.py new file mode 100644 index 00000000..7358dcd4 --- /dev/null +++ b/datasets/nfts/nfts/data.py @@ -0,0 +1,50 @@ +""" +Data structures used in (and as part of the maintenance of) the Moonstream NFTs dataset +""" +from dataclasses import dataclass +from enum import Enum +from os import name +from typing import Optional + + +@dataclass +class BlockBounds: + starting_block: int + ending_block: Optional[int] = None + + +class EventType(Enum): + TRANSFER = "nft_transfer" + MINT = "nft_mint" + ERC721 = "erc721" + + +event_types = {event_type.value: event_type for event_type in EventType} + + +def nft_event(raw_event: str) -> EventType: + try: + return event_types[raw_event] + except KeyError: + raise ValueError(f"Unknown nft event type: {raw_event}") + + +@dataclass +class NFTEvent: + event_id: str + event_type: EventType + nft_address: str + token_id: str + from_address: str + to_address: str + transaction_hash: str + value: Optional[int] = None + block_number: Optional[int] = None + timestamp: Optional[int] = None + + +@dataclass +class NFTMetadata: + address: str + name: str + symbol: str diff --git a/datasets/nfts/nfts/dataset.py b/datasets/nfts/nfts/dataset.py new file mode 100644 index 00000000..9062c9ca --- /dev/null +++ b/datasets/nfts/nfts/dataset.py @@ -0,0 +1,228 @@ +""" +Functions to access various data in the NFTs dataset. +""" +import sqlite3 +from typing import List, Optional, Tuple + +import numpy as np +import pandas as pd +import scipy.sparse +from tqdm import tqdm + +from .datastore import event_tables, EventType + +# TODO(zomglings): Make it so that table names are parametrized by importable variables. The way +# things are now, we have to be very careful if we ever rename a table in our dataset. We should +# also propagate the name change here. +NFTS = "nfts" +MINTS = event_tables[EventType.MINT] +TRANSFERS = event_tables[EventType.TRANSFER] +CURRENT_OWNERS = "current_owners" +CURRENT_MARKET_VALUES = "current_market_values" +TRANSFER_STATISTICS_BY_ADDRESS = "transfer_statistics_by_address" +MINT_HOLDING_TIMES = "mint_holding_times" +TRANSFER_HOLDING_TIMES = "transfer_holding_times" +OWNERSHIP_TRANSITIONS = "ownership_transitions" + +AVAILABLE_DATAFRAMES = { + NFTS: """Describes the NFT contracts represented in this dataset, with a name and symbol if they were available at time of crawl. + +Columns: +1. address: The Ethereum address of the NFT contract. +2. name: The name of the collection of NFTs that the contract represents. +3. symbol: The symbol of the collection of NFTs that the contract represents. +""", + MINTS: """All token mint events crawled in this dataset. + +Columns: +1. event_id: A unique event ID associated with the event. +2. transaction_hash: The hash of the transaction which triggered the event. +3. block_number: The transaction block in which the transaction was mined. +4. nft_address: The address of the NFT collection containing the minted token. +5. token_id: The ID of the token that was minted. +6. from_address: The "from" address for the transfer event. For a mint, this should be the 0 address: 0x0000000000000000000000000000000000000000. +7. to_address: The "to" address for the transfer event. This represents the owner of the freshly minted token. +8. transaction_value: The amount of WEI that were sent with the transaction in which the token was minted. +9. timestamp: The time at which the mint operation was mined into the blockchain (this is the timestamp for the mined block). +""", + TRANSFERS: """All token transfer events crawled in this dataset. + +Columns: +1. event_id: A unique event ID associated with the event. +2. transaction_hash: The hash of the transaction which triggered the event. +3. block_number: The transaction block in which the transaction was mined. +4. nft_address: The address of the NFT collection containing the transferred token. +5. token_id: The ID of the token that was transferred. +6. from_address: The "from" address for the transfer event. This is the address that owned the token at the *start* of the transfer. +7. to_address: The "to" address for the transfer event. This is the address that owned the token at the *end* of the transfer. +8. transaction_value: The amount of WEI that were sent with the transaction in which the token was transferred. +9. timestamp: The time at which the transfer operation was mined into the blockchain (this is the timestamp for the mined block). +""", + CURRENT_OWNERS: f"""This table is derived from the {NFTS}, {MINTS}, and {TRANSFERS} tables. It represents the current owner of each token in the dataset. + +Columns: +1. nft_address: The address of the NFT collection containing the token whose ownership we are denoting. +2. token_id: The ID of the token (inside the collection) whose ownership we are denoting. +3. owner: The address that owned the token at the time of construction of this dataset. +""", + CURRENT_MARKET_VALUES: f"""This table is derived from the {NFTS}, {MINTS}, and {TRANSFERS} tables. It represents the current market value (in WEI) of each token in the dataset. + +Columns: +1. nft_address: The address of the NFT collection containing the token whose market value we are denoting. +2. token_id: The ID of the token (inside the collection) whose market value we are denoting. +3. market_value: The estimated market value of the token at the time of construction of this dataset. + +For this dataset, we estimate the market value as the last non-zero transaction value for a transfer involving this token. +This estimate may be inaccurate for some transfers (e.g. multiple token transfers made by an escrow contract in a single transaction) +but ought to be reasonably accurate for a large majority of tokens. +""", + TRANSFER_STATISTICS_BY_ADDRESS: f"""This table is derived from the {NFTS}, {MINTS}, and {TRANSFERS} tables. For each address that participated in +at least one NFT transfer between April 1, 2021 and September 25, 2021, this table shows exactly how many NFTs that address transferred to +other addresses and how many NFT transfers that address was the recipient of. + +Columns: +1. address: An Ethereum address that participated in at least one NFT transfer between April 1, 2021 and September 25, 2021. +2. transfers_out: The number of NFTs that the given address transferred to any other address between April 1, 2021 and September 25, 2021. +3. transfers_in: The number of NFTs that any other address transferred to given address between April 1, 2021 and September 25, 2021. +""", +} + + +AVAILABLE_MATRICES = { + OWNERSHIP_TRANSITIONS: f"""{OWNERSHIP_TRANSITIONS} is an adjacency matrix which counts the number of times that a token was transferred from a source address (indexed by the rows of the matrix) to a target address (indexed by the columns of the matrix). + +These counts only include data about mints and transfers made between April 1, 2021 and September 25, 2021. We also denote the current owners of an NFT as having transitioned +the NFT from themselves back to themselves. This gives some estimate of an owner retaining the NFT in the given time period. + +Load this matrix as follows: +>>> indexed_addresses, transitions = ds.load_ownership_transitions() + +- "indexed_addresses" is a list denoting the address that each index (row/column) in the matrix represents. +- "transitions" is a numpy ndarray containing the matrix, with source addresses on the row axis and target addresses on the column axis. +""" +} + + +def explain() -> None: + """ + Explains the structure of the dataset. + """ + preamble = """ +The Moonstream NFTs dataset +=========================== + +To load the NFTs dataset from a SQLite file, run: +>>> ds = nfts.dataset.FromSQLite() + +This dataset consists of the following dataframes:""" + + print(preamble) + for name, explanation in AVAILABLE_DATAFRAMES.items(): + print(f"\nDataframe: {name}") + print( + f'Load using:\n>>> {name}_df = ds.load_dataframe(, "{name}")' + ) + print("") + print(explanation) + print("- - -") + + for name, explanation in AVAILABLE_MATRICES.items(): + print(f"\nMatrix: {name}") + print("") + print(explanation) + print("- - -") + + +class FromSQLite: + def __init__(self, datafile: str) -> None: + """ + Initialize an NFTs dataset instance by connecting it to a SQLite database containing the data. + """ + self.conn = sqlite3.connect(datafile) + self.ownership_transitions: Optional[ + Tuple[List[str], scipy.sparse.spmatrix] + ] = None + self.ownership_transition_probabilities: Optional[ + Tuple[List[str], scipy.sparse.spmatrix] + ] = None + + def load_dataframe(self, name: str) -> pd.DataFrame: + """ + Loads one of the available dataframes. To learn more about the available dataframes, run: + >>> nfts.dataset.explain() + """ + if name not in AVAILABLE_DATAFRAMES: + raise ValueError( + f"Invalid dataframe: {name}. Please choose from one of the available dataframes: {','.join(AVAILABLE_DATAFRAMES)}." + ) + df = pd.read_sql_query(f"SELECT * FROM {name};", self.conn) + return df + + def load_ownership_transitions( + self, force: bool = False + ) -> Tuple[List[str], scipy.sparse.spmatrix]: + """ + Loads ownership transitions adjacency matrix from SQLite database. + + To learn more about this matrix, run: + >>> nfts.dataset.explain() + """ + if self.ownership_transitions is not None and not force: + return self.ownership_transitions + cur = self.conn.cursor() + address_indexes_query = """ +WITH all_addresses AS ( + SELECT from_address AS address FROM ownership_transitions + UNION + SELECT to_address AS address FROM ownership_transitions +) +SELECT DISTINCT(all_addresses.address) AS address FROM all_addresses ORDER BY address ASC; +""" + addresses = [row[0] for row in cur.execute(address_indexes_query)] + num_addresses = len(addresses) + address_indexes = {address: i for i, address in enumerate(addresses)} + + adjacency_matrix = scipy.sparse.dok_matrix((num_addresses, num_addresses)) + adjacency_query = "SELECT from_address, to_address, num_transitions FROM ownership_transitions;" + + rows = cur.execute(adjacency_query) + for from_address, to_address, num_transitions in tqdm( + rows, desc="Ownership transitions (adjacency matrix)" + ): + from_index = address_indexes[from_address] + to_index = address_indexes[to_address] + adjacency_matrix[from_index, to_index] = num_transitions + + self.ownership_transitions = (addresses, adjacency_matrix) + return self.ownership_transitions + + def load_ownership_transition_probabilities( + self, + force: bool = False, + ) -> Tuple[List[str], scipy.sparse.spmatrix]: + """ + Returns transition probabilities of ownership transitions, with each entry A_{i,j} denoting the + probability that the address represented by row i transferred and NFT to the address represented by row[j]. + """ + if self.ownership_transition_probabilities is not None and not force: + return self.ownership_transition_probabilities + + addresses, adjacency_matrix = self.load_ownership_transitions(force) + + # Sum of the entries in each row: + # https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.spmatrix.sum.html#scipy.sparse.spmatrix.sum + row_sums = adjacency_matrix.sum(axis=1) + + # Convert adjacency matrix to matrix of transition probabilities. + # We cannot do this by simply dividing transition_probabilites /= row_sums because that tries + # to coerce the matrix into a dense numpy ndarray and requires terabytes of memory. + transition_probabilities = adjacency_matrix.copy() + for i, j in zip(*transition_probabilities.nonzero()): + transition_probabilities[i, j] = ( + transition_probabilities[i, j] / row_sums[i] + ) + + # Now we identify and remove burn addresses from this data. + + self.ownership_transition_probabilities = (addresses, transition_probabilities) + return self.ownership_transition_probabilities diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py new file mode 100644 index 00000000..0f3f361e --- /dev/null +++ b/datasets/nfts/nfts/datastore.py @@ -0,0 +1,464 @@ +""" +This module provides tools to interact with and maintain a SQLite database which acts/should act as +a datastore for a Moonstream NFTs dataset. +""" +import logging +import sqlite3 +from typing import Any, cast, List, Tuple, Optional + +from tqdm import tqdm + +from .data import EventType, NFTEvent, NFTMetadata + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +event_tables = {EventType.TRANSFER: "transfers", EventType.MINT: "mints"} + +CREATE_NFTS_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS nfts + ( + address TEXT NOT NULL UNIQUE ON CONFLICT FAIL, + name TEXT, + symbol TEXT, + UNIQUE(address, name, symbol) + ); +""" + +BACKUP_NFTS_TABLE_QUERY = "ALTER TABLE nfts RENAME TO nfts_backup;" +DROP_BACKUP_NFTS_TABLE_QUERY = "DROP TABLE IF EXISTS nfts_backup;" +SELECT_NFTS_QUERY = "SELECT address, name, symbol FROM nfts;" + +CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS checkpoint + ( + event_type STRING, + offset INTEGER + ); +""" + + +def create_events_table_query(event_type: EventType) -> str: + creation_query = f""" +CREATE TABLE IF NOT EXISTS {event_tables[event_type]} + ( + event_id TEXT NOT NULL UNIQUE ON CONFLICT FAIL, + transaction_hash TEXT, + block_number INTEGER, + nft_address TEXT REFERENCES nfts(address), + token_id TEXT, + from_address TEXT, + to_address TEXT, + transaction_value INTEGER, + timestamp INTEGER + ); + """ + return creation_query + + +def backup_events_table_query(event_type: EventType) -> str: + backup_query = f"ALTER TABLE {event_tables[event_type]} RENAME TO {event_tables[event_type]}_backup;" + return backup_query + + +def drop_backup_events_table_query(event_type: EventType) -> str: + drop_query = f"DROP TABLE IF EXISTS {event_tables[event_type]}_backup;" + return drop_query + + +def select_events_table_query(event_type: EventType) -> str: + selection_query = f""" +SELECT + event_id, + transaction_hash, + nft_address, + token_id, + from_address, + to_address, + transaction_value, + block_number, + timestamp +FROM {event_tables[event_type]}; + """ + + return selection_query + + +def get_events_for_enrich( + conn: sqlite3.Connection, event_type: EventType +) -> List[NFTEvent]: + def select_query(event_type: EventType) -> str: + selection_query = f""" + SELECT + event_id, + transaction_hash, + block_number, + nft_address, + token_id, + from_address, + to_address, + transaction_value, + timestamp + FROM {event_tables[event_type]} WHERE block_number = 'None'; + """ + + return selection_query + + logger.info(f"Loading {event_tables[event_type]} table events for enrich") + cur = conn.cursor() + cur.execute(select_query(event_type)) + + events: List[NFTEvent] = [] + + for row in cur: + ( + event_id, + transaction_hash, + block_number, + nft_address, + token_id, + from_address, + to_address, + value, + timestamp, + ) = cast( + Tuple[ + str, + str, + Optional[int], + str, + str, + str, + str, + Optional[int], + Optional[int], + ], + row, + ) + event = NFTEvent( + event_id=event_id, + event_type=event_type, # Original argument to this function + nft_address=nft_address, + token_id=token_id, + from_address=from_address, + to_address=to_address, + transaction_hash=transaction_hash, + value=value, + block_number=block_number, + timestamp=timestamp, + ) + events.append(event) + logger.info(f"Found {len(events)} events to enrich") + return events + + +def update_events_batch(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: + def replace_query(event_type: EventType) -> str: + query = f""" + REPLACE INTO {event_tables[event_type]}( + event_id, + transaction_hash, + block_number, + nft_address, + token_id, + from_address, + to_address, + transaction_value, + timestamp + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """ + return query + + logger.info("Updating events in sqlite") + cur = conn.cursor() + try: + transfers = [ + nft_event_to_tuple(event) + for event in events + if event.event_type == EventType.TRANSFER + ] + + mints = [ + nft_event_to_tuple(event) + for event in events + if event.event_type == EventType.MINT + ] + + cur.executemany(replace_query(EventType.TRANSFER), transfers) + cur.executemany(replace_query(EventType.MINT), mints) + + conn.commit() + except Exception as e: + logger.error(f"FAILED TO replace!!! :{events}") + conn.rollback() + raise e + + +def setup_database(conn: sqlite3.Connection) -> None: + """ + Sets up the schema of the Moonstream NFTs dataset in the given SQLite database. + """ + cur = conn.cursor() + + cur.execute(CREATE_NFTS_TABLE_QUERY) + cur.execute(create_events_table_query(EventType.TRANSFER)) + cur.execute(create_events_table_query(EventType.MINT)) + cur.execute(CREATE_CHECKPOINT_TABLE_QUERY) + + conn.commit() + + +def insert_events_query(event_type: EventType) -> str: + """ + Generates a query which inserts NFT events into the appropriate events table. + """ + query = f""" +INSERT OR IGNORE INTO {event_tables[event_type]}( + event_id, + transaction_hash, + block_number, + nft_address, + token_id, + from_address, + to_address, + transaction_value, + timestamp +) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """ + return query + + +def nft_event_to_tuple( + event: NFTEvent, +) -> Tuple[str, str, str, str, str, str, str, str, str]: + """ + Converts an NFT event into a tuple for use with sqlite cursor executemany. This includes + dropping e.g. the event_type field. + """ + return ( + str(event.event_id), + str(event.transaction_hash), + str(event.block_number), + str(event.nft_address), + str(event.token_id), + str(event.from_address), + str(event.to_address), + str(event.value), + str(event.timestamp), + ) + + +def get_checkpoint_offset( + conn: sqlite3.Connection, event_type: EventType +) -> Optional[int]: + cur = conn.cursor() + response = cur.execute( + f"SELECT * from checkpoint where event_type='{event_type.value}' order by rowid desc limit 1" + ) + for row in response: + return row[1] + return None + + +def delete_checkpoints( + conn: sqlite3.Connection, event_type: EventType, commit: bool = True +) -> None: + cur = conn.cursor() + cur.execute(f"DELETE FROM checkpoint where event_type='{event_type.value}';") + if commit: + try: + conn.commit() + except: + conn.rollback() + raise + + +def insert_checkpoint(conn: sqlite3.Connection, event_type: EventType, offset: int): + query = f""" +INSERT INTO checkpoint ( + event_type, + offset +) VALUES (?, ?) + """ + cur = conn.cursor() + cur.execute(query, [event_type.value, offset]) + conn.commit() + + +def insert_address_metadata( + conn: sqlite3.Connection, metadata_list: List[NFTMetadata] +) -> None: + cur = conn.cursor() + query = f""" +INSERT INTO nfts ( + address, + name, + symbol +) VALUES (?, ?, ?) + """ + try: + nfts = [ + (metadata.address, metadata.name, metadata.symbol) + for metadata in metadata_list + ] + cur.executemany(query, nfts) + conn.commit() + except Exception as e: + logger.error(f"Failed to save :\n {metadata_list}") + conn.rollback() + raise e + + +def insert_events(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: + """ + Inserts the given events into the appropriate events table in the given SQLite database. + + This method works with batches of events. + """ + cur = conn.cursor() + try: + transfers = [ + nft_event_to_tuple(event) + for event in events + if event.event_type == EventType.TRANSFER + ] + + mints = [ + nft_event_to_tuple(event) + for event in events + if event.event_type == EventType.MINT + ] + + cur.executemany(insert_events_query(EventType.TRANSFER), transfers) + cur.executemany(insert_events_query(EventType.MINT), mints) + + conn.commit() + except Exception as e: + logger.error(f"FAILED TO SAVE :{events}") + conn.rollback() + raise e + + +def import_data( + target_conn: sqlite3.Connection, + source_conn: sqlite3.Connection, + event_type: EventType, + batch_size: int = 1000, +) -> None: + """ + Imports the data correspondong to the given event type from the source database into the target + database. + + Any existing data of that type in the target database is first deleted. It is a good idea to + create a backup copy of your target database before performing this operation. + """ + target_cur = target_conn.cursor() + drop_backup_query = DROP_BACKUP_NFTS_TABLE_QUERY + backup_table_query = BACKUP_NFTS_TABLE_QUERY + create_table_query = CREATE_NFTS_TABLE_QUERY + source_selection_query = SELECT_NFTS_QUERY + if event_type != EventType.ERC721: + drop_backup_query = drop_backup_events_table_query(event_type) + backup_table_query = backup_events_table_query(event_type) + create_table_query = create_events_table_query(event_type) + source_selection_query = select_events_table_query(event_type) + + target_cur.execute(drop_backup_query) + target_cur.execute(backup_table_query) + target_cur.execute(create_table_query) + target_conn.commit() + + source_cur = source_conn.cursor() + source_cur.execute(source_selection_query) + + batch: List[Any] = [] + + for row in tqdm(source_cur, desc="Rows processed"): + if event_type == EventType.ERC721: + batch.append(NFTMetadata(*cast(Tuple[str, str, str], row))) + else: + # Order matches select query returned by select_events_table_query + ( + event_id, + transaction_hash, + nft_address, + token_id, + from_address, + to_address, + value, + block_number, + timestamp, + ) = cast( + Tuple[ + str, + str, + str, + str, + str, + str, + Optional[int], + Optional[int], + Optional[int], + ], + row, + ) + event = NFTEvent( + event_id=event_id, + event_type=event_type, # Original argument to this function + nft_address=nft_address, + token_id=token_id, + from_address=from_address, + to_address=to_address, + transaction_hash=transaction_hash, + value=value, + block_number=block_number, + timestamp=timestamp, + ) + batch.append(event) + + if len(batch) == batch_size: + if event_type == EventType.ERC721: + insert_address_metadata(target_conn, cast(List[NFTMetadata], batch)) + else: + insert_events(target_conn, cast(List[NFTEvent], batch)) + + if event_type == EventType.ERC721: + insert_address_metadata(target_conn, cast(List[NFTMetadata], batch)) + else: + insert_events(target_conn, cast(List[NFTEvent], batch)) + + target_cur.execute(CREATE_CHECKPOINT_TABLE_QUERY) + target_conn.commit() + + source_offset = get_checkpoint_offset(source_conn, event_type) + if source_offset is not None: + delete_checkpoints(target_conn, event_type, commit=False) + insert_checkpoint(target_conn, event_type, source_offset) + + +def filter_data( + sqlite_db: sqlite3.Connection, + start_time: Optional[int] = None, + end_time: Optional[int] = None, +): + """ + Run Deletes query depends on filters + """ + + cur = sqlite_db.cursor() + print(f"Remove by timestamp < {start_time}") + if start_time: + cur.execute(f"DELETE from transfers where timestamp < {start_time}") + print(f"Transfers filtered out: {cur.rowcount}") + sqlite_db.commit() + cur.execute(f"DELETE from mints where timestamp < {start_time}") + print(f"Mints filtered out: {cur.rowcount}") + sqlite_db.commit() + + print(f"Remove by timestamp > {end_time}") + if end_time: + cur.execute(f"DELETE from transfers where timestamp > {end_time}") + print(f"Transfers filtered out: {cur.rowcount}") + sqlite_db.commit() + cur.execute(f"DELETE from mints where timestamp > {end_time}") + print(f"Mints filtered out: {cur.rowcount}") + sqlite_db.commit() diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py new file mode 100644 index 00000000..37bf2321 --- /dev/null +++ b/datasets/nfts/nfts/derive.py @@ -0,0 +1,494 @@ +""" +Tools to build derived relations from raw data (nfts, transfers, mints relations). + +For example: +- Current owner of each token +- Current value of each token +""" +import logging +import sqlite3 + + +logging.basicConfig(level=logging.ERROR) +logger = logging.getLogger(__name__) + + +class LastValue: + """ + Stores the last seen value in a given column. This is meant to be used as an aggregate function. + We use it, for example, to get the current owner of an NFT (inside a given window of time). + """ + + def __init__(self): + self.value = None + + def step(self, value): + self.value = value + + def finalize(self): + return self.value + + +class LastNonzeroValue: + """ + Stores the last non-zero value in a given column. This is meant to be used as an aggregate + function. We use it, for example, to get the current market value of an NFT (inside a given + window of time). + """ + + def __init__(self): + self.value = 0 + + def step(self, value): + if value != 0: + self.value = value + + def finalize(self): + return self.value + + +class QuantileFunction: + """Split vlues to quantiles""" + + def __init__(self, num_quantiles) -> None: + self.divider = 1 / num_quantiles + + def __call__(self, value): + if value is None or value == "None": + value = 0 + quantile = self.divider + try: + while value > quantile: + quantile += self.divider + + if quantile > 1: + quantile = 1 + + return quantile + + except Exception as err: + print(err) + raise + + +def ensure_custom_aggregate_functions(conn: sqlite3.Connection) -> None: + """ + Loads custom aggregate functions to an active SQLite3 connection. + """ + conn.create_aggregate("last_value", 1, LastValue) + conn.create_aggregate("last_nonzero_value", 1, LastNonzeroValue) + conn.create_function("quantile_10", 1, QuantileFunction(10)) + conn.create_function("quantile_25", 1, QuantileFunction(25)) + + +def current_owners(conn: sqlite3.Connection) -> None: + """ + Requires a connection to a dataset in which the raw data (esp. transfers) has already been + loaded. + """ + ensure_custom_aggregate_functions(conn) + drop_existing_current_owners_query = "DROP TABLE IF EXISTS current_owners;" + current_owners_query = """ + CREATE TABLE current_owners AS + SELECT nft_address, token_id, last_value(to_address) AS owner FROM + ( + SELECT * FROM mints + UNION ALL + SELECT * FROM transfers + ) + GROUP BY nft_address, token_id;""" + cur = conn.cursor() + try: + cur.execute(drop_existing_current_owners_query) + cur.execute(current_owners_query) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: current_owners") + logger.error(e) + + +def current_market_values(conn: sqlite3.Connection) -> None: + """ + Requires a connection to a dataset in which the raw data (esp. transfers) has already been + loaded. + """ + ensure_custom_aggregate_functions(conn) + drop_existing_current_market_values_query = ( + "DROP TABLE IF EXISTS current_market_values;" + ) + current_market_values_query = """ + CREATE TABLE current_market_values AS + SELECT nft_address, token_id, last_nonzero_value(transaction_value) AS market_value FROM + ( + SELECT * FROM mints + UNION ALL + SELECT * FROM transfers + ) + GROUP BY nft_address, token_id;""" + cur = conn.cursor() + try: + cur.execute(drop_existing_current_market_values_query) + cur.execute(current_market_values_query) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: current_market_values") + + +def current_values_distribution(conn: sqlite3.Connection) -> None: + """ + Requires a connection to a dataset in which current_market_values has already been loaded. + """ + ensure_custom_aggregate_functions(conn) + drop_existing_values_distribution_query = ( + "DROP TABLE IF EXISTS market_values_distribution;" + ) + current_values_distribution_query = """ + CREATE TABLE market_values_distribution AS + select + current_market_values.nft_address as address, + current_market_values.token_id as token_id, + CAST(current_market_values.market_value as REAL) / max_values.max_value as relative_value + from + current_market_values + inner join ( + select + nft_address, + max(market_value) as max_value + from + current_market_values + group by + nft_address + ) as max_values on current_market_values.nft_address = max_values.nft_address; + """ + cur = conn.cursor() + try: + cur.execute(drop_existing_values_distribution_query) + cur.execute(current_values_distribution_query) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: current_values_distribution") + logger.error(e) + + +def transfer_statistics_by_address(conn: sqlite3.Connection) -> None: + """ + Create transfer in and transfer out for each address. + """ + drop_existing_transfer_statistics_by_address_query = ( + "DROP TABLE IF EXISTS transfer_statistics_by_address;" + ) + transfer_statistics_by_address_query = """ + CREATE TABLE transfer_statistics_by_address AS + SELECT + address, + sum(transfer_out) as transfers_out, + sum(transfer_in) as transfers_in + from + ( + SELECT + from_address as address, + 1 as transfer_out, + 0 as transfer_in + from + transfers + UNION + ALL + select + to_address as address, + 0 as transfer_out, + 1 as transfer_in + from + transfers + ) + group by + address; + """ + cur = conn.cursor() + try: + cur.execute(drop_existing_transfer_statistics_by_address_query) + cur.execute(transfer_statistics_by_address_query) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: transfer_statistics_by_address") + logger.error(e) + + +def quantile_generating(conn: sqlite3.Connection): + """ + Create quantile wich depends on setted on class defenition + """ + ensure_custom_aggregate_functions(conn) + drop_calculate_10_quantiles = ( + "DROP TABLE IF EXISTS transfer_values_quantile_10_distribution_per_address;" + ) + calculate_10_quantiles = """ + CREATE TABLE transfer_values_quantile_10_distribution_per_address AS + select + cumulate.address as address, + CAST(quantile_10(cumulate.relative_value) as TEXT) as quantiles, + cumulate.relative_value as relative_value + from + ( + select + current_market_values.nft_address as address, + COALESCE( + CAST(current_market_values.market_value as REAL) / max_values.max_value, + 0 + ) as relative_value + from + current_market_values + inner join ( + select + current_market_values.nft_address, + max(market_value) as max_value + from + current_market_values + group by + current_market_values.nft_address + ) as max_values on current_market_values.nft_address = max_values.nft_address + ) as cumulate + """ + drop_calculate_25_quantiles = ( + "DROP TABLE IF EXISTS transfer_values_quantile_25_distribution_per_address;" + ) + calculate_25_quantiles = """ + CREATE TABLE transfer_values_quantile_25_distribution_per_address AS + select + cumulate.address as address, + CAST(quantile_25(cumulate.relative_value) as TEXT) as quantiles, + cumulate.relative_value as relative_value + from + ( + select + current_market_values.nft_address as address, + COALESCE( + CAST(current_market_values.market_value as REAL) / max_values.max_value, + 0 + ) as relative_value + from + current_market_values + inner join ( + select + current_market_values.nft_address, + max(market_value) as max_value + from + current_market_values + group by + current_market_values.nft_address + ) as max_values on current_market_values.nft_address = max_values.nft_address + ) as cumulate + """ + cur = conn.cursor() + try: + print("Creating transfer_values_quantile_10_distribution_per_address") + cur.execute(drop_calculate_10_quantiles) + cur.execute(calculate_10_quantiles) + print("Creating transfer_values_quantile_25_distribution_per_address") + cur.execute(drop_calculate_25_quantiles) + cur.execute(calculate_25_quantiles) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: quantile_generating") + logger.error(e) + + +def transfers_mints_connection_table(conn: sqlite3.Connection): + """ + Create cinnection transfers and mints + """ + + drop_transfers_mints_connection = "DROP TABLE IF EXISTS transfers_mints;" + transfers_mints_connection = """ + CREATE TABLE transfers_mints as + select + transfers.event_id as transfer_id, + mints.mint_id as mint_id + from + transfers + inner join ( + select + Max(posable_mints.mints_time) as mint_time, + posable_mints.transfer_id as transfer_id + from + ( + select + mint_id, + mints.timestamp as mints_time, + transfers.token_id, + transfers.timestamp, + transfers.event_id as transfer_id + from + transfers + inner join ( + select + mints.event_id as mint_id, + mints.nft_address, + mints.token_id, + mints.timestamp + from + mints + group by + mints.nft_address, + mints.token_id, + mints.timestamp + ) as mints on transfers.nft_address = mints.nft_address + and transfers.token_id = mints.token_id + and mints.timestamp <= transfers.timestamp + ) as posable_mints + group by + posable_mints.transfer_id + ) as mint_time on mint_time.transfer_id = transfers.event_id + inner join ( + select + mints.event_id as mint_id, + mints.nft_address, + mints.token_id, + mints.timestamp + from + mints + ) as mints on transfers.nft_address = mints.nft_address + and transfers.token_id = mints.token_id + and mints.timestamp = mint_time.mint_time; + """ + cur = conn.cursor() + try: + cur.execute(drop_transfers_mints_connection) + cur.execute(transfers_mints_connection) + conn.commit() + except Exception as e: + conn.rollback() + logger.error( + "Could not create derived dataset: transfers_mints_connection_table" + ) + logger.error(e) + + +def mint_holding_times(conn: sqlite3.Connection): + + drop_mints_holding_table = "DROP TABLE IF EXISTS mint_holding_times;" + mints_holding_table = """ + CREATE TABLE mint_holding_times AS + SELECT + days_after_minted.days as days, + count(*) as num_holds + from + ( + SELECT + mints.nft_address, + mints.token_id, + ( + firsts_transfers.firts_transfer - mints.timestamp + ) / 86400 as days + from + mints + inner join ( + select + transfers_mints.mint_id, + transfers.nft_address, + transfers.token_id, + min(transfers.timestamp) as firts_transfer + from + transfers + inner join transfers_mints on transfers_mints.transfer_id = transfers.event_id + group by + transfers.nft_address, + transfers.token_id, + transfers_mints.mint_id + ) as firsts_transfers on firsts_transfers.mint_id = mints.event_id + ) as days_after_minted + group by days; + """ + cur = conn.cursor() + try: + cur.execute(drop_mints_holding_table) + cur.execute(mints_holding_table) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: mint_holding_times") + logger.error(e) + + +def transfer_holding_times(conn: sqlite3.Connection): + """ + Create distributions of holding times beetween transfers + """ + drop_transfer_holding_times = "DROP TABLE IF EXISTS transfer_holding_times;" + transfer_holding_times = """ + CREATE TABLE transfer_holding_times AS + select days_beetween.days as days, count(*) as num_holds + from (SELECT + middle.address, + middle.token_id, + (middle.LEAD - middle.timestamp) / 86400 as days + from + ( + SELECT + nft_address AS address, + token_id as token_id, + timestamp as timestamp, + LEAD(timestamp, 1, Null) OVER ( + PARTITION BY nft_address, + token_id + ORDER BY + timestamp + ) as LEAD + FROM + transfers + ) as middle + where + LEAD is not Null + ) as days_beetween + group by days; + """ + cur = conn.cursor() + try: + cur.execute(drop_transfer_holding_times) + cur.execute(transfer_holding_times) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: transfer_holding_times") + logger.error(e) + + +def ownership_transitions(conn: sqlite3.Connection) -> None: + """ + Derives a table called ownership_transitions which counts the number of transitions in ownership + from address A to address B for each pair of addresses (A, B) for which there was at least + one transfer from A to B. + + Requires the following tables: + - transfers + - current_owners + """ + table_name = "ownership_transitions" + drop_ownership_transitions = f"DROP TABLE IF EXISTS {table_name};" + # TODO(zomglings): Adding transaction_value below causes integer overflow. Might be worth trying MEAN instead of SUM for value transferred. + create_ownership_transitions = f""" +CREATE TABLE {table_name} AS +WITH transitions(from_address, to_address, transition) AS ( + SELECT current_owners.owner as from_address, current_owners.owner as to_address, 1 as transition FROM current_owners + UNION ALL + SELECT transfers.from_address as from_address, transfers.to_address as to_address, 1 as transition FROM transfers +) +SELECT + transitions.from_address, + transitions.to_address, + sum(transitions.transition) as num_transitions +FROM transitions GROUP BY transitions.from_address, transitions.to_address; +""" + cur = conn.cursor() + try: + cur.execute(drop_ownership_transitions) + cur.execute(create_ownership_transitions) + conn.commit() + except Exception as e: + conn.rollback() + logger.error(f"Could not create derived dataset: {table_name}") + logger.error(e) diff --git a/datasets/nfts/nfts/enrich.py b/datasets/nfts/nfts/enrich.py new file mode 100644 index 00000000..41410674 --- /dev/null +++ b/datasets/nfts/nfts/enrich.py @@ -0,0 +1,161 @@ +import logging +import sqlite3 +from typing import Any, cast, Iterator, List, Optional, Set +import json + +from tqdm import tqdm +import requests + +from .data import BlockBounds, EventType, NFTEvent, event_types +from .datastore import ( + get_checkpoint_offset, + get_events_for_enrich, + insert_address_metadata, + insert_checkpoint, + insert_events, + update_events_batch, +) + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +class EthereumBatchloader: + def __init__(self, jsonrpc_url) -> None: + self.jsonrpc_url = jsonrpc_url + self.message_number = 0 + self.commands: List[Any] = [] + self.requests_banch: List[Any] = [] + + def load_blocks(self, block_list: List[int], with_transactions: bool): + """ + Request list of blocks + """ + rpc = [ + { + "jsonrpc": "2.0", + "id": index, + "method": "eth_getBlockByNumber", + "params": params_single, + } + for index, params_single in enumerate( + [[hex(block_number), with_transactions] for block_number in block_list] + ) + ] + response = self.send_json_message(rpc) + return response + + def load_transactions(self, transaction_hashes: List[str]): + """ + Request list of transactions + """ + + rpc = [ + { + "jsonrpc": "2.0", + "method": "eth_getTransactionByHash", + "id": index, + "params": [tx_hash], + } + for index, tx_hash in enumerate(transaction_hashes) + ] + response = self.send_json_message(rpc) + return response + + def send_message(self, payload): + headers = {"Content-Type": "application/json"} + + try: + r = requests.post( + self.jsonrpc_url, headers=headers, data=payload, timeout=300 + ) + except Exception as e: + print(e) + raise e + return r + + def send_json_message(self, message): + encoded_json = json.dumps(message) + raw_response = self.send_message(encoded_json.encode("utf8")) + response = raw_response.json() + return response + + +def enrich_from_web3( + nft_events: List[NFTEvent], + batch_loader: EthereumBatchloader, +) -> List[NFTEvent]: + """ + Adds block number, value, timestamp from web3 if they are None (because that transaction is missing in db) + """ + transactions_to_query = set() + indices_to_update: List[int] = [] + for index, nft_event in enumerate(nft_events): + if ( + nft_event.block_number == "None" + or nft_event.value == "None" + or nft_event.timestamp == "None" + ): + transactions_to_query.add(nft_event.transaction_hash) + indices_to_update.append(index) + + if len(transactions_to_query) == 0: + return nft_events + logger.info("Calling JSON RPC API") + jsonrpc_transactions_response = batch_loader.load_transactions( + list(transactions_to_query) + ) + + transactions_map = { + result["result"]["hash"]: ( + int(result["result"]["value"], 16), + int(result["result"]["blockNumber"], 16), + ) + for result in jsonrpc_transactions_response + } + + blocks_to_query: Set[int] = set() + for index in indices_to_update: + nft_events[index].value, nft_events[index].block_number = transactions_map[ + nft_events[index].transaction_hash + ] + blocks_to_query.add(cast(int, nft_events[index].block_number)) + + if len(blocks_to_query) == 0: + return nft_events + jsonrpc_blocks_response = batch_loader.load_blocks(list(blocks_to_query), False) + blocks_map = { + int(result["result"]["number"], 16): int(result["result"]["timestamp"], 16) + for result in jsonrpc_blocks_response + } + for index in indices_to_update: + nft_events[index].timestamp = blocks_map[cast(int, nft_event.block_number)] + + return nft_events + + +def enrich( + datastore_conn: sqlite3.Connection, + event_type: EventType, + batch_loader: EthereumBatchloader, + batch_size: int = 1000, +) -> None: + events = get_events_for_enrich(datastore_conn, event_type) + events_batch = [] + for event in tqdm(events, f"Processing events for {event_type.value} event type"): + events_batch.append(event) + if len(events_batch) == batch_size: + logger.info("Getting data from JSONrpc") + enriched_events = enrich_from_web3( + events_batch, + batch_loader, + ) + update_events_batch(datastore_conn, enriched_events) + events_batch = [] + + logger.info("Getting data from JSONrpc") + enriched_events = enrich_from_web3( + events_batch, + batch_loader, + ) + update_events_batch(datastore_conn, enriched_events) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py new file mode 100644 index 00000000..bad00102 --- /dev/null +++ b/datasets/nfts/nfts/materialize.py @@ -0,0 +1,186 @@ +import logging +import sqlite3 +from typing import Any, cast, Iterator, List, Optional, Set +import json + +from moonstreamdb.models import ( + EthereumAddress, + EthereumLabel, + EthereumTransaction, + EthereumBlock, +) +from sqlalchemy import or_, and_ +from sqlalchemy.orm import Session +from tqdm import tqdm +from web3 import Web3 +import requests + +from .data import BlockBounds, EventType, NFTEvent, NFTMetadata, event_types +from .datastore import ( + get_checkpoint_offset, + insert_address_metadata, + insert_checkpoint, + insert_events, +) + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +def add_events( + datastore_conn: sqlite3.Connection, + db_session: Session, + event_type: EventType, + initial_offset=0, + bounds: Optional[BlockBounds] = None, + batch_size: int = 10, +) -> None: + raw_created_at_list = ( + db_session.query(EthereumLabel.created_at) + .filter(EthereumLabel.label == event_type.value) + .order_by(EthereumLabel.created_at.asc()) + .distinct(EthereumLabel.created_at) + ).all() + + created_at_list = [ + created_at[0] for created_at in raw_created_at_list[initial_offset:] + ] + query = ( + db_session.query( + EthereumLabel.id, + EthereumLabel.label, + EthereumAddress.address, + EthereumLabel.label_data, + EthereumLabel.transaction_hash, + EthereumTransaction.value, + EthereumTransaction.block_number, + EthereumBlock.timestamp, + ) + .filter(EthereumLabel.label == event_type.value) + .join(EthereumAddress, EthereumLabel.address_id == EthereumAddress.id) + .outerjoin( + EthereumTransaction, + EthereumLabel.transaction_hash == EthereumTransaction.hash, + ) + .outerjoin( + EthereumBlock, + EthereumTransaction.block_number == EthereumBlock.block_number, + ) + .order_by(EthereumLabel.created_at.asc(),) + ) + if bounds is not None: + time_filters = [EthereumTransaction.block_number >= bounds.starting_block] + if bounds.ending_block is not None: + time_filters.append(EthereumTransaction.block_number <= bounds.ending_block) + bounds_filters = [EthereumTransaction.hash == None, and_(*time_filters)] + + query = query.filter(or_(*bounds_filters)) + + pbar = tqdm(total=(len(raw_created_at_list))) + pbar.set_description(f"Processing created ats") + pbar.update(initial_offset) + batch_start = 0 + batch_end = batch_start + batch_size + while batch_start <= len(created_at_list): + + events = query.filter( + EthereumLabel.created_at.in_(created_at_list[batch_start : batch_end + 1]) + ).all() + if not events: + continue + + raw_events_batch = [] + for ( + event_id, + label, + address, + label_data, + transaction_hash, + value, + block_number, + timestamp, + ) in events: + raw_event = NFTEvent( + event_id=event_id, + event_type=event_types[label], + nft_address=address, + token_id=label_data["tokenId"], + from_address=label_data["from"], + to_address=label_data["to"], + transaction_hash=transaction_hash, + value=value, + block_number=block_number, + timestamp=timestamp, + ) + raw_events_batch.append(raw_event) + + logger.info(f"Adding {len(raw_events_batch)} to database") + insert_events( + datastore_conn, raw_events_batch + ) # TODO REMOVED WEB3 enrich, since node is down + insert_checkpoint(datastore_conn, event_type, batch_end + initial_offset) + pbar.update(batch_end - batch_start + 1) + batch_start = batch_end + 1 + batch_end = min(batch_end + batch_size, len(created_at_list)) + + +def create_dataset( + datastore_conn: sqlite3.Connection, + db_session: Session, + event_type: EventType, + bounds: Optional[BlockBounds] = None, + batch_size: int = 10, +) -> None: + """ + Creates Moonstream NFTs dataset in the given SQLite datastore. + """ + offset = get_checkpoint_offset(datastore_conn, event_type) + if offset is not None: + logger.info(f"Found checkpoint for {event_type.value}: offset = {offset}") + else: + offset = 0 + logger.info(f"Did not found any checkpoint for {event_type.value}") + + if event_type == EventType.ERC721: + add_contracts_metadata(datastore_conn, db_session, offset, batch_size) + else: + add_events( + datastore_conn, db_session, event_type, offset, bounds, batch_size, + ) + + +def add_contracts_metadata( + datastore_conn: sqlite3.Connection, + db_session: Session, + initial_offset: int = 0, + batch_size: int = 1000, +) -> None: + logger.info("Adding erc721 contract metadata") + query = ( + db_session.query(EthereumLabel.label_data, EthereumAddress.address) + .filter(EthereumLabel.label == EventType.ERC721.value) + .join(EthereumAddress, EthereumLabel.address_id == EthereumAddress.id) + .order_by(EthereumLabel.created_at, EthereumLabel.address_id) + ) + + offset = initial_offset + while True: + events = query.offset(offset).limit(batch_size).all() + if not events: + break + offset += len(events) + + events_batch: List[NFTMetadata] = [] + for label_data, address in events: + events_batch.append( + NFTMetadata( + address=address, + name=label_data.get("name", None), + symbol=label_data.get("symbol", None), + ) + ) + insert_address_metadata(datastore_conn, events_batch) + insert_checkpoint(datastore_conn, EventType.ERC721, offset) + logger.info(f"Already added {offset}") + + logger.info(f"Added total of {offset-initial_offset} nfts metadata") diff --git a/datasets/nfts/notebooks/.gitignore b/datasets/nfts/notebooks/.gitignore new file mode 100644 index 00000000..7897fa70 --- /dev/null +++ b/datasets/nfts/notebooks/.gitignore @@ -0,0 +1 @@ +img/ diff --git a/datasets/nfts/notebooks/nft_ownership.ipynb b/datasets/nfts/notebooks/nft_ownership.ipynb new file mode 100644 index 00000000..1f26f181 --- /dev/null +++ b/datasets/nfts/notebooks/nft_ownership.ipynb @@ -0,0 +1,1232 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "e2c7afd6-752c-477a-adcc-417eefd575f1", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sqlite3\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import nfts.dataset\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9f0e7f34-591b-4694-99d7-e20535afe33a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The Moonstream NFTs dataset\n", + "===========================\n", + "\n", + "To load the NFTs dataset from a SQLite file, run:\n", + ">>> ds = nfts.dataset.FromSQLite()\n", + "\n", + "This dataset consists of the following dataframes:\n", + "\n", + "Dataframe: nfts\n", + "Load using:\n", + ">>> nfts_df = ds.load_dataframe(, \"nfts\")\n", + "\n", + "Describes the NFT contracts represented in this dataset, with a name and symbol if they were available at time of crawl.\n", + "\n", + "Columns:\n", + "1. address: The Ethereum address of the NFT contract.\n", + "2. name: The name of the collection of NFTs that the contract represents.\n", + "3. symbol: The symbol of the collection of NFTs that the contract represents.\n", + "\n", + "- - -\n", + "\n", + "Dataframe: mints\n", + "Load using:\n", + ">>> mints_df = ds.load_dataframe(, \"mints\")\n", + "\n", + "All token mint events crawled in this dataset.\n", + "\n", + "Columns:\n", + "1. event_id: A unique event ID associated with the event.\n", + "2. transaction_hash: The hash of the transaction which triggered the event.\n", + "3. block_number: The transaction block in which the transaction was mined.\n", + "4. nft_address: The address of the NFT collection containing the minted token.\n", + "5. token_id: The ID of the token that was minted.\n", + "6. from_address: The \"from\" address for the transfer event. For a mint, this should be the 0 address: 0x0000000000000000000000000000000000000000.\n", + "7. to_address: The \"to\" address for the transfer event. This represents the owner of the freshly minted token.\n", + "8. transaction_value: The amount of WEI that were sent with the transaction in which the token was minted.\n", + "9. timestamp: The time at which the mint operation was mined into the blockchain (this is the timestamp for the mined block).\n", + "\n", + "- - -\n", + "\n", + "Dataframe: transfers\n", + "Load using:\n", + ">>> transfers_df = ds.load_dataframe(, \"transfers\")\n", + "\n", + "All token transfer events crawled in this dataset.\n", + "\n", + "Columns:\n", + "1. event_id: A unique event ID associated with the event.\n", + "2. transaction_hash: The hash of the transaction which triggered the event.\n", + "3. block_number: The transaction block in which the transaction was mined.\n", + "4. nft_address: The address of the NFT collection containing the transferred token.\n", + "5. token_id: The ID of the token that was transferred.\n", + "6. from_address: The \"from\" address for the transfer event. This is the address that owned the token at the *start* of the transfer.\n", + "7. to_address: The \"to\" address for the transfer event. This is the address that owned the token at the *end* of the transfer.\n", + "8. transaction_value: The amount of WEI that were sent with the transaction in which the token was transferred.\n", + "9. timestamp: The time at which the transfer operation was mined into the blockchain (this is the timestamp for the mined block).\n", + "\n", + "- - -\n", + "\n", + "Dataframe: current_owners\n", + "Load using:\n", + ">>> current_owners_df = ds.load_dataframe(, \"current_owners\")\n", + "\n", + "This table is derived from the nfts, mints, and transfers tables. It represents the current owner of each token in the dataset.\n", + "\n", + "Columns:\n", + "1. nft_address: The address of the NFT collection containing the token whose ownership we are denoting.\n", + "2. token_id: The ID of the token (inside the collection) whose ownership we are denoting.\n", + "3. owner: The address that owned the token at the time of construction of this dataset.\n", + "\n", + "- - -\n", + "\n", + "Dataframe: current_market_values\n", + "Load using:\n", + ">>> current_market_values_df = ds.load_dataframe(, \"current_market_values\")\n", + "\n", + "This table is derived from the nfts, mints, and transfers tables. It represents the current market value (in WEI) of each token in the dataset.\n", + "\n", + "Columns:\n", + "1. nft_address: The address of the NFT collection containing the token whose market value we are denoting.\n", + "2. token_id: The ID of the token (inside the collection) whose market value we are denoting.\n", + "3. market_value: The estimated market value of the token at the time of construction of this dataset.\n", + "\n", + "For this dataset, we estimate the market value as the last non-zero transaction value for a transfer involving this token.\n", + "This estimate may be inaccurate for some transfers (e.g. multiple token transfers made by an escrow contract in a single transaction)\n", + "but ought to be reasonably accurate for a large majority of tokens.\n", + "\n", + "- - -\n", + "\n", + "Dataframe: transfer_statistics_by_address\n", + "Load using:\n", + ">>> transfer_statistics_by_address_df = ds.load_dataframe(, \"transfer_statistics_by_address\")\n", + "\n", + "This table is derived from the nfts, mints, and transfers tables. For each address that participated in\n", + "at least one NFT transfer between April 1, 2021 and September 25, 2021, this table shows exactly how many NFTs that address transferred to\n", + "other addresses and how many NFT transfers that address was the recipient of.\n", + "\n", + "Columns:\n", + "1. address: An Ethereum address that participated in at least one NFT transfer between April 1, 2021 and September 25, 2021.\n", + "2. transfers_out: The number of NFTs that the given address transferred to any other address between April 1, 2021 and September 25, 2021.\n", + "3. transfers_in: The number of NFTs that any other address transferred to given address between April 1, 2021 and September 25, 2021.\n", + "\n", + "- - -\n", + "\n", + "Matrix: ownership_transitions\n", + "\n", + "ownership_transitions is an adjacency matrix which counts the number of times that a token was transferred from a source address (indexed by the rows of the matrix) to a target address (indexed by the columns of the matrix).\n", + "\n", + "These counts only include data about mints and transfers made between April 1, 2021 and September 25, 2021. We also denote the current owners of an NFT as having transitioned\n", + "the NFT from themselves back to themselves. This gives some estimate of an owner retaining the NFT in the given time period.\n", + "\n", + "Load this matrix as follows:\n", + ">>> indexed_addresses, transitions = ds.load_ownership_transitions()\n", + "\n", + "- \"indexed_addresses\" is a list denoting the address that each index (row/column) in the matrix represents.\n", + "- \"transitions\" is a numpy ndarray containing the matrix, with source addresses on the row axis and target addresses on the column axis.\n", + "\n", + "- - -\n" + ] + } + ], + "source": [ + "nfts.dataset.explain()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b25c369a-3751-4e18-a539-f8e950982537", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Path to SQLite database containing the NFTs dataset: /home/neeraj/data/nfts/nfts.sqlite\n" + ] + } + ], + "source": [ + "DATABASE = os.path.expanduser(\"~/data/nfts/nfts.sqlite\")\n", + "print(f\"Path to SQLite database containing the NFTs dataset: {DATABASE}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b7a608aa-d304-4c53-9073-bb3d2379482c", + "metadata": {}, + "outputs": [], + "source": [ + "ds = nfts.dataset.FromSQLite(DATABASE)" + ] + }, + { + "cell_type": "markdown", + "id": "8977af98-ff38-48c9-bc3a-7a11d2b7e8fc", + "metadata": { + "tags": [] + }, + "source": [ + "### Who owns NFTs?" + ] + }, + { + "cell_type": "markdown", + "id": "17564e85-99bc-4456-8353-ef892b042921", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4793b4e8-3138-4a85-8266-09c42b29eb3e", + "metadata": {}, + "outputs": [], + "source": [ + "current_owners_df = ds.load_dataframe(\"current_owners\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a52f616b-0441-46a1-b8b3-c117464b35d8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nft_addresstoken_idowner
00x00000000000b7F8E8E8Ad148f9d53303Bfe2079600xb776cAb26B9e6Be821842DC0cc0e8217489a4581
10x00000000000b7F8E8E8Ad148f9d53303Bfe2079610x8A73024B39A4477a5Dc43fD6360e446851AD1D28
20x00000000000b7F8E8E8Ad148f9d53303Bfe20796100x5e5C817E9264B46cBBB980198684Ad9d14f3e0B4
30x00000000000b7F8E8E8Ad148f9d53303Bfe20796110x8376f63c13b99D3eedfA51ddd77Ff375279B3Ba0
40x00000000000b7F8E8E8Ad148f9d53303Bfe20796120xb5e34552F32BA9226C987769BF6555a538510BA8
\n", + "
" + ], + "text/plain": [ + " nft_address token_id \\\n", + "0 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 0 \n", + "1 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 1 \n", + "2 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 10 \n", + "3 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 11 \n", + "4 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 12 \n", + "\n", + " owner \n", + "0 0xb776cAb26B9e6Be821842DC0cc0e8217489a4581 \n", + "1 0x8A73024B39A4477a5Dc43fD6360e446851AD1D28 \n", + "2 0x5e5C817E9264B46cBBB980198684Ad9d14f3e0B4 \n", + "3 0x8376f63c13b99D3eedfA51ddd77Ff375279B3Ba0 \n", + "4 0xb5e34552F32BA9226C987769BF6555a538510BA8 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "current_owners_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5ab1dbb2-0d93-4bbd-a179-8f6735089f2b", + "metadata": {}, + "outputs": [], + "source": [ + "top_owners_df = current_owners_df.groupby([\"owner\"], as_index=False).size().rename(columns={\"size\": \"num_tokens\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "223b7d4b-0362-4ce8-8ef7-4bb7f0b88ab8", + "metadata": {}, + "outputs": [], + "source": [ + "top_owners_df.sort_values(\"num_tokens\", inplace=True, ascending=False)" + ] + }, + { + "cell_type": "markdown", + "id": "89964e2f-458d-4e09-8f4b-cc8984a5f55f", + "metadata": {}, + "source": [ + "#### Top 20 NFT owners" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a84b69f5-1295-4ebc-b15e-34425e6ebff9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ownernum_tokens
72720x02E4103b8A3c55AcDDF298311a9928f9Fe27822C100045
00x000000000000000000000000000000000000000083548
4702270xE052113bd7D7700d623414a0a4585BCaE754E9d551028
5620450xcDA72070E455bb31C7690a170224Ce43623d0B6f50131
3692280x96bEE49d3386d674bF4E956D9B3ce61b9540409D36751
4390860xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa32905
4272700xBa0d01220a7CeA942596123102535F800f55876332691
70x000000000000000000000000000000000000dEaD19758
2770x0008d343091EF8BD3EFA730F6aAE5A26a285C7a212137
4547050xD387A6E4e84a6C86bd90C158C6028A58CC8Ac45911497
\n", + "
" + ], + "text/plain": [ + " owner num_tokens\n", + "7272 0x02E4103b8A3c55AcDDF298311a9928f9Fe27822C 100045\n", + "0 0x0000000000000000000000000000000000000000 83548\n", + "470227 0xE052113bd7D7700d623414a0a4585BCaE754E9d5 51028\n", + "562045 0xcDA72070E455bb31C7690a170224Ce43623d0B6f 50131\n", + "369228 0x96bEE49d3386d674bF4E956D9B3ce61b9540409D 36751\n", + "439086 0xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa 32905\n", + "427270 0xBa0d01220a7CeA942596123102535F800f558763 32691\n", + "7 0x000000000000000000000000000000000000dEaD 19758\n", + "277 0x0008d343091EF8BD3EFA730F6aAE5A26a285C7a2 12137\n", + "454705 0xD387A6E4e84a6C86bd90C158C6028A58CC8Ac459 11497" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "top_owners_df.head(10)" + ] + }, + { + "cell_type": "markdown", + "id": "3590f26f-d486-4477-bf1d-b849ecf0f19b", + "metadata": { + "tags": [] + }, + "source": [ + "#### NFT ownership histogram\n", + "\n", + "The following is the cumulative distribution of the number of addressses owning $n$ NFTs for each $n \\geq 1$." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "89e9fa88-8997-4e89-a1a6-5f4dc0912be0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xlabel(\"Number of tokens owned - n\")\n", + "plt.ylabel(\"Number of addresses owning n tokens (log scale)\")\n", + "_ = plt.hist(top_owners_df[\"num_tokens\"], bins=100, log=True)\n", + "plt.savefig(\"img/tokens_owned_histogram_log.png\", transparent=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e98d9d53-4068-4178-9cc8-603dc6ed824c", + "metadata": {}, + "source": [ + "The *overwhelming* number of NFT owners each only own a small number of tokens. There are very few addresses that own hundreds or even thousands of tokens.\n", + "\n", + "**Note:** This histogram has been charted on a logarithmic scale. We have done this because the true distribution of the count of number of NFTs owned by each address follows an [exponential distribution](https://en.wikipedia.org/wiki/Exponential_distribution). It would be difficult to visually tell apart the differences on ownership patterns over all owners if we charted this distribution using a linear scale." + ] + }, + { + "cell_type": "markdown", + "id": "11989c70-fe49-41c1-b28a-77d9b26fd465", + "metadata": {}, + "source": [ + "Any address which owns thousands of tokens is either purchasing those tokens automatically (if they exist on multiple contracts) or is financing the collections in which they own tokens. First, let us analye the ownership trends amount addresses which do not own large numbers of tokens. This will help us estimate trends in NFT ownership among non-algorithmic and non-smart contract owners.\n", + "\n", + "For this, we set a `scale_cutoff` and only consider addresses which own a number of tokens not exceeding that cutoff.\n", + "\n", + "This allows us to estimate on a linear scale, rather than a logarithmic one, how NFT ownership is distributed among human owners." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6fd8e3ba-a943-4afc-8d9f-82d0f74e2d3f", + "metadata": {}, + "outputs": [], + "source": [ + "scale_cutoff = 1500" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "93681f2b-f6a8-440f-a831-ad43f5beb946", + "metadata": {}, + "outputs": [], + "source": [ + "low_scale_owners = [num_tokens for num_tokens in top_owners_df[\"num_tokens\"] if num_tokens <= scale_cutoff]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ad904ada-cffa-4dbe-8bd8-23a3cb33af50", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xlabel(f\"Number of tokens owned - n <= {scale_cutoff}\")\n", + "plt.ylabel(\"Number of addresses owning n tokens\")\n", + "_ = plt.hist(low_scale_owners, bins=int(scale_cutoff/5))\n", + "plt.savefig(\"img/tokens_owned_histogram_low_scale.png\", transparent=True)" + ] + }, + { + "cell_type": "markdown", + "id": "3ea46e96-4771-4ef3-ac4a-a6cb310b362c", + "metadata": {}, + "source": [ + "Even at this scale, it is more instructive to view the distribution on a logarithmic scale:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3a9415c3-a5f0-4c87-a6e7-69112c2e6c0f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xlabel(f\"Number of tokens owned - n <= {scale_cutoff}\")\n", + "plt.ylabel(\"Number of addresses owning n tokens (log scale)\")\n", + "_ = plt.hist(low_scale_owners, bins=int(scale_cutoff/50), log=True)\n", + "plt.savefig(\"img/tokens_owned_histogram_log_low_scale.png\", transparent=True)" + ] + }, + { + "cell_type": "markdown", + "id": "1febf072-b4be-4460-8ef5-88715cb31230", + "metadata": {}, + "source": [ + "This analysis shows that the *decentralized* NFT market is indeed decentralized, with proportionally few NFTs being held by addresses which are minting and purchasing NFTs at industrial scale.\n", + "\n", + "**There are vanishingly few large scale NFT owners on the Ethereum blockchain.**\n", + "\n", + "Note that this is an analysis of addresses, not real-world entities. It is possible for a single person or organization to use a distinct Ethereum address to control each NFT they own. This would currently be difficult enough operationally that only a handful of players in the NFT market are probably doing it. Even this would yield to a further network analysis of where the *funds* for each NFT purchase were coming from." + ] + }, + { + "cell_type": "markdown", + "id": "0a597bc5-24a5-49a1-b6b5-082770d36ee4", + "metadata": {}, + "source": [ + "### The shapes of NFT collections\n", + "\n", + "NFTs are released in collections, with a single contract accounting for multiple tokens.\n", + "\n", + "Are there differences between ownership distributions of NFTs like the [Ethereum Name Service (ENS)](https://ens.domains/), which have utility beyond their artistic value, and those that do not currently have such use cases?\n", + "\n", + "One way we can answer this question is to see how much information each NFT collection gives us about individual owners of tokens in that collection. We will do this by treating each collection as a probability distribution over owners of tokens from that collection. If the collection $C$ consists of $n$ tokens and an address $A$ owns $m$ of those tokens, we will assign that address a probability of $p_A = m/n$ in the collection's associated probability distribution. Then we will calculate the entropy:\n", + "\n", + "$$H(C) = - \\sum_{A} p_A \\log(p_A).$$\n", + "\n", + "Here, the sum is over all addresses $A$ that own at least one token from $C$.\n", + "\n", + "$H(C)$ simultaneously contains information about:\n", + "1. How many tokens were issued as part of the collection $C$.\n", + "2. How evenly the tokens in $C$ are distributed over the addresses $A$ which own those tokens." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8a08e304-b5ff-4e45-a12c-6fd562fe5255", + "metadata": {}, + "outputs": [], + "source": [ + "contract_owners_df = current_owners_df.groupby([\"nft_address\", \"owner\"], as_index=False).size().rename(columns={\"size\": \"num_tokens\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9fd82a56-fe0c-4f02-b996-c5bf0feea5e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nft_addressownernum_tokens
00x00000000000b7F8E8E8Ad148f9d53303Bfe207960x429a635eD4DaF9529C07d5406D466B349EC343613
10x00000000000b7F8E8E8Ad148f9d53303Bfe207960x5e5C817E9264B46cBBB980198684Ad9d14f3e0B45
20x00000000000b7F8E8E8Ad148f9d53303Bfe207960x8376f63c13b99D3eedfA51ddd77Ff375279B3Ba01
30x00000000000b7F8E8E8Ad148f9d53303Bfe207960x83D7Da9E572C5ad14caAe36771022C43AF084dbF5
40x00000000000b7F8E8E8Ad148f9d53303Bfe207960x8A73024B39A4477a5Dc43fD6360e446851AD1D285
\n", + "
" + ], + "text/plain": [ + " nft_address \\\n", + "0 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 \n", + "1 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 \n", + "2 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 \n", + "3 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 \n", + "4 0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 \n", + "\n", + " owner num_tokens \n", + "0 0x429a635eD4DaF9529C07d5406D466B349EC34361 3 \n", + "1 0x5e5C817E9264B46cBBB980198684Ad9d14f3e0B4 5 \n", + "2 0x8376f63c13b99D3eedfA51ddd77Ff375279B3Ba0 1 \n", + "3 0x83D7Da9E572C5ad14caAe36771022C43AF084dbF 5 \n", + "4 0x8A73024B39A4477a5Dc43fD6360e446851AD1D28 5 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "contract_owners_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7192cc40-c04f-4e91-b731-5ba6ee749fde", + "metadata": {}, + "outputs": [], + "source": [ + "contract_owners_groups = contract_owners_df.groupby([\"nft_address\"])\n", + "\n", + "entropies = {}\n", + "\n", + "for contract_address, owners_group in contract_owners_groups:\n", + " total_supply = owners_group[\"num_tokens\"].sum()\n", + " owners_group[\"p\"] = owners_group[\"num_tokens\"]/total_supply\n", + " owners_group[\"log(p)\"] = np.log2(owners_group[\"p\"])\n", + " owners_group[\"-plog(p)\"] = (-1) * owners_group[\"p\"] * owners_group[\"log(p)\"]\n", + " entropy = owners_group[\"-plog(p)\"].sum()\n", + " entropies[contract_address] = entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2dc080a0-8dd1-49ab-be2d-cc1eed5d0ff4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xlabel(f\"Ownership entropy of NFT collection\")\n", + "plt.ylabel(\"Number of NFT collections\")\n", + "_ = plt.hist(entropies.values(), bins=80)\n", + "plt.savefig(\"img/ownership_entropy.png\", transparent=True)" + ] + }, + { + "cell_type": "markdown", + "id": "d197f6b6-65d8-4f84-9f12-9d31840adf34", + "metadata": {}, + "source": [ + "#### Collections at the extremes\n", + "\n", + "It is interesting to get a sense of what the collections look like at either extreme of this entropy spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9e1bca5a-be9d-46c6-b21a-ae1a648b7fa7", + "metadata": {}, + "outputs": [], + "source": [ + "sorted_entropies = [it for it in entropies.items()]\n", + "sorted_entropies.sort(key=lambda it: it[1], reverse=True)\n", + "entropies_df = pd.DataFrame.from_records(sorted_entropies, columns=[\"nft_address\", \"entropy\"])" + ] + }, + { + "cell_type": "markdown", + "id": "c060fa53-245b-4774-8fba-0bb0aa2aed8d", + "metadata": {}, + "source": [ + "##### Highest entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c80abbc5-2268-47a7-b2df-f93450a4a7d0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nft_addressentropy
00x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA8513.864019
10x60F80121C31A0d46B5279700f9DF786054aa5eE513.831032
20xC36442b4a4522E871399CD717aBDD847Ab11FE8813.742724
30xabc207502EA88D9BCa29B95Cd2EeE5F0d793641813.714889
40x5537d90A4A2DC9d9b37BAb49B490cF67D4C54E9113.285761
\n", + "
" + ], + "text/plain": [ + " nft_address entropy\n", + "0 0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85 13.864019\n", + "1 0x60F80121C31A0d46B5279700f9DF786054aa5eE5 13.831032\n", + "2 0xC36442b4a4522E871399CD717aBDD847Ab11FE88 13.742724\n", + "3 0xabc207502EA88D9BCa29B95Cd2EeE5F0d7936418 13.714889\n", + "4 0x5537d90A4A2DC9d9b37BAb49B490cF67D4C54E91 13.285761" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "entropies_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "e0726c04-1349-4b8d-919e-7547cfffd6e7", + "metadata": {}, + "source": [ + "[`0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85`](https://etherscan.io/address/0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85) is the [Ethereum Name Service](https://ens.domains/).\n", + "\n", + "[`0x60F80121C31A0d46B5279700f9DF786054aa5eE5`](https://etherscan.io/address/0x60F80121C31A0d46B5279700f9DF786054aa5eE5) is [Rarible's](https://rarible.com/) governance token ([details](https://www.notion.so/rarible/Rarible-com-FAQ-a47b276aa1994f7c8e3bc96d700717c5)). Their aidrops are the cause of this high entropy.\n", + "\n", + "[`0xC36442b4a4522E871399CD717aBDD847Ab11FE88`](https://etherscan.io/address/0xC36442b4a4522E871399CD717aBDD847Ab11FE88) is [Uniswap's](https://uniswap.org/) position NFT, representing [non-fungible liquidity positions](https://uniswap.org/blog/uniswap-v3/) on Uniswap v3.\n", + "\n", + "[`0xabc207502EA88D9BCa29B95Cd2EeE5F0d7936418`](https://etherscan.io/address/0xabc207502EA88D9BCa29B95Cd2EeE5F0d7936418) are badges for [Yield Guild Games](https://yieldguild.io/), which seem to have been airdropped to many existing NFT holders.\n", + "\n", + "[`0x5537d90A4A2DC9d9b37BAb49B490cF67D4C54E91`](https://etherscan.io/address/0x5537d90A4A2DC9d9b37BAb49B490cF67D4C54E91) is the [OneDayPunk](https://punkscape.xyz/) collection, which has gained popularity as a down-market Crypto Punks alternative.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "786574c8-4226-43a4-b3e3-81fb8667583f", + "metadata": {}, + "source": [ + "##### Zero entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d4c9d052-f9dd-4e4f-9716-31ddd8692294", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nft_addressentropy
92870xfe00276E0A87E5e54ADD7C5FC6cdD80B363DEe040.0
92880xfe6b0dAccBAE832b0283CfBFEBe9543B6b7B10a80.0
92890xff881E3008f081707bdDA1644e6c92DB9599C1C00.0
92900xffC6c59F34Cd9f8861012FDDd0c7F1323082Ab860.0
92910xffCb352Fb3FdbEAab3F662378db28B8D151f210c0.0
\n", + "
" + ], + "text/plain": [ + " nft_address entropy\n", + "9287 0xfe00276E0A87E5e54ADD7C5FC6cdD80B363DEe04 0.0\n", + "9288 0xfe6b0dAccBAE832b0283CfBFEBe9543B6b7B10a8 0.0\n", + "9289 0xff881E3008f081707bdDA1644e6c92DB9599C1C0 0.0\n", + "9290 0xffC6c59F34Cd9f8861012FDDd0c7F1323082Ab86 0.0\n", + "9291 0xffCb352Fb3FdbEAab3F662378db28B8D151f210c 0.0" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "entropies_df.tail()" + ] + }, + { + "cell_type": "markdown", + "id": "49008c09-4fec-482a-b080-8836922de57b", + "metadata": {}, + "source": [ + "[`0xfe00276E0A87E5e54ADD7C5FC6cdD80B363DEe04`](https://etherscan.io/address/0xfe00276E0A87E5e54ADD7C5FC6cdD80B363DEe04).\n", + "\n", + "[`0xfe6b0dAccBAE832b0283CfBFEBe9543B6b7B10a8`](https://etherscan.io/address/0xfe6b0dAccBAE832b0283CfBFEBe9543B6b7B10a8).\n", + "\n", + "[`0xff881E3008f081707bdDA1644e6c92DB9599C1C0`](https://etherscan.io/address/0xff881E3008f081707bdDA1644e6c92DB9599C1C0).\n", + "\n", + "[`0xffC6c59F34Cd9f8861012FDDd0c7F1323082Ab86`](https://etherscan.io/address/0xffC6c59F34Cd9f8861012FDDd0c7F1323082Ab86).\n", + "\n", + "[`0xffCb352Fb3FdbEAab3F662378db28B8D151f210c`](https://etherscan.io/address/0xffCb352Fb3FdbEAab3F662378db28B8D151f210c).\n", + "\n", + "All these projects are NFTs that did see release in the time period for which we collected data, but saw no further activity. That means that these are either failed projects or projects that have not yet done an official launch." + ] + }, + { + "cell_type": "markdown", + "id": "598be2d9-5ade-45cd-8777-70a0d61cae34", + "metadata": {}, + "source": [ + "##### Low entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ca65053e-9cb7-4698-94b6-7da01e509bb7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nft_addressentropy
40250x08CdCF9ba0a4b5667F5A59B78B60FbEFb145e64c2.004886
40260xA4fF6019f9DBbb4bCC61Fa8Bd5C39F36ee4eB1642.003856
40270xB66c7Ca15Af1f357C57294BAf730ABc77FF949402.003756
40280x5f98B87fb68f7Bb6F3a60BD6f0917723365444C12.002227
40290x374DBF0dF7aBc89C2bA776F003E725177Cb357502.001823
\n", + "
" + ], + "text/plain": [ + " nft_address entropy\n", + "4025 0x08CdCF9ba0a4b5667F5A59B78B60FbEFb145e64c 2.004886\n", + "4026 0xA4fF6019f9DBbb4bCC61Fa8Bd5C39F36ee4eB164 2.003856\n", + "4027 0xB66c7Ca15Af1f357C57294BAf730ABc77FF94940 2.003756\n", + "4028 0x5f98B87fb68f7Bb6F3a60BD6f0917723365444C1 2.002227\n", + "4029 0x374DBF0dF7aBc89C2bA776F003E725177Cb35750 2.001823" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "entropies_df.loc[entropies_df[\"entropy\"] > 2].tail()" + ] + }, + { + "cell_type": "markdown", + "id": "0100251f-e2f3-4665-98cf-81594ecc0145", + "metadata": {}, + "source": [ + "[`0x08CdCF9ba0a4b5667F5A59B78B60FbEFb145e64c`](https://etherscan.io/address/0x08CdCF9ba0a4b5667F5A59B78B60FbEFb145e64c) is called [WorldCupToken](https://coinclarity.com/dapp/worldcuptoken/) and was last active 4 years ago. Their recent increase in activity could be in anticipation of the next soccer world cup in 2022.\n", + "\n", + "[`0xA4fF6019f9DBbb4bCC61Fa8Bd5C39F36ee4eB164`](https://etherscan.io/address/0xA4fF6019f9DBbb4bCC61Fa8Bd5C39F36ee4eB164) is associated with a project called [instigators](https://instigators.network/).\n", + "\n", + "[`0xB66c7Ca15Af1f357C57294BAf730ABc77FF94940`](https://etherscan.io/address/0xB66c7Ca15Af1f357C57294BAf730ABc77FF94940) is a token associated with something called the [Gems of Awareness Benefit](https://nftcalendar.io/event/gems-of-awareness-benefit-for-entheon-art-by-alex-grey-x-allyson-grey/).\n", + "\n", + "[`0x5f98B87fb68f7Bb6F3a60BD6f0917723365444C1`](https://etherscan.io/address/0x5f98B87fb68f7Bb6F3a60BD6f0917723365444C1) is [SHADYCON, an NFT associated with Eminem which seems to have been marketed on Nifty Gateway](https://www.eminem.com/news/shadycon-x-nifty-gateway).\n", + "\n", + "[`0x374DBF0dF7aBc89C2bA776F003E725177Cb35750`](https://etherscan.io/address/0x374DBF0dF7aBc89C2bA776F003E725177Cb35750) is [WyldFrogz](https://twitter.com/WyldFrogz), a cryptopunks derivative that seems to have some kind of planet-saving theme." + ] + }, + { + "cell_type": "markdown", + "id": "23ab64f9-85fb-4a12-87ef-a5f6295b43ce", + "metadata": {}, + "source": [ + "##### Medium entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "09997f43-5eeb-43a1-9e01-4076b7a4bc8e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nft_addressentropy
15640x0ae3c3A1504E41a6877De1B854C000EC64894bEa6.021144
15650x1ECA43C93D8e06FB91489818B4967014D748Da536.017002
15660xc57605Bef27ef91DbECc839e71E49574b98857Fc6.011324
15670xd3f69F10532457D35188895fEaA4C20B730EDe886.010405
15680xba61aEF92ebF174DbB39C97Dd29D0F2bd3D83d336.009679
\n", + "
" + ], + "text/plain": [ + " nft_address entropy\n", + "1564 0x0ae3c3A1504E41a6877De1B854C000EC64894bEa 6.021144\n", + "1565 0x1ECA43C93D8e06FB91489818B4967014D748Da53 6.017002\n", + "1566 0xc57605Bef27ef91DbECc839e71E49574b98857Fc 6.011324\n", + "1567 0xd3f69F10532457D35188895fEaA4C20B730EDe88 6.010405\n", + "1568 0xba61aEF92ebF174DbB39C97Dd29D0F2bd3D83d33 6.009679" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "entropies_df.loc[entropies_df[\"entropy\"] > 6].tail()" + ] + }, + { + "cell_type": "markdown", + "id": "f3f2dc22-d111-472b-a28f-076f12f98047", + "metadata": {}, + "source": [ + "[`0x0ae3c3A1504E41a6877De1B854C000EC64894bEa`](https://etherscan.io/address/0x0ae3c3A1504E41a6877De1B854C000EC64894bEa) is the [Circleorzo NFT](https://opensea.io/collection/circleorzo), a collection of images of procedurally generated circles.\n", + "\n", + "[`0x1ECA43C93D8e06FB91489818B4967014D748Da53`](https://etherscan.io/address/0x1ECA43C93D8e06FB91489818B4967014D748Da53) is [Cowboy Punks](https://twitter.com/cowboypunks?lang=en), which appeals to blockheads that prefer westerns to cyberpunk.\n", + "\n", + "[`0xc57605Bef27ef91DbECc839e71E49574b98857Fc`](https://etherscan.io/address/0xc57605Bef27ef91DbECc839e71E49574b98857Fc) seems to be associated with the [Enigma Project](https://www.producthunt.com/posts/enigma-project) and control access to puzzle games.\n", + "\n", + "[`0xd3f69F10532457D35188895fEaA4C20B730EDe88`](https://etherscan.io/address/0xd3f69F10532457D35188895fEaA4C20B730EDe88) is something called hte [RTFKT Capsule Space Drip](https://rtfkt.com/spacedrip) which I do not understand and feel too old to have a hope of ever understanding. The important thing is that it seems these NFTs can be redeemed for a physical object called a space drip. [Here's a blog post about it](https://www.one37pm.com/nft/gaming/space-drip-rtfkt-loopify).\n", + "\n", + "[`0xba61aEF92ebF174DbB39C97Dd29D0F2bd3D83d33`](https://etherscan.io/address/0xba61aEF92ebF174DbB39C97Dd29D0F2bd3D83d33) is an NFT project called [Dommies](https://twitter.com/DommiesNFT)." + ] + }, + { + "cell_type": "markdown", + "id": "158b1714-083d-48fa-820a-c238b510de29", + "metadata": {}, + "source": [ + "##### Entropy as a measure of quality\n", + "\n", + "Based on this analysis, the ownership entropy of an NFT collection shows promise as a measure of its quality. There are certainly examples of high entropy NFT collections (like Rarible's governance token) which have that kind of entropy simply because they have been airdropped at scale. It remains to be seen what the value of these mass airdropped tokens will be in the long term.\n", + "\n", + "At the very least, the entropy measurement indicates that there is a lot of money behind those releases. This is in contrast to lower entropy releases promising thousands of tokens and only minting tens of them." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/datasets/nfts/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb new file mode 100644 index 00000000..b9acefe5 --- /dev/null +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -0,0 +1,1780 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import sqlite3\n", + "import numpy as np\n", + "from matplotlib.pyplot import figure\n", + "\n", + "import warnings # current version of seaborn generates a bunch of warnings that we'll ignore\n", + "warnings.filterwarnings(\"ignore\")\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "sns.set(style=\"white\", color_codes=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "conTXs = sqlite3.connect('../../../../../../datasets/nfts.sqlite')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", + "num_df[\"timestamp\"] = pd.to_datetime(num_df.timestamp, unit='s', errors='coerce')\n", + "num_df.set_index(\"timestamp\")\n", + "num_df = num_df.resample(\"1440min\", label='right', on='timestamp').sum()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'NFT transfers value over time')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set the width and height of the figure\n", + "plt.figure(figsize=(12,6))\n", + "# Line chart showing the number of visitors to each museum over time\n", + "ax = sns.lineplot(data=num_df, x=\"timestamp\", y=\"transaction_value\")\n", + "ax.set(xlabel='timestamp', ylabel='Total value')\n", + "plt.title(\"NFT transfers value over time\")\n", + "# Add title" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of unique addresses: 6765\n" + ] + } + ], + "source": [ + "print(\"number of unique addresses:\", transfers[\"nft_address\"].nunique())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# num_df = (transfers[[\"nft_address\", \"transaction_value\", \"timestamp\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#create data frame where group together from_addresses and count size of each group (how many TX each address did in total)\n", + "from_series = transfers[\"from_address\"].groupby(transfers[\"from_address\"]).size()\n", + "#create data frame where group together from_addresses and count size of each group (how many TX each address did in total)\n", + "to_series = transfers[\"to_address\"].groupby(transfers[\"to_address\"]).size()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame()\n", + "df = df.join(to_series.rename(\"to_count\"), how='outer')\n", + "df = df.join(from_series.rename('from_count'), how='outer')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(24,24))\n", + "fig, axs = plt.subplots(1, 2)\n", + "fig.set_size_inches(24, 5, forward=True)\n", + "fig.suptitle('Numbers of NFT transactions per address')\n", + "axs[0].hist(df[\"from_count\"], density=False, alpha=0.75, log=True, bins=20, color='orange')\n", + "axs[0].set_title(\"NFTs Sent from an address\")\n", + "axs[1].hist(df[\"to_count\"], density=False, alpha=0.75, log=True, bins=20)\n", + "axs[1].set_title(\"NFTs received to an address\")\n", + "plt.setp(axs[0], xlabel='Number of transactions out', ylabel='Number of addresses')\n", + "plt.setp(axs[1], xlabel='Number of transactions in', ylabel='Number of addresses')\n", + "print(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "df_small=df[df[\"to_count\"]<10]\n", + "df_small=df_small[df_small[\"from_count\"]<10]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(24,24))\n", + "fig, axs = plt.subplots(1, 2)\n", + "fig.set_size_inches(24, 5, forward=True)\n", + "fig.suptitle('Numbers of NFT transactions per address')\n", + "axs[0].hist(df_small[\"from_count\"], density=False, alpha=0.75, log=False, bins=9, color='orange')\n", + "axs[0].set_title(\"NFTs Sent from an address\")\n", + "axs[1].hist(df_small[\"to_count\"], density=False, alpha=0.75, log=False, bins=9)\n", + "axs[1].set_title(\"NFTs received to an address\")\n", + "plt.setp(axs[0], xlabel='Number of transactions out', ylabel='Number of addresses')\n", + "plt.setp(axs[1], xlabel='Number of transactions in', ylabel='Number of addresses')\n", + "print(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "whales_tx=df[df[\"from_count\"]>60000]\n", + "whales_rx=df[df[\"to_count\"]>60000]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
to_countfrom_count
0x0000000000000000000000000000000000000000119978.0NaN
0xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa74608.01.0
0xcDA72070E455bb31C7690a170224Ce43623d0B6f76645.036116.0
\n", + "
" + ], + "text/plain": [ + " to_count from_count\n", + "0x0000000000000000000000000000000000000000 119978.0 NaN\n", + "0xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa 74608.0 1.0\n", + "0xcDA72070E455bb31C7690a170224Ce43623d0B6f 76645.0 36116.0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "whales_rx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Whales RX info:\n", + "0x0000000000000000000000000000000000000000 - burn address\n", + "\n", + "[0xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa](https://etherscan.io/address/0xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa) / [creator](https://etherscan.io/address/0xC69b4c6fFDBaF843A0d0588c99E3C67f27069BEa) / info: `ENS: ETH Registrar Controller `\n", + "\n", + "[0xcDA72070E455bb31C7690a170224Ce43623d0B6f](https://etherscan.io/address/0xcDA72070E455bb31C7690a170224Ce43623d0B6f) / [creator](https://etherscan.io/address/0x95271d54d6e0d88b3825f89a766f97b8b7e8af82) / info: https://foundation.app" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
to_countfrom_count
0x283Af0B28c62C092C9727F1Ee09c02CA627EB7F52.0140875.0
0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fANaN106620.0
\n", + "
" + ], + "text/plain": [ + " to_count from_count\n", + "0x283Af0B28c62C092C9727F1Ee09c02CA627EB7F5 2.0 140875.0\n", + "0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA NaN 106620.0" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "whales_tx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Whales TX info:\n", + "\n", + "[0x283Af0B28c62C092C9727F1Ee09c02CA627EB7F5](https://etherscan.io/address/0x283Af0B28c62C092C9727F1Ee09c02CA627EB7F5) / [creator](https://etherscan.io/address/0x4fe4e666be5752f1fdd210f4ab5de2cc26e3e0e8) / info: `ENS: ETH Registrar Controller`\n", + "\n", + "[0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA](https://etherscan.io/address/0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA) not a contract! / info: `???`" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sharks_tx=df[df[\"from_count\"]>20e3]\n", + "sharks_rx=df[df[\"to_count\"]>20e3]\n", + "sharks_tx=sharks_tx[sharks_tx[\"from_count\"]<60e3]\n", + "sharks_rx=sharks_tx[sharks_tx[\"to_count\"]<60e3]\n", + "\n", + "plt.figure(figsize=(24,24))\n", + "fig, axs = plt.subplots(1, 2)\n", + "fig.set_size_inches(24, 5, forward=True)\n", + "fig.suptitle('Numbers of NFT transactions per address')\n", + "axs[0].hist(sharks_tx[\"from_count\"], density=False, alpha=0.75, log=False, bins=100, color='orange')\n", + "axs[0].set_title(\"NFTs Sent from an address\")\n", + "axs[1].hist(sharks_rx[\"to_count\"], density=False, alpha=0.75, log=False, bins=9)\n", + "axs[1].set_title(\"NFTs received to an address\")\n", + "plt.setp(axs[0], xlabel='Number of transactions out', ylabel='Number of addresses')\n", + "plt.setp(axs[1], xlabel='Number of transactions in', ylabel='Number of addresses')\n", + "print(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
to_countfrom_count
0xE052113bd7D7700d623414a0a4585BCaE754E9d59552.031967.0
0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C14124.023128.0
0xcDA72070E455bb31C7690a170224Ce43623d0B6f76645.036116.0
\n", + "
" + ], + "text/plain": [ + " to_count from_count\n", + "0xE052113bd7D7700d623414a0a4585BCaE754E9d5 9552.0 31967.0\n", + "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C 14124.0 23128.0\n", + "0xcDA72070E455bb31C7690a170224Ce43623d0B6f 76645.0 36116.0" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sharks_tx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sharks TX info:\n", + "\n", + "[0xE052113bd7D7700d623414a0a4585BCaE754E9d5](https://etherscan.io/address/0xE052113bd7D7700d623414a0a4585BCaE754E9d5) / not a contract! / info: `Nifty Gateway: Omnibus `\n", + "\n", + "[0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C](https://etherscan.io/address/0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C) / not a contract! / info: `CryptoKitties: Sales Auction `\n", + "\n", + "[0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C](https://etherscan.io/address/0xcDA72070E455bb31C7690a170224Ce43623d0B6f) / [creator](https://etherscan.io/address/0x95271d54d6e0d88b3825f89a766f97b8b7e8af82) / info: https://foundation.app" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
to_countfrom_count
0xE052113bd7D7700d623414a0a4585BCaE754E9d59552.031967.0
0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C14124.023128.0
\n", + "
" + ], + "text/plain": [ + " to_count from_count\n", + "0xE052113bd7D7700d623414a0a4585BCaE754E9d5 9552.0 31967.0\n", + "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C 14124.0 23128.0" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sharks_rx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sharks RX info:\n", + "\n", + "[0xE052113bd7D7700d623414a0a4585BCaE754E9d5](https://etherscan.io/address/0xE052113bd7D7700d623414a0a4585BCaE754E9d5) / not a contract! / info: `Nifty Gateway: Omnibus `\n", + "\n", + "[0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C](https://etherscan.io/address/0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C) / not a contract! / info: `CryptoKitties: Sales Auction `\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#transfers not transactions\n", + "transactions_per_nft = transfers[\"nft_address\"].groupby(transfers[\"nft_address\"]).size()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.000000e+00\n", + "1 0.000000e+00\n", + "2 0.000000e+00\n", + "3 0.000000e+00\n", + "4 0.000000e+00\n", + "5 6.180000e+18\n", + "6 0.000000e+00\n", + "7 0.000000e+00\n", + "8 3.000000e+16\n", + "9 0.000000e+00\n", + "10 0.000000e+00\n", + "11 0.000000e+00\n", + "12 0.000000e+00\n", + "13 0.000000e+00\n", + "14 0.000000e+00\n", + "Name: transaction_value, dtype: float64" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transfers[\"transaction_value\"] = pd.to_numeric(transfers[\"transaction_value\"])\n", + "transfers[\"transaction_value\"] = transfers[\"transaction_value\"].fillna(0)\n", + "transfers[\"transaction_value\"].head(15)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
transaction_value
nft_address
0x00000000000b7F8E8E8Ad148f9d53303Bfe207960.000000e+00
0x000000000437b3CCE2530936156388Bff5578FC34.175880e+18
0x000000000A42C2791eEc307FFf43Fa5c640e3Ef70.000000e+00
0x000000F36EDb9d436Be73cDBf0DCa7dF3E6F3A500.000000e+00
0x00000633Df1228868270bAdB2B812E12e13fdB912.829000e+17
0x000E49C87d2874431567d38FF9548890aB39BAac1.399971e+19
0x001B4b85192aa034bff1524f181e3a7060e0dC301.800000e+17
0x0025Eae58dF9F636F261CFdFa98cAcb57779DF740.000000e+00
\n", + "
" + ], + "text/plain": [ + " transaction_value\n", + "nft_address \n", + "0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 0.000000e+00\n", + "0x000000000437b3CCE2530936156388Bff5578FC3 4.175880e+18\n", + "0x000000000A42C2791eEc307FFf43Fa5c640e3Ef7 0.000000e+00\n", + "0x000000F36EDb9d436Be73cDBf0DCa7dF3E6F3A50 0.000000e+00\n", + "0x00000633Df1228868270bAdB2B812E12e13fdB91 2.829000e+17\n", + "0x000E49C87d2874431567d38FF9548890aB39BAac 1.399971e+19\n", + "0x001B4b85192aa034bff1524f181e3a7060e0dC30 1.800000e+17\n", + "0x0025Eae58dF9F636F261CFdFa98cAcb57779DF74 0.000000e+00" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_value_per_nft = transfers[[\"nft_address\", \"transaction_value\"]].groupby(transfers[\"nft_address\"]).sum()\n", + "total_value_per_nft.head(8)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
transaction_valueinfo
nft_address
0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD2702.296429e+23None
0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D1.588150e+23None
0x60E4d786628Fea6478F785A6d7e704777c86a7c67.530649e+22None
0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc76.610220e+22None
0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D76.378142e+22None
0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D4.022007e+22None
0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a3.809675e+22None
0xBd3531dA5CF5857e7CfAA92426877b022e612cf83.797948e+22None
\n", + "
" + ], + "text/plain": [ + " transaction_value info\n", + "nft_address \n", + "0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 2.296429e+23 None\n", + "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D 1.588150e+23 None\n", + "0x60E4d786628Fea6478F785A6d7e704777c86a7c6 7.530649e+22 None\n", + "0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc7 6.610220e+22 None\n", + "0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D7 6.378142e+22 None\n", + "0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D 4.022007e+22 None\n", + "0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a 3.809675e+22 None\n", + "0xBd3531dA5CF5857e7CfAA92426877b022e612cf8 3.797948e+22 None" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "most_valuable_nfts = total_value_per_nft[\"transaction_value\"].sort_values(ascending=False).head(8)\n", + "most_valuable_nfts = most_valuable_nfts.to_frame()\n", + "most_valuable_nfts['info'] = None\n", + "most_valuable_nfts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### INFO:\n", + "[0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270](https://etherscan.io/address/0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270) Info: https://artblocks.io\n", + "\n", + "[0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D](https://etherscan.io/address/0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D) Info: https://boredapeyachtclub.com/#/\n", + "\n", + "[0x60E4d786628Fea6478F785A6d7e704777c86a7c6](https://etherscan.io/address/0x60E4d786628Fea6478F785A6d7e704777c86a7c6) Info: https://boredapeyachtclub.com/#/mayc\n", + "\n", + "[0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc7](https://etherscan.io/address/0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc7) Info: https://larvalabs.com/project/meebits\n", + "\n", + "[0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D7](https://etherscan.io/address/0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D7) Info: https://www.lootproject.com\n", + "\n", + "[0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D](https://etherscan.io/address/0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D) Info: https://www.0n1force.com\n", + "\n", + "[0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a](https://etherscan.io/address/0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a) Info: https://artblocks.io Old BLOCKS Token \n", + "\n", + "[0xBd3531dA5CF5857e7CfAA92426877b022e612cf8](https://etherscan.io/address/0xBd3531dA5CF5857e7CfAA92426877b022e612cf8) Info: https://www.pudgypenguins.io/#/" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
transaction_valueinfo
nft_address
0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD2702.296429e+23artblocks
0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D1.588150e+23BAYC Token
0x60E4d786628Fea6478F785A6d7e704777c86a7c67.530649e+22MAYC Token
0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc76.610220e+22Meebits
0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D76.378142e+22LOOT
0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D4.022007e+220n1force
0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a3.809675e+22Artblocks OLD
0xBd3531dA5CF5857e7CfAA92426877b022e612cf83.797948e+22pudgypenguins
\n", + "
" + ], + "text/plain": [ + " transaction_value info\n", + "nft_address \n", + "0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 2.296429e+23 artblocks\n", + "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D 1.588150e+23 BAYC Token\n", + "0x60E4d786628Fea6478F785A6d7e704777c86a7c6 7.530649e+22 MAYC Token\n", + "0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc7 6.610220e+22 Meebits\n", + "0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D7 6.378142e+22 LOOT\n", + "0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D 4.022007e+22 0n1force\n", + "0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a 3.809675e+22 Artblocks OLD\n", + "0xBd3531dA5CF5857e7CfAA92426877b022e612cf8 3.797948e+22 pudgypenguins" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "most_valuable_nfts.at['0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270', 'info'] = 'artblocks'\n", + "most_valuable_nfts.at['0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D', 'info'] = 'BAYC Token'\n", + "most_valuable_nfts.at['0x60E4d786628Fea6478F785A6d7e704777c86a7c6', 'info'] = 'MAYC Token'\n", + "most_valuable_nfts.at['0x7Bd29408f11D2bFC23c34f18275bBf23bB716Bc7', 'info'] = 'Meebits'\n", + "most_valuable_nfts.at['0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D7', 'info'] = 'LOOT'\n", + "most_valuable_nfts.at['0x3bf2922f4520a8BA0c2eFC3D2a1539678DaD5e9D', 'info'] = '0n1force'\n", + "most_valuable_nfts.at['0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a', 'info'] = 'Artblocks OLD'\n", + "most_valuable_nfts.at['0xBd3531dA5CF5857e7CfAA92426877b022e612cf8', 'info'] = 'pudgypenguins'\n", + "most_valuable_nfts" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Most valuable NFT conctract chart')" + ] + }, + "execution_count": 154, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "fig.set_size_inches(11.7, 8.27)\n", + "sns.barplot(y=most_valuable_nfts['info'], x=most_valuable_nfts['transaction_value']).set_title('Most valuable NFT conctract chart')" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
transaction_valuenft_addressinfo
timestamp
2021-01-01 01:10:001.761902e+170x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3aArtblocks OLD
2021-01-01 01:10:001.761902e+170x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3aArtblocks OLD
2021-01-01 01:10:001.761902e+170x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3aArtblocks OLD
2021-01-01 01:10:001.761902e+170x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3aArtblocks OLD
2021-01-01 01:10:001.761902e+170x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3aArtblocks OLD
............
2021-05-31 23:55:021.110000e+180xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
2021-05-31 23:55:348.000000e+170xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
2021-05-31 23:57:101.000000e+180xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
2021-05-31 23:57:100.000000e+000xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
2021-05-31 23:59:579.500000e+170xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
\n", + "

275100 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " transaction_value \\\n", + "timestamp \n", + "2021-01-01 01:10:00 1.761902e+17 \n", + "2021-01-01 01:10:00 1.761902e+17 \n", + "2021-01-01 01:10:00 1.761902e+17 \n", + "2021-01-01 01:10:00 1.761902e+17 \n", + "2021-01-01 01:10:00 1.761902e+17 \n", + "... ... \n", + "2021-05-31 23:55:02 1.110000e+18 \n", + "2021-05-31 23:55:34 8.000000e+17 \n", + "2021-05-31 23:57:10 1.000000e+18 \n", + "2021-05-31 23:57:10 0.000000e+00 \n", + "2021-05-31 23:59:57 9.500000e+17 \n", + "\n", + " nft_address info \n", + "timestamp \n", + "2021-01-01 01:10:00 0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a Artblocks OLD \n", + "2021-01-01 01:10:00 0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a Artblocks OLD \n", + "2021-01-01 01:10:00 0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a Artblocks OLD \n", + "2021-01-01 01:10:00 0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a Artblocks OLD \n", + "2021-01-01 01:10:00 0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a Artblocks OLD \n", + "... ... ... \n", + "2021-05-31 23:55:02 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D BAYC Token \n", + "2021-05-31 23:55:34 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D BAYC Token \n", + "2021-05-31 23:57:10 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D BAYC Token \n", + "2021-05-31 23:57:10 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D BAYC Token \n", + "2021-05-31 23:59:57 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D BAYC Token \n", + "\n", + "[275100 rows x 3 columns]" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get frame with values over time\n", + "num_df = pd.DataFrame()\n", + "#cast to numeric\n", + "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", + "#add nft_address column to it\n", + "num_df[\"nft_address\"]=transfers[\"nft_address\"]\n", + "#filter out only ones that are in most_popular_nft variable\n", + "num_df = num_df[num_df.nft_address.isin(list(most_valuable_nfts.index))]\n", + "#convert timestamp in to date time\n", + "num_df[\"timestamp\"] = pd.to_datetime(num_df.timestamp, unit='s', errors='coerce')\n", + "#set index as timestamp\n", + "num_df = num_df.set_index(\"timestamp\")\n", + "\n", + "num_df['info'] = None\n", + "for i in range(len(most_valuable_nfts)):\n", + " address = most_valuable_nfts.iloc[i].name\n", + " \n", + " num_df.loc[num_df.nft_address == address, 'info'] = most_valuable_nfts.at[address, 'info'] #most_valuable_nfts.at[num_df.iloc[i]['nft_address'], 'info']\n", + "\n", + "num_df" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [], + "source": [ + "#group timestamps by day, create column per each nft_address, aggregate transaction value by count and sum\n", + "new_df = num_df.groupby([pd.Grouper(freq='d'), 'nft_address', 'info'])['transaction_value'].agg(transaction_value=\"sum\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(24, 12))\n", + "# new_df.unstack()\n", + "ax = sns.lineplot(data=new_df, x='timestamp', y='transaction_value', hue='info',)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "nft_address\n", + "0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 386096\n", + "0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85 187809\n", + "0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 135308\n", + "0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405 128240\n", + "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d 70095\n", + "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D 34966\n", + "0x1A92f7381B9F03921564a437210bB9396471050C 29539\n", + "0xBd3531dA5CF5857e7CfAA92426877b022e612cf8 28764\n", + "Name: nft_address, dtype: int64" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "most_popular_nfts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### INFO:\n", + "[0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205](https://etherscan.io/address/0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205) Info: SOR token\n", + "\n", + "[0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85](https://etherscan.io/address/0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85) Info: ENS Base registrar\n", + "\n", + "[0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270](https://etherscan.io/address/0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270) Info: BLOCKS Token\n", + "\n", + "[0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405](https://etherscan.io/address/0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405) Info: FNDNFT Token\n", + "\n", + "[0x06012c8cf97BEaD5deAe237070F9587f8E7A266d](https://etherscan.io/address/0x06012c8cf97BEaD5deAe237070F9587f8E7A266d) Info: CryptoKitties Core\n", + "\n", + "[0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D](https://etherscan.io/address/0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D) Info: BAYC Token\n", + "\n", + "[0x1A92f7381B9F03921564a437210bB9396471050C](https://etherscan.io/address/0x1A92f7381B9F03921564a437210bB9396471050C) Info: COOL Token\n", + "\n", + "[0xBd3531dA5CF5857e7CfAA92426877b022e612cf8](https://etherscan.io/address/0xBd3531dA5CF5857e7CfAA92426877b022e612cf8) Info: PPG Token" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countinfo
nft_address
0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205386096SOR token
0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85187809ENS Base registrar
0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270135308BLOCKS Token
0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405128240FNDNFT Token
0x06012c8cf97BEaD5deAe237070F9587f8E7A266d70095CryptoKitties Core
0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D34966BAYC Token
0x1A92f7381B9F03921564a437210bB9396471050C29539COOL Token
0xBd3531dA5CF5857e7CfAA92426877b022e612cf828764PPG Token
\n", + "
" + ], + "text/plain": [ + " count info\n", + "nft_address \n", + "0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 386096 SOR token\n", + "0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85 187809 ENS Base registrar\n", + "0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 135308 BLOCKS Token\n", + "0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405 128240 FNDNFT Token\n", + "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d 70095 CryptoKitties Core\n", + "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D 34966 BAYC Token\n", + "0x1A92f7381B9F03921564a437210bB9396471050C 29539 COOL Token\n", + "0xBd3531dA5CF5857e7CfAA92426877b022e612cf8 28764 PPG Token" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "most_popular_nfts = transactions_per_nft.sort_values(ascending=False).head(8)\n", + "most_popular_nfts = most_popular_nfts.to_frame()\n", + "most_valuable_nfts['info'] = None\n", + "most_popular_nfts.at['0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205', 'info'] = 'SOR token'\n", + "most_popular_nfts.at['0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85', 'info'] = 'ENS Base registrar'\n", + "most_popular_nfts.at['0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270', 'info'] = 'BLOCKS Token'\n", + "most_popular_nfts.at['0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405', 'info'] = 'FNDNFT Token'\n", + "most_popular_nfts.at['0x06012c8cf97BEaD5deAe237070F9587f8E7A266d', 'info'] = 'CryptoKitties Core'\n", + "most_popular_nfts.at['0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D', 'info'] = 'BAYC Token'\n", + "most_popular_nfts.at['0x1A92f7381B9F03921564a437210bB9396471050C', 'info'] = ' COOL Token'\n", + "most_popular_nfts.at['0xBd3531dA5CF5857e7CfAA92426877b022e612cf8', 'info'] = 'PPG Token'\n", + "most_popular_nfts = most_popular_nfts.rename(columns={'nft_address': 'count'})\n", + "most_popular_nfts" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Most transaction count per NFT conctract chart')" + ] + }, + "execution_count": 175, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "fig.set_size_inches(11.7, 8.27)\n", + "sns.barplot(y=most_popular_nfts['info'], x=most_popular_nfts['count']).set_title('Most transaction count per NFT conctract chart')" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
transaction_valuenft_addressinfo
timestamp
2021-01-01 00:16:460.000000e+000x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token
2021-01-01 00:16:460.000000e+000x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token
2021-01-01 00:01:370.000000e+000x06012c8cf97BEaD5deAe237070F9587f8E7A266dCryptoKitties Core
2021-01-01 00:19:083.000000e+160x06012c8cf97BEaD5deAe237070F9587f8E7A266dCryptoKitties Core
2021-01-01 00:16:460.000000e+000x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token
............
2021-05-31 23:57:100.000000e+000xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
2021-05-31 23:57:260.000000e+000x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token
2021-05-31 23:57:260.000000e+000x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token
2021-05-31 23:57:260.000000e+000x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405FNDNFT Token
2021-05-31 23:59:579.500000e+170xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token
\n", + "

1000817 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " transaction_value \\\n", + "timestamp \n", + "2021-01-01 00:16:46 0.000000e+00 \n", + "2021-01-01 00:16:46 0.000000e+00 \n", + "2021-01-01 00:01:37 0.000000e+00 \n", + "2021-01-01 00:19:08 3.000000e+16 \n", + "2021-01-01 00:16:46 0.000000e+00 \n", + "... ... \n", + "2021-05-31 23:57:10 0.000000e+00 \n", + "2021-05-31 23:57:26 0.000000e+00 \n", + "2021-05-31 23:57:26 0.000000e+00 \n", + "2021-05-31 23:57:26 0.000000e+00 \n", + "2021-05-31 23:59:57 9.500000e+17 \n", + "\n", + " nft_address \\\n", + "timestamp \n", + "2021-01-01 00:16:46 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "2021-01-01 00:16:46 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "2021-01-01 00:01:37 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d \n", + "2021-01-01 00:19:08 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d \n", + "2021-01-01 00:16:46 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "... ... \n", + "2021-05-31 23:57:10 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D \n", + "2021-05-31 23:57:26 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "2021-05-31 23:57:26 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "2021-05-31 23:57:26 0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405 \n", + "2021-05-31 23:59:57 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D \n", + "\n", + " info \n", + "timestamp \n", + "2021-01-01 00:16:46 SOR token \n", + "2021-01-01 00:16:46 SOR token \n", + "2021-01-01 00:01:37 CryptoKitties Core \n", + "2021-01-01 00:19:08 CryptoKitties Core \n", + "2021-01-01 00:16:46 SOR token \n", + "... ... \n", + "2021-05-31 23:57:10 BAYC Token \n", + "2021-05-31 23:57:26 SOR token \n", + "2021-05-31 23:57:26 SOR token \n", + "2021-05-31 23:57:26 FNDNFT Token \n", + "2021-05-31 23:59:57 BAYC Token \n", + "\n", + "[1000817 rows x 3 columns]" + ] + }, + "execution_count": 176, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get frame with values over time\n", + "num_df = pd.DataFrame()\n", + "#cast to numeric\n", + "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", + "#add nft_address column to it\n", + "num_df[\"nft_address\"]=transfers[\"nft_address\"]\n", + "#filter out only ones that are in most_popular_nfts variable\n", + "num_df = num_df[num_df.nft_address.isin(list(most_popular_nfts.index))]\n", + "#convert timestamp in to date time\n", + "num_df[\"timestamp\"] = pd.to_datetime(num_df.timestamp, unit='s', errors='coerce')\n", + "#set index as timestamp\n", + "num_df = num_df.set_index(\"timestamp\")\n", + "\n", + "num_df['info'] = None\n", + "for i in range(len(most_valuable_nfts)):\n", + " address = most_popular_nfts.iloc[i].name\n", + " \n", + " num_df.loc[num_df.nft_address == address, 'info'] = most_popular_nfts.at[address, 'info'] #most_valuable_nfts.at[num_df.iloc[i]['nft_address'], 'info']\n", + "\n", + "num_df" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [], + "source": [ + "#group timestamps by day, create column per each nft_address, aggregate transaction value by count and sum\n", + "new_df = num_df.groupby([pd.Grouper(freq='d'), 'nft_address', 'info'])['transaction_value'].agg(transaction_value=\"count\").rename(columns={'transaction_value': 'count'})\n" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
count
timestampnft_addressinfo
2021-01-010x06012c8cf97BEaD5deAe237070F9587f8E7A266dCryptoKitties Core179
0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85ENS Base registrar166
0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token831
0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270BLOCKS Token39
2021-01-020x06012c8cf97BEaD5deAe237070F9587f8E7A266dCryptoKitties Core168
............
2021-09-250x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85ENS Base registrar1965
0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205SOR token286
0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13DBAYC Token75
0xBd3531dA5CF5857e7CfAA92426877b022e612cf8PPG Token38
0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270BLOCKS Token505
\n", + "

1240 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " count\n", + "timestamp nft_address info \n", + "2021-01-01 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d CryptoKitties Core 179\n", + " 0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85 ENS Base registrar 166\n", + " 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 SOR token 831\n", + " 0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 BLOCKS Token 39\n", + "2021-01-02 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d CryptoKitties Core 168\n", + "... ...\n", + "2021-09-25 0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85 ENS Base registrar 1965\n", + " 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 SOR token 286\n", + " 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D BAYC Token 75\n", + " 0xBd3531dA5CF5857e7CfAA92426877b022e612cf8 PPG Token 38\n", + " 0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 BLOCKS Token 505\n", + "\n", + "[1240 rows x 1 columns]" + ] + }, + "execution_count": 180, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_df" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(24, 12))\n", + "# new_df.unstack()\n", + "ax = sns.lineplot(data=new_df, x='timestamp', y='count', hue='info')\n", + "\n", + "# ax.set(yscale=\"log\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/nfts/sample.env b/datasets/nfts/sample.env new file mode 100644 index 00000000..f7e4c4ab --- /dev/null +++ b/datasets/nfts/sample.env @@ -0,0 +1,2 @@ +export MOONSTREAM_DB_URI="" +export MOONSTREAM_WEB3_PROVIDER="" diff --git a/datasets/nfts/setup.py b/datasets/nfts/setup.py new file mode 100644 index 00000000..4d8d17b8 --- /dev/null +++ b/datasets/nfts/setup.py @@ -0,0 +1,52 @@ +from setuptools import find_packages, setup + +long_description = "" +with open("README.md") as ifp: + long_description = ifp.read() + +setup( + name="nfts", + version="0.0.2", + author="Bugout.dev", + author_email="engineers@bugout.dev", + license="Apache License 2.0", + description="Tools to build, update, and interact with the Moonstream NFTs dataset", + long_description=long_description, + long_description_content_type="text/markdown", + url="https://github.com/bugout-dev/moonstream", + platforms="all", + classifiers=[ + "Development Status :: 2 - Pre-Alpha", + "Intended Audience :: Developers", + "Natural Language :: English", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: Implementation :: CPython", + "Topic :: Software Development :: Libraries", + "Topic :: Software Development :: Libraries :: Python Modules", + ], + python_requires=">=3.6", + packages=find_packages(), + package_data={"nfts": ["py.typed"]}, + zip_safe=False, + install_requires=[ + "moonstreamdb", + "humbug", + "numpy", + "pandas", + "requests", + "scipy", + "tqdm", + "web3", + ], + extras_require={ + "dev": ["black", "mypy", "types-requests"], + "distribute": ["setuptools", "twine", "wheel"], + }, + entry_points={ + "console_scripts": [ + "nfts=nfts.cli:main", + ] + }, +) diff --git a/db/deploy/moonstreamdb.service b/db/deploy/moonstreamdb.service index 5f0b2b6f..17357726 100644 --- a/db/deploy/moonstreamdb.service +++ b/db/deploy/moonstreamdb.service @@ -7,7 +7,7 @@ User=ubuntu Group=www-data WorkingDirectory=/home/ubuntu/moonstream/db/server EnvironmentFile=/home/ubuntu/moonstream-secrets/app.env -ExecStart=/home/ubuntu/moonstream/db/server/moonstreamdb -host 0.0.0.0 -port "${MOONSTREAM_DB_SERVER_PORT}" +ExecStart=/home/ubuntu/moonstream/db/server/moonstreamdb -host 127.0.0.1 -port "${MOONSTREAM_DB_SERVER_PORT}" SyslogIdentifier=moonstreamdb [Install] diff --git a/db/setup.py b/db/setup.py index 0913022e..601c4c14 100644 --- a/db/setup.py +++ b/db/setup.py @@ -33,7 +33,10 @@ setup( package_data={"moonstreamdb": ["py.typed"]}, zip_safe=False, install_requires=["alembic", "psycopg2-binary", "sqlalchemy"], - extras_require={"dev": ["black", "mypy"]}, + extras_require={ + "dev": ["black", "mypy"], + "distribute": ["setuptools", "twine", "wheel"], + }, entry_points={ "console_scripts": [ "moonstreamdb=moonstreamdb.cli:main", diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 91c5be10..4250fea8 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -1,26 +1,19 @@ -import React, { - useState, - useContext, - Suspense, - useEffect, - useLayoutEffect, -} from "react"; +import React, { useState, Suspense, useEffect, useLayoutEffect } from "react"; import { Fade, Flex, Heading, Box, - Image as ChakraImage, - Button, Center, chakra, Stack, Link, - SimpleGrid, useMediaQuery, Grid, Text, GridItem, + SimpleGrid, + Image as ChakraImage, } from "@chakra-ui/react"; import dynamic from "next/dynamic"; import useUser from "../src/core/hooks/useUser"; @@ -30,56 +23,15 @@ import { MIXPANEL_PROPS, MIXPANEL_EVENTS, } from "../src/core/providers/AnalyticsProvider/constants"; -import UIContext from "../src/core/providers/UIProvider/context"; import { AWS_ASSETS_PATH } from "../src/core/constants"; import mixpanel from "mixpanel-browser"; -const SplitWithImage = dynamic( - () => import("../src/components/SplitWithImage"), - { - ssr: false, - } -); + const ConnectedButtons = dynamic( () => import("../src/components/ConnectedButtons"), { ssr: false, } ); - -const RiDashboardFill = dynamic(() => - import("react-icons/ri").then((mod) => mod.RiDashboardFill) -); -const FaFileContract = dynamic(() => - import("react-icons/fa").then((mod) => mod.FaFileContract) -); -const GiMeshBall = dynamic(() => - import("react-icons/gi").then((mod) => mod.GiMeshBall) -); - -const GiLogicGateXor = dynamic(() => - import("react-icons/gi").then((mod) => mod.GiLogicGateXor) -); - -const GiSuspicious = dynamic(() => - import("react-icons/gi").then((mod) => mod.GiSuspicious) -); - -const GiHook = dynamic(() => - import("react-icons/gi").then((mod) => mod.GiHook) -); - -const AiFillApi = dynamic(() => - import("react-icons/ai").then((mod) => mod.AiFillApi) -); - -const BiTransfer = dynamic(() => - import("react-icons/bi").then((mod) => mod.BiTransfer) -); - -const IoTelescopeSharp = dynamic(() => - import("react-icons/io5").then((mod) => mod.IoTelescopeSharp) -); - const HEADING_PROPS = { fontWeight: "700", fontSize: ["4xl", "5xl", "4xl", "5xl", "6xl", "7xl"], @@ -94,12 +46,11 @@ const assets = { pendingTransactions: `${AWS_ASSETS_PATH}/Ethereum+pending+transactions.png`, priceInformation: `${AWS_ASSETS_PATH}/Price+information.png`, socialMediaPosts: `${AWS_ASSETS_PATH}/Social+media+posts.png`, - algorithmicFunds: `${AWS_ASSETS_PATH}/algorithmic+funds.png`, cryptoTraders: `${AWS_ASSETS_PATH}/crypto+traders.png`, + comicWhite: `${AWS_ASSETS_PATH}/moonstream-comic-white.png`, smartDevelopers: `${AWS_ASSETS_PATH}/smart+contract+developers.png`, }; const Homepage = () => { - const ui = useContext(UIContext); const [background, setBackground] = useState("background720"); const [backgroundLoaded720, setBackgroundLoaded720] = useState(false); const [backgroundLoaded1920, setBackgroundLoaded1920] = useState(false); @@ -254,7 +205,7 @@ const Homepage = () => { fontWeight="semibold" color="white" > - All the crypto data you care about in a single stream + Open source blockchain analytics { display="inline-block" color="blue.200" > - Get all the crypto data you need in a single stream. - From pending transactions in the Ethereum transaction - pool to Elon Musk’s latest tweets. - - - Access this data through the Moonstream dashboard or - API + Product analytics for Web3. Moonstream helps you + understand exactly how people are using your smart + contracts. @@ -280,16 +223,8 @@ const Homepage = () => { - + { > - {` We believe in financial inclusion. Proprietary technologies - are not financially inclusive. That's why all our software - is `} - + We believe that the blockchain is for everyone. This + requires complete transparency. That’s why all our + software is{" "} + open source @@ -313,10 +252,10 @@ const Homepage = () => { - Data you can add to your stream: + See how your smart contracts are being used from: @@ -369,193 +308,58 @@ const Homepage = () => { w="100%" direction={["column", "row", "column", null, "column"]} flexWrap={["nowrap", "nowrap", "nowrap", null, "nowrap"]} - pb="66px" + pb="32px" > { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `scroll to CryptoTrader`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Connected buttons: scroll to analytics`, + }); + }, + }} + button1={{ + label: "TX pool real time data", + speed: 9, + // link: "/#txpool", + onClick: () => { + mixpanel.get_distinct_id() && + mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Connected buttons: scroll to txpool`, }); }, }} button2={{ - label: "Algorithmic Fund", - link: "/#algoFund", + label: "Exchange price stream", + speed: 6, + // link: "/#exchanges", onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `scroll to AlgoFund`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Connected buttons: scroll to exchanges`, }); }, }} button3={{ - label: "Developer", - link: "/#smartDeveloper", + label: "Social media posts", + speed: 3, + // link: "/#smartDeveloper", onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `scroll to Developer`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Connected buttons: scroll to developer`, }); }, }} /> - - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: Crypto trader`, - }); - toggleModal("hubspot-trader"); - }, - }} - elementName={"element1"} - colorScheme="green" - badge={`For crypto traders`} - title={``} - body={``} - bullets={[ - { - text: `Subscribe to the defi contracts you care about`, - icon: FaFileContract, - color: "green.50", - bgColor: "green.900", - }, - { - text: `Make sense of how others are calling these contracts using Moonstream dashboards. - `, - icon: RiDashboardFill, - color: "green.50", - bgColor: "green.900", - }, - { - text: `Get data directly from the transaction pool through our global network of Ethereum nodes`, - icon: GiMeshBall, - color: "green.50", - bgColor: "green.900", - }, - ]} - imgURL={assets["cryptoTraders"]} - /> - - - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: Algo fund`, - }); - toggleModal("hubspot-fund"); - }, - }} - elementName={"element2"} - mirror={true} - colorScheme="orange" - badge={`For algorithmic funds`} - bullets={[ - { - text: `Get API access to your stream`, - icon: AiFillApi, - color: "orange.50", - bgColor: "orange.900", - }, - { - text: `Set conditions that trigger predefined actions`, - icon: GiLogicGateXor, - color: "orange.50", - bgColor: "orange.900", - }, - { - text: `Execute transactions directly on Moonstream nodes`, - icon: BiTransfer, - color: "orange.50", - bgColor: "orange.900", - }, - ]} - imgURL={assets["algorithmicFunds"]} - /> - - - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer`, - }); - toggleModal("hubspot-developer"); - }, - }} - socialButton={{ - url: "https://github.com/bugout-dev/moonstream/", - network: "github", - label: "See our github", - onClick: () => { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Github link in landing page`, - }); - }, - }} - elementName={"element3"} - colorScheme="blue" - badge={`For smart contract developers`} - bullets={[ - { - text: `See how people use your smart contracts`, - icon: IoTelescopeSharp, - color: "blue.50", - bgColor: "blue.900", - }, - { - text: `Set up alerts on suspicious activity`, - icon: GiSuspicious, - color: "blue.50", - bgColor: "blue.900", - }, - { - text: `Register webhooks to connect your off-chain infrastructure`, - icon: GiHook, - color: "blue.50", - bgColor: "blue.900", - }, - ]} - imgURL={assets["smartDevelopers"]} - /> - { pb="120px" >
- + + + Want to find out more? Reach out to us on{" "} + { + mixpanel.get_distinct_id() && + mixpanel.track( + `${MIXPANEL_EVENTS.BUTTON_CLICKED}`, + { + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Join our discord`, + } + ); + }} + isExternal + href={"https://discord.gg/K56VNUQGvA"} + > + Discord + {" "} + or{" "} + { + mixpanel.get_distinct_id() && + mixpanel.track( + `${MIXPANEL_EVENTS.BUTTON_CLICKED}`, + { + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer want to find more button`, + } + ); + toggleModal("hubspot-developer"); + }} + > + request early access + + +
diff --git a/frontend/pages/product/index.js b/frontend/pages/product/index.js index fa03ba4a..ad154392 100644 --- a/frontend/pages/product/index.js +++ b/frontend/pages/product/index.js @@ -1,26 +1,30 @@ import React, { useEffect, useState, useLayoutEffect } from "react"; import { - Heading, Text, Flex, Link, Stack, - chakra, useMediaQuery, useBreakpointValue, + Center, } from "@chakra-ui/react"; -import { DEFAULT_METATAGS, AWS_ASSETS_PATH } from "../../src/core/constants"; -export async function getStaticProps() { - return { - props: { metaTags: { ...DEFAULT_METATAGS } }, - }; -} - +import { AWS_ASSETS_PATH } from "../../src/core/constants"; +import SplitWithImage from "../../src/components/SplitWithImage"; +import mixpanel from "mixpanel-browser"; +import { + MIXPANEL_PROPS, + MIXPANEL_EVENTS, +} from "../../src/core/providers/AnalyticsProvider/constants"; const assets = { background720: `${AWS_ASSETS_PATH}/product-background-720x405.png`, background1920: `${AWS_ASSETS_PATH}/product-background-720x405.png`, background2880: `${AWS_ASSETS_PATH}/product-background-720x405.png`, background3840: `${AWS_ASSETS_PATH}/product-background-720x405.png`, + environment: `${AWS_ASSETS_PATH}/product_comic/environment.png`, + developers: `${AWS_ASSETS_PATH}/product_comic/developers.png`, + meanwhile: `${AWS_ASSETS_PATH}/product_comic/meanwhile.png`, + struggle: `${AWS_ASSETS_PATH}/product_comic/struggle.png`, + solution: `${AWS_ASSETS_PATH}/product_comic/solution.png`, }; const Product = () => { @@ -131,72 +135,115 @@ const Product = () => { alignItems="center" pb={24} > - - - {`Why you'll love Moonstream`} - - - - We strive for financial inclusion. With cryptocurrencies becoming - mainstream, now is the time for anyone with a computer and access to - the Internet to utilize this opportunity to make passive income. - We’re here to make it easier. - - - Right now our source of data is Ethereum blockchain. Our goal is to - provide a live view of the transactions taking place on every public - blockchain - from the activity of specific accounts or smart - contracts to updates about general market movements. - - - This information comes from the blockchains themselves, from their - mempools/transaction pools, and from centralized exchanges, social - media, and the news. This forms a stream of information tailored to - your specific needs. - - - We’re giving you a macro view of the crypto market with direct - access from Moonstream dashboards to execute transactions. You can - also set up programs which execute (on- or off-chain) when your - stream meets certain conditions. - - - Moonstream is accessible through dashboard, API and webhooks. - - - Moonstream’s financial inclusion goes beyond providing access to - data. All of our work is open source as we do not believe that - proprietary technologies are financially inclusive. - - - You can read{" "} - - our code on GitHub. - {" "} - and keep track of our progress using{" "} - - the Moonstream milestones - - . - - + + + + + + +
+ + + To find out more, join us on{" "} + { + mixpanel.get_distinct_id() && + mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Join our discord`, + }); + }} + isExternal + href={"https://discord.gg/K56VNUQGvA"} + > + Discord + {" "} + + +
); }; + +export async function getStaticProps() { + const metaTags = { + title: "Moonstream.to: web3 analytics", + description: + "Moonstream brings product analytics to web3. Instantly get analytics for any smart contract you write.", + keywords: + "blockchain, crypto, data, trading, smart contracts, ethereum, solana, transactions, defi, finance, decentralized, analytics, product", + url: "https://www.moonstream.to/product", + image: `${AWS_ASSETS_PATH}/product_comic/solution.png`, + }; + + const assetPreload = Object.keys(assets).map((key) => { + return { + rel: "preload", + href: assets[key], + as: "image", + }; + }); + const preconnects = [{ rel: "preconnect", href: "https://s3.amazonaws.com" }]; + + const preloads = assetPreload.concat(preconnects); + + return { + props: { metaTags, preloads }, + }; +} + export default Product; diff --git a/frontend/pages/welcome.js b/frontend/pages/welcome.js index 9bb4f2b8..7caeb345 100644 --- a/frontend/pages/welcome.js +++ b/frontend/pages/welcome.js @@ -8,8 +8,6 @@ import { Stack, ButtonGroup, Spacer, - Radio, - RadioGroup, UnorderedList, ListItem, Fade, @@ -28,7 +26,6 @@ import { import StepProgress from "../src/components/StepProgress"; import { ArrowLeftIcon, ArrowRightIcon } from "@chakra-ui/icons"; import Scrollable from "../src/components/Scrollable"; -import AnalyticsContext from "../src/core/providers/AnalyticsProvider/context"; import NewSubscription from "../src/components/NewSubscription"; import StreamEntry from "../src/components/StreamEntry"; import SubscriptionsList from "../src/components/SubscriptionsList"; @@ -39,8 +36,6 @@ import { FaFilter } from "react-icons/fa"; const Welcome = () => { const { subscriptionsCache } = useSubscriptions(); const ui = useContext(UIContext); - const { mixpanel, isLoaded, MIXPANEL_PROPS } = useContext(AnalyticsContext); - const [profile, setProfile] = React.useState(); const [showSubscriptionForm, setShowSubscriptionForm] = useBoolean(true); useEffect(() => { @@ -53,14 +48,6 @@ const Welcome = () => { ui.setOnboardingStep(index); }; - useEffect(() => { - if (profile && isLoaded) { - mixpanel.people.set({ - [`${MIXPANEL_PROPS.USER_SPECIALITY}`]: profile, - }); - } - }, [profile, MIXPANEL_PROPS, isLoaded, mixpanel]); - const SubscriptonCreatedCallback = () => { setShowSubscriptionForm.off(); }; @@ -250,48 +237,6 @@ const Welcome = () => { - - - - Tell us more about your needs - - - In order to create the best possible experience, we would love - to find out some more about you. - - - Please tell us what profile describes you best.{" "} - - This is purely analytical data, you can change it anytime - later. - - - - - I am trading crypto currency - I represent investment fund - I am developer - - - )} diff --git a/frontend/src/components/ConnectedButtons.js b/frontend/src/components/ConnectedButtons.js index 990f1cc1..590416b2 100644 --- a/frontend/src/components/ConnectedButtons.js +++ b/frontend/src/components/ConnectedButtons.js @@ -1,5 +1,13 @@ import React, { useEffect, useRef, useContext } from "react"; -import { Flex, Heading, Button, Link, SimpleGrid } from "@chakra-ui/react"; +import { + Flex, + Heading, + Button, + Link, + SimpleGrid, + useBreakpointValue, + useMediaQuery, +} from "@chakra-ui/react"; import Xarrow, { useXarrow } from "react-xarrows"; import UIContext from "../core/providers/UIProvider/context"; @@ -9,6 +17,9 @@ const ArrowCTA = (props) => { const box1Ref = useRef(null); const box2Ref = useRef(null); const box3Ref = useRef(null); + const box4Ref = useRef(null); + + // const gridRow = props.button4 ? [5, 4, 2, null, 2] : [4, 3, 2, null, 2]; const updateXarrow = useXarrow(); @@ -17,30 +28,72 @@ const ArrowCTA = (props) => { // eslint-disable-next-line }, [ui.isMobileView]); + const xarrowEntrySide = useBreakpointValue({ + base: "top", + sm: "left", + md: "top", + lg: "top", + xl: "top", + "2xl": "top", + }); + + const [isLargerThan580px] = useMediaQuery(["(min-width: 580px)"]); + + const buttonWidth = [ + "190px", + isLargerThan580px ? "200px" : "140px", + "230px", + null, + "280px", + ]; + + const fontSize = [ + undefined, + isLargerThan580px ? undefined : "12px", + undefined, + null, + ]; + + const speedConst = -0.05; + return ( - + {props.title} @@ -59,6 +113,7 @@ const ArrowCTA = (props) => { + {props.button4 && ( + + )} + {props.button4 && ( + + )} ); }; diff --git a/frontend/src/components/Sidebar.js b/frontend/src/components/Sidebar.js index 5cc6f818..fc63394e 100644 --- a/frontend/src/components/Sidebar.js +++ b/frontend/src/components/Sidebar.js @@ -118,6 +118,14 @@ const Sidebar = () => { > Login + + {" "} + Product + + + {" "} + Team + )} diff --git a/frontend/src/components/SplitWithImage.js b/frontend/src/components/SplitWithImage.js index 5220d052..203d9dbf 100644 --- a/frontend/src/components/SplitWithImage.js +++ b/frontend/src/components/SplitWithImage.js @@ -68,6 +68,8 @@ const SplitWithImage = ({ elementName, cta, socialButton, + imgBoxShadow, + py, }) => { var buttonSize = useBreakpointValue({ base: { single: "sm", double: "xs" }, @@ -94,10 +96,20 @@ const SplitWithImage = ({ return () => observer.unobserve(current); }, []); + const themeColor = useColorModeValue( + `${colorScheme}.50`, + `${colorScheme}.900` + ); + + const bgThemeColor = useColorModeValue( + `${colorScheme}.900`, + `${colorScheme}.50` + ); + return ( @@ -109,31 +121,34 @@ const SplitWithImage = ({ alt={"feature image"} src={imgURL} objectFit={"contain"} + boxShadow={imgBoxShadow ?? "inherit"} /> )} - - - + {badge && ( + - {badge} - - - {title} - + + {badge} + + + )} + {title} + {body} - + {cta && ( + + )} {socialButton && ( } > git clone moonstream @@ -194,12 +211,14 @@ const SplitWithImage = ({ {(!mirror || ui.isMobileView) && ( - + {"feature )} diff --git a/frontend/src/core/hooks/hookCommon.js b/frontend/src/core/hooks/hookCommon.js index a3aeef16..72f85a30 100644 --- a/frontend/src/core/hooks/hookCommon.js +++ b/frontend/src/core/hooks/hookCommon.js @@ -11,3 +11,4 @@ export const queryCacheProps = { return status === 404 || status === 403 ? false : true; }, }; +export default queryCacheProps; diff --git a/frontend/src/layouts/RootLayout.js b/frontend/src/layouts/RootLayout.js index cd66abe9..d7afd5c9 100644 --- a/frontend/src/layouts/RootLayout.js +++ b/frontend/src/layouts/RootLayout.js @@ -7,7 +7,7 @@ const Navbar = React.lazy(() => import("../components/Navbar")); const RootLayout = (props) => { const ui = useContext(UIContext); - const [showBanner, setShowBanner] = useState(true); + const [showBanner, setShowBanner] = useState(false); return (