From 79dab82972c1bf951ad646bff976fbe58b32834c Mon Sep 17 00:00:00 2001 From: kompotkot Date: Tue, 21 Sep 2021 12:56:56 +0000 Subject: [PATCH 01/87] Migrated to fastapi router from subapps --- backend/moonstream/api.py | 66 +++++++++++++++++---- backend/moonstream/routes/address_info.py | 44 +++----------- backend/moonstream/routes/streams.py | 47 +++------------ backend/moonstream/routes/subscriptions.py | 49 ++++------------ backend/moonstream/routes/txinfo.py | 35 ++--------- backend/moonstream/routes/users.py | 67 +++++----------------- 6 files changed, 100 insertions(+), 208 deletions(-) diff --git a/backend/moonstream/api.py b/backend/moonstream/api.py index 48ab8cda..636ec351 100644 --- a/backend/moonstream/api.py +++ b/backend/moonstream/api.py @@ -3,24 +3,46 @@ The Moonstream HTTP API """ import logging import time +from typing import Dict from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from . import data -from .routes.subscriptions import app as subscriptions_api -from .routes.users import app as users_api -from .routes.txinfo import app as txinfo_api -from .routes.streams import app as streams_api -from .routes.address_info import app as addressinfo_api +from .routes.address_info import router as addressinfo_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 .settings import ORIGINS +from .middleware import BroodAuthMiddleware +from .settings import DOCS_PATHS, 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": "Address public information."}, + {"name": "labels", "description": "Addresses label information."}, + {"name": "streams", "description": "Operations with data stream and filters."}, + {"name": "subscriptions", "description": "Operations with subscriptions."}, + {"name": "time", "description": "Timestamp endpoints."}, + {"name": "tokens", "description": "Operations with user tokens."}, + {"name": "txinfo", "description": "Ethereum transactions info."}, + {"name": "users", "description": "Operations with users."}, +] + +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}", +) app.add_middleware( CORSMiddleware, @@ -29,6 +51,24 @@ app.add_middleware( allow_methods=["*"], allow_headers=["*"], ) +whitelist_paths: Dict[str, str] = {} +whitelist_paths.update(DOCS_PATHS) +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.get("/ping", response_model=data.PingResponse) @@ -46,8 +86,10 @@ async def now_handler() -> data.NowResponse: return data.NowResponse(epoch_time=time.time()) -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.include_router(addressinfo_router) +app.include_router(streams_router) +app.include_router(subscriptions_router) +app.include_router(txinfo_router) +app.include_router(users_router) + +# app.mount("/address_info", addressinfo_api) diff --git a/backend/moonstream/routes/address_info.py b/backend/moonstream/routes/address_info.py index c985c683..9178844b 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="/users", ) -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, @@ -57,9 +29,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/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 8ab9a5ec..bdaf1947 100644 --- a/backend/moonstream/routes/txinfo.py +++ b/backend/moonstream/routes/txinfo.py @@ -6,10 +6,8 @@ transactions, etc.) with side information and return objects that are better sui end users. """ import logging -from typing import Dict -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 @@ -17,43 +15,18 @@ 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 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="/txinfo", ) -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) - # 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 19cefc8f..cf2236c4 100644 --- a/backend/moonstream/routes/users.py +++ b/backend/moonstream/routes/users.py @@ -7,68 +7,31 @@ import uuid from bugout.data import BugoutToken, BugoutUser, BugoutResource 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}", +router = APIRouter( + prefix="/users", ) -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) - - -@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: @@ -86,13 +49,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) @@ -103,7 +66,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: @@ -116,7 +79,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: @@ -132,7 +95,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: @@ -147,7 +110,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(...) ) -> BugoutToken: @@ -166,7 +129,7 @@ async def login_handler( return token -@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: @@ -178,7 +141,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(...), @@ -224,7 +187,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: @@ -259,7 +222,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: From d0381ed089e18fb9280e8e4a39b8dfe9f7f94624 Mon Sep 17 00:00:00 2001 From: kompotkot Date: Wed, 22 Sep 2021 10:32:38 +0000 Subject: [PATCH 02/87] Removed variable MOONSTREAM_OPENAPI_LIST --- backend/moonstream/api.py | 3 +-- backend/moonstream/settings.py | 9 --------- backend/sample.env | 1 - 3 files changed, 1 insertion(+), 12 deletions(-) diff --git a/backend/moonstream/api.py b/backend/moonstream/api.py index 636ec351..2ea2fc3d 100644 --- a/backend/moonstream/api.py +++ b/backend/moonstream/api.py @@ -16,7 +16,7 @@ from .routes.txinfo import router as txinfo_router from .routes.users import router as users_router from .middleware import BroodAuthMiddleware -from .settings import DOCS_PATHS, DOCS_TARGET_PATH, ORIGINS +from .settings import DOCS_TARGET_PATH, ORIGINS from .version import MOONSTREAM_VERSION logging.basicConfig(level=logging.INFO) @@ -52,7 +52,6 @@ app.add_middleware( allow_headers=["*"], ) whitelist_paths: Dict[str, str] = {} -whitelist_paths.update(DOCS_PATHS) whitelist_paths.update( { "/ping": "GET", diff --git a/backend/moonstream/settings.py b/backend/moonstream/settings.py index 0a90d751..516a7b87 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 779bbb0c..22df1353 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://:@:/" From f481d280506e92ce82f567fb86911efd5ff22364 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 25 Sep 2021 09:29:20 -0700 Subject: [PATCH 03/87] Started on code for NFTs dataset --- datasets/nfts/README.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 datasets/nfts/README.md 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 From d22c0c6929099ba89d459a79accde7c06e461adf Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 25 Sep 2021 09:39:30 -0700 Subject: [PATCH 04/87] Set up Python package --- datasets/nfts/.gitignore | 165 +++++++++++++++++++++++++++++++++ datasets/nfts/nfts/__init__.py | 0 datasets/nfts/setup.py | 46 +++++++++ 3 files changed, 211 insertions(+) create mode 100644 datasets/nfts/.gitignore create mode 100644 datasets/nfts/nfts/__init__.py create mode 100644 datasets/nfts/setup.py diff --git a/datasets/nfts/.gitignore b/datasets/nfts/.gitignore new file mode 100644 index 00000000..cc2de8a5 --- /dev/null +++ b/datasets/nfts/.gitignore @@ -0,0 +1,165 @@ + +# 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/ 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/setup.py b/datasets/nfts/setup.py new file mode 100644 index 00000000..294f47ca --- /dev/null +++ b/datasets/nfts/setup.py @@ -0,0 +1,46 @@ +from setuptools import find_packages, setup + +long_description = "" +with open("README.md") as ifp: + long_description = ifp.read() + +setup( + name="nfts", + version="0.0.1", + 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 @ git+https://git@github.com/bugout-dev/moonstream.git@a4fff6498f66789934d4af26fd42a8cfb6e5eed5#egg=moonstreamdb&subdirectory=db", + "humbug", + "tqdm", + "web3", + ], + extras_require={ + "dev": ["black", "mypy"], + "distribute": ["setuptools", "twine", "wheel"], + }, + entry_points={ + "console_scripts": [] + }, +) From 3fe06ee1942e66bda3bc957f2a6e97ae7d358bfe Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 25 Sep 2021 09:42:22 -0700 Subject: [PATCH 05/87] Set up moonstreamdb/setup.py for distribution to PyPI --- db/setup.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) 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", From abae67143af12901cda4647ce17d1741a518432a Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 25 Sep 2021 09:50:43 -0700 Subject: [PATCH 06/87] Bumped nfts version to 0.0.2 --- datasets/nfts/setup.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/datasets/nfts/setup.py b/datasets/nfts/setup.py index 294f47ca..6cf9ef9f 100644 --- a/datasets/nfts/setup.py +++ b/datasets/nfts/setup.py @@ -6,7 +6,7 @@ with open("README.md") as ifp: setup( name="nfts", - version="0.0.1", + version="0.0.2", author="Bugout.dev", author_email="engineers@bugout.dev", license="Apache License 2.0", @@ -31,7 +31,7 @@ setup( package_data={"nfts": ["py.typed"]}, zip_safe=False, install_requires=[ - "moonstreamdb @ git+https://git@github.com/bugout-dev/moonstream.git@a4fff6498f66789934d4af26fd42a8cfb6e5eed5#egg=moonstreamdb&subdirectory=db", + "moonstreamdb", "humbug", "tqdm", "web3", @@ -40,7 +40,5 @@ setup( "dev": ["black", "mypy"], "distribute": ["setuptools", "twine", "wheel"], }, - entry_points={ - "console_scripts": [] - }, + entry_points={"console_scripts": []}, ) From 072a86c8fc8f64e72ed4a64d40b70d8f2537c42a Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 25 Sep 2021 10:23:33 -0700 Subject: [PATCH 07/87] Got started on materialization code for intermediate datasets These are the steps required to produce the raw dataset referenced here: https://github.com/bugout-dev/moonstream/issues/272#issuecomment-926087702 Intermediate steps: https://github.com/bugout-dev/moonstream/issues/272#issuecomment-927144872 --- datasets/nfts/nfts/cli.py | 9 +++++ datasets/nfts/nfts/materialize.py | 66 +++++++++++++++++++++++++++++++ 2 files changed, 75 insertions(+) create mode 100644 datasets/nfts/nfts/cli.py create mode 100644 datasets/nfts/nfts/materialize.py diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py new file mode 100644 index 00000000..091ed97f --- /dev/null +++ b/datasets/nfts/nfts/cli.py @@ -0,0 +1,9 @@ +from moonstreamdb.db import yield_db_session_ctx + +from .materialize import get_rows, EventType + +if __name__ == "__main__": + with yield_db_session_ctx() as db_session: + rows = get_rows(db_session, EventType.TRANSFER) + for row in rows: + print(row) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py new file mode 100644 index 00000000..72603cc5 --- /dev/null +++ b/datasets/nfts/nfts/materialize.py @@ -0,0 +1,66 @@ +from dataclasses import dataclass +from enum import Enum +from typing import List, Optional + +from moonstreamdb.models import ( + EthereumAddress, + EthereumLabel, + EthereumTransaction, + EthereumBlock, +) +from sqlalchemy.orm import Session + + +@dataclass +class BlockBounds: + starting_block: int + ending_block: Optional[int] = None + + +class EventType(Enum): + TRANSFER = "nft_transfer" + MINT = "nft_mint" + + +@dataclass +class NFTEvent: + 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 + + +def get_rows( + db_session: Session, event_type: EventType, bounds: Optional[BlockBounds] = None +) -> List[NFTEvent]: + query = ( + db_session.query( + EthereumLabel.label, + EthereumAddress.address, + EthereumLabel.label_data, + EthereumLabel.transaction_hash, + ) + .join(EthereumAddress, EthereumLabel.address_id == EthereumAddress.id) + .outerjoin( + EthereumTransaction, + EthereumLabel.transaction_hash == EthereumTransaction.hash, + ) + .filter(EthereumLabel.label == event_type.value) + .limit(10) + ) + return [ + NFTEvent( + event_type=label, + nft_address=address, + token_id=label_data["tokenId"], + from_address=label_data["from"], + to_address=label_data["to"], + transaction_hash=transaction_hash, + ) + for label, address, label_data, transaction_hash in query + ] From 098aea7d205fa725a57933daa695ab24715c57e1 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Sat, 25 Sep 2021 22:44:41 +0300 Subject: [PATCH 08/87] Made preprocess method that will add missing fields to NftEvent from web3 --- datasets/nfts/nfts/cli.py | 11 +++++++++-- datasets/nfts/nfts/materialize.py | 29 ++++++++++++++++++++++++++++- datasets/nfts/sample.env | 2 ++ 3 files changed, 39 insertions(+), 3 deletions(-) create mode 100644 datasets/nfts/sample.env diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 091ed97f..03bfcf71 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -1,9 +1,16 @@ -from moonstreamdb.db import yield_db_session_ctx +import os -from .materialize import get_rows, EventType +from moonstreamdb.db import yield_db_session_ctx +from web3 import Web3 + +from .materialize import get_rows, EventType, preproccess if __name__ == "__main__": + web3_path = os.environ.get("MOONSTREAM_IPC_PATH") + web3_client = Web3(Web3.HTTPProvider(web3_path)) + with yield_db_session_ctx() as db_session: rows = get_rows(db_session, EventType.TRANSFER) + rows = preproccess(db_session, web3_client, rows) for row in rows: print(row) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 72603cc5..04ccbebd 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -9,6 +9,7 @@ from moonstreamdb.models import ( EthereumBlock, ) from sqlalchemy.orm import Session +from web3 import Web3 @dataclass @@ -35,6 +36,22 @@ class NFTEvent: timestamp: Optional[int] = None +def preproccess( + db_session: Session, web3_client: Web3, nft_events: List[NFTEvent] +) -> List[NFTEvent]: + """ + Adds block number, value, timestamp from web3 if they are None (because that transaction is missing in db) + """ + for nft_event in nft_events: + if nft_event.block_number is None: + transaction = web3_client.eth.get_transaction(nft_event.transaction_hash) + nft_event.value = transaction["value"] + nft_event.block_number = transaction["blockNumber"] + block = web3_client.eth.get_block(transaction["blockNumber"]) + nft_event.timestamp = block["timestamp"] + return nft_events + + def get_rows( db_session: Session, event_type: EventType, bounds: Optional[BlockBounds] = None ) -> List[NFTEvent]: @@ -44,12 +61,19 @@ def get_rows( EthereumAddress.address, EthereumLabel.label_data, EthereumLabel.transaction_hash, + EthereumTransaction.value, + EthereumTransaction.block_number, + EthereumBlock.timestamp, ) .join(EthereumAddress, EthereumLabel.address_id == EthereumAddress.id) .outerjoin( EthereumTransaction, EthereumLabel.transaction_hash == EthereumTransaction.hash, ) + .outerjoin( + EthereumBlock, + EthereumTransaction.block_number == EthereumBlock.block_number, + ) .filter(EthereumLabel.label == event_type.value) .limit(10) ) @@ -61,6 +85,9 @@ def get_rows( from_address=label_data["from"], to_address=label_data["to"], transaction_hash=transaction_hash, + value=value, + block_number=block_number, + timestamp=timestamp, ) - for label, address, label_data, transaction_hash in query + for label, address, label_data, transaction_hash, value, block_number, timestamp in query ] diff --git a/datasets/nfts/sample.env b/datasets/nfts/sample.env new file mode 100644 index 00000000..10161c69 --- /dev/null +++ b/datasets/nfts/sample.env @@ -0,0 +1,2 @@ +export MOONSTREAM_DB_URI="" +export MOONSTREAM_IPC_PATH=null From be63141b145cee83d746ab668087738c63ee02d2 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sun, 26 Sep 2021 09:34:14 -0700 Subject: [PATCH 09/87] MOONSTREAM_IPC_PATH -> MOONSTREAM_WEB3_PROVIDER Updated sample.env, too --- datasets/nfts/sample.env | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datasets/nfts/sample.env b/datasets/nfts/sample.env index 10161c69..f7e4c4ab 100644 --- a/datasets/nfts/sample.env +++ b/datasets/nfts/sample.env @@ -1,2 +1,2 @@ -export MOONSTREAM_DB_URI="" -export MOONSTREAM_IPC_PATH=null +export MOONSTREAM_DB_URI="" +export MOONSTREAM_WEB3_PROVIDER="" From 6439324abae5c18d62cbfffbe27061eeffa6cc9f Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sun, 26 Sep 2021 11:14:40 -0700 Subject: [PATCH 10/87] Added some datastore (to SQLite) functionality Set up CLI framework, as well. --- datasets/nfts/.gitignore | 1 + datasets/nfts/nfts/cli.py | 103 +++++++++++++++++++++++++--- datasets/nfts/nfts/data.py | 40 +++++++++++ datasets/nfts/nfts/datastore.py | 109 ++++++++++++++++++++++++++++++ datasets/nfts/nfts/materialize.py | 101 +++++++++++++++------------ 5 files changed, 299 insertions(+), 55 deletions(-) create mode 100644 datasets/nfts/nfts/data.py create mode 100644 datasets/nfts/nfts/datastore.py diff --git a/datasets/nfts/.gitignore b/datasets/nfts/.gitignore index cc2de8a5..adc9bb00 100644 --- a/datasets/nfts/.gitignore +++ b/datasets/nfts/.gitignore @@ -163,3 +163,4 @@ cython_debug/ .venv/ .nfts/ venv/ +.secrets/ diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 03bfcf71..8a66149a 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -1,16 +1,99 @@ +import argparse +import contextlib import os +import sqlite3 +from typing import Optional, Union from moonstreamdb.db import yield_db_session_ctx -from web3 import Web3 +from web3 import Web3, IPCProvider, HTTPProvider + +from .data import event_types, nft_event +from .datastore import setup_database +from .materialize import create_dataset + + +def web3_connection(web3_uri: Optional[str] = None) -> Web3: + """ + Connect to the given web3 provider. You may specify a web3 provider either as a path to an IPC + socket on your filesystem or as an HTTP(S) URI to a JSON RPC provider. + + If web3_uri is not provided or is set to None, this function attempts to use the default behavior + of the web3.py IPCProvider (one of the steps is looking for .ethereum/geth.ipc, but there may be others). + """ + web3_provider: Union[IPCProvider, HTTPProvider] = Web3.IPCProvider() + if web3_uri is not None: + if web3_uri.startswith("http://") or web3_uri.startswith("https://"): + web3_provider = Web3.HTTPProvider(web3_uri) + else: + web3_provider = Web3.IPCProvider(web3_uri) + web3_client = Web3(web3_provider) + return web3_client + + +def handle_initdb(args: argparse.Namespace) -> None: + with contextlib.closing(sqlite3.connect(args.datastore)) as conn: + setup_database(conn) + + +def handle_materialize(args: argparse.Namespace) -> None: + event_type = nft_event(args.type) + print(args) + with yield_db_session_ctx() as db_session, contextlib.closing( + sqlite3.connect(args.datastore) + ) as moonstream_datastore: + create_dataset(moonstream_datastore, db_session, args.web3, event_type) + + +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") + + 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( + "--web3", + default=default_web3_provider, + type=web3_connection, + help=f"Web3 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.set_defaults(func=handle_materialize) + + args = parser.parse_args() + args.func(args) -from .materialize import get_rows, EventType, preproccess if __name__ == "__main__": - web3_path = os.environ.get("MOONSTREAM_IPC_PATH") - web3_client = Web3(Web3.HTTPProvider(web3_path)) - - with yield_db_session_ctx() as db_session: - rows = get_rows(db_session, EventType.TRANSFER) - rows = preproccess(db_session, web3_client, rows) - for row in rows: - print(row) + main() diff --git a/datasets/nfts/nfts/data.py b/datasets/nfts/nfts/data.py new file mode 100644 index 00000000..df967ead --- /dev/null +++ b/datasets/nfts/nfts/data.py @@ -0,0 +1,40 @@ +""" +Data structures used in (and as part of the maintenance of) the Moonstream NFTs dataset +""" +from dataclasses import dataclass +from enum import Enum +from typing import Optional + + +@dataclass +class BlockBounds: + starting_block: int + ending_block: Optional[int] = None + + +class EventType(Enum): + TRANSFER = "nft_transfer" + MINT = "nft_mint" + + +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_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 diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py new file mode 100644 index 00000000..538999fb --- /dev/null +++ b/datasets/nfts/nfts/datastore.py @@ -0,0 +1,109 @@ +""" +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 sqlite3 +from typing import Any, List, Tuple + +from .data import EventType, NFTEvent + +event_tables = {EventType.TRANSFER: "transfers", EventType.MINT: "mints"} + +CREATE_NFTS_TABLE_QUERY = """CREATE TABLE nfts + ( + address TEXT NOT NULL UNIQUE ON CONFLICT FAIL, + name TEXT, + symbol TEXT + ); +""" + + +def create_events_table_query(event_type: EventType) -> str: + creation_query = f""" +CREATE TABLE {event_tables[event_type]} + ( + transaction_hash TEXT, + block_number INTEGER, + nft_address TEXT REFERENCES nfts(address), + token_id TEXT, + from_address TEXT, + to_address TEXT, + value INT, + timestamp INT + ); + """ + return creation_query + + +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)) + 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 INTO {event_tables[event_type]}( + transaction_hash, + block_number, + nft_address, + token_id, + from_address, + to_address, + value, + timestamp +) VALUES (?, ?, ?, ?, ?, ?, ?, ?) + """ + return query + + +def nft_event_to_tuple(event: NFTEvent) -> Tuple[Any]: + """ + Converts an NFT event into a tuple for use with sqlite cursor executemany. This includes + dropping e.g. the event_type field. + """ + return ( + event.transaction_hash, + event.block_number, + event.nft_address, + event.token_id, + event.from_address, + event.to_address, + int(event.value), + event.timestamp, + ) + + +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 + ] + cur.executemany(insert_events_query(EventType.TRANSFER), transfers) + mints = [ + nft_event_to_tuple(event) + for event in events + if event.event_type == EventType.MINT + ] + cur.executemany(insert_events_query(EventType.MINT), mints) + conn.commit() + except Exception as e: + conn.rollback() + raise e diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 04ccbebd..6258469b 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,6 +1,5 @@ -from dataclasses import dataclass -from enum import Enum -from typing import List, Optional +import sqlite3 +from typing import Iterator, List, Optional from moonstreamdb.models import ( EthereumAddress, @@ -9,52 +8,33 @@ from moonstreamdb.models import ( EthereumBlock, ) from sqlalchemy.orm import Session +from tqdm import tqdm from web3 import Web3 - -@dataclass -class BlockBounds: - starting_block: int - ending_block: Optional[int] = None +from .data import BlockBounds, EventType, NFTEvent, event_types +from .datastore import insert_events -class EventType(Enum): - TRANSFER = "nft_transfer" - MINT = "nft_mint" - - -@dataclass -class NFTEvent: - 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 - - -def preproccess( - db_session: Session, web3_client: Web3, nft_events: List[NFTEvent] -) -> List[NFTEvent]: +def enrich_from_web3(web3_client: Web3, nft_event: NFTEvent) -> NFTEvent: """ Adds block number, value, timestamp from web3 if they are None (because that transaction is missing in db) """ - for nft_event in nft_events: - if nft_event.block_number is None: - transaction = web3_client.eth.get_transaction(nft_event.transaction_hash) - nft_event.value = transaction["value"] - nft_event.block_number = transaction["blockNumber"] - block = web3_client.eth.get_block(transaction["blockNumber"]) - nft_event.timestamp = block["timestamp"] - return nft_events + if ( + nft_event.block_number is None + or nft_event.value is None + or nft_event.timestamp is None + ): + transaction = web3_client.eth.get_transaction(nft_event.transaction_hash) + nft_event.value = transaction["value"] + nft_event.block_number = transaction["blockNumber"] + block = web3_client.eth.get_block(transaction["blockNumber"]) + nft_event.timestamp = block["timestamp"] + return nft_event -def get_rows( +def get_events_from_db( db_session: Session, event_type: EventType, bounds: Optional[BlockBounds] = None -) -> List[NFTEvent]: +) -> Iterator[NFTEvent]: query = ( db_session.query( EthereumLabel.label, @@ -75,11 +55,20 @@ def get_rows( EthereumTransaction.block_number == EthereumBlock.block_number, ) .filter(EthereumLabel.label == event_type.value) - .limit(10) + .limit(5) ) - return [ - NFTEvent( - event_type=label, + + for ( + label, + address, + label_data, + transaction_hash, + value, + block_number, + timestamp, + ) in query: + yield NFTEvent( + event_type=event_types[label], nft_address=address, token_id=label_data["tokenId"], from_address=label_data["from"], @@ -89,5 +78,27 @@ def get_rows( block_number=block_number, timestamp=timestamp, ) - for label, address, label_data, transaction_hash, value, block_number, timestamp in query - ] + + +def create_dataset( + datastore_conn: sqlite3.Connection, + db_session: Session, + web3_client: Web3, + event_type: EventType, + batch_size: int = 1000, +) -> None: + """ + Creates Moonstream NFTs dataset in the given SQLite datastore. + """ + events = map( + lambda e: enrich_from_web3(web3_client, e), + get_events_from_db(db_session, event_type), + ) + events_batch: List[NFTEvent] = [] + for event in tqdm(events): + print(event) + events_batch.append(event) + if len(events_batch) == batch_size: + insert_events(datastore_conn, events_batch) + events_batch = [] + insert_events(datastore_conn, events_batch) From 897bfda6845b03b9568abb344a647f02bdd9160b Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sun, 26 Sep 2021 13:06:09 -0700 Subject: [PATCH 11/87] Working version of "nfts initdb" and "nfts materialize" Started a job to collect NFT mints from production to a local SQLite datastore. It looks like it will take a few hours to complete. --- datasets/nfts/nfts/cli.py | 39 ++++++++++++-- datasets/nfts/nfts/datastore.py | 20 ++++---- datasets/nfts/nfts/materialize.py | 84 ++++++++++++++++++++----------- 3 files changed, 101 insertions(+), 42 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 8a66149a..8b9a62ef 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -1,5 +1,6 @@ import argparse import contextlib +import logging import os import sqlite3 from typing import Optional, Union @@ -7,11 +8,15 @@ from typing import Optional, Union from moonstreamdb.db import yield_db_session_ctx from web3 import Web3, IPCProvider, HTTPProvider -from .data import event_types, nft_event +from .data import event_types, nft_event, BlockBounds from .datastore import setup_database from .materialize import create_dataset +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + def web3_connection(web3_uri: Optional[str] = None) -> Web3: """ Connect to the given web3 provider. You may specify a web3 provider either as a path to an IPC @@ -37,11 +42,26 @@ def handle_initdb(args: argparse.Namespace) -> None: def handle_materialize(args: argparse.Namespace) -> None: event_type = nft_event(args.type) - print(args) + 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") + + 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, args.web3, event_type) + create_dataset( + moonstream_datastore, + db_session, + args.web3, + event_type, + bounds, + args.batch_size, + ) def main() -> None: @@ -89,6 +109,19 @@ def main() -> None: 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) args = parser.parse_args() diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index 538999fb..c50527c7 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -29,8 +29,8 @@ CREATE TABLE {event_tables[event_type]} token_id TEXT, from_address TEXT, to_address TEXT, - value INT, - timestamp INT + value INTEGER, + timestamp INTEGER ); """ return creation_query @@ -72,14 +72,14 @@ def nft_event_to_tuple(event: NFTEvent) -> Tuple[Any]: dropping e.g. the event_type field. """ return ( - event.transaction_hash, - event.block_number, - event.nft_address, - event.token_id, - event.from_address, - event.to_address, - int(event.value), - event.timestamp, + 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), ) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 6258469b..bc88462c 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,3 +1,4 @@ +import logging import sqlite3 from typing import Iterator, List, Optional @@ -7,6 +8,7 @@ from moonstreamdb.models import ( EthereumTransaction, EthereumBlock, ) +from sqlalchemy import or_ from sqlalchemy.orm import Session from tqdm import tqdm from web3 import Web3 @@ -14,6 +16,9 @@ from web3 import Web3 from .data import BlockBounds, EventType, NFTEvent, event_types from .datastore import insert_events +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + def enrich_from_web3(web3_client: Web3, nft_event: NFTEvent) -> NFTEvent: """ @@ -24,6 +29,7 @@ def enrich_from_web3(web3_client: Web3, nft_event: NFTEvent) -> NFTEvent: or nft_event.value is None or nft_event.timestamp is None ): + logger.info("Enriching from web3") transaction = web3_client.eth.get_transaction(nft_event.transaction_hash) nft_event.value = transaction["value"] nft_event.block_number = transaction["blockNumber"] @@ -32,8 +38,12 @@ def enrich_from_web3(web3_client: Web3, nft_event: NFTEvent) -> NFTEvent: return nft_event -def get_events_from_db( - db_session: Session, event_type: EventType, bounds: Optional[BlockBounds] = None +def get_events( + db_session: Session, + web3_client: Web3, + event_type: EventType, + bounds: Optional[BlockBounds] = None, + batch_size: int = 1000, ) -> Iterator[NFTEvent]: query = ( db_session.query( @@ -55,29 +65,46 @@ def get_events_from_db( EthereumTransaction.block_number == EthereumBlock.block_number, ) .filter(EthereumLabel.label == event_type.value) - .limit(5) ) + if bounds is not None: + bounds_filters = [ + EthereumTransaction.hash == None, + EthereumTransaction.block_number >= bounds.starting_block, + ] + if bounds.ending_block is not None: + bounds_filters.append( + EthereumTransaction.block_number <= bounds.ending_block + ) + query = query.filter(or_(*bounds_filters)) - for ( - label, - address, - label_data, - transaction_hash, - value, - block_number, - timestamp, - ) in query: - yield NFTEvent( - 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, - ) + offset = 0 + while True: + events = query.offset(offset).limit(batch_size).all() + if not events: + break + offset += batch_size + for ( + label, + address, + label_data, + transaction_hash, + value, + block_number, + timestamp, + ) in events: + raw_event = NFTEvent( + 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, + ) + event = enrich_from_web3(web3_client, raw_event) + yield event def create_dataset( @@ -85,20 +112,19 @@ def create_dataset( db_session: Session, web3_client: Web3, event_type: EventType, + bounds: Optional[BlockBounds] = None, batch_size: int = 1000, ) -> None: """ Creates Moonstream NFTs dataset in the given SQLite datastore. """ - events = map( - lambda e: enrich_from_web3(web3_client, e), - get_events_from_db(db_session, event_type), - ) + events = get_events(db_session, web3_client, event_type, bounds, batch_size) events_batch: List[NFTEvent] = [] - for event in tqdm(events): - print(event) + for event in tqdm(events, desc="Events processed", colour="#DD6E0F"): events_batch.append(event) if len(events_batch) == batch_size: + logger.info("Writing batch of events to datastore") insert_events(datastore_conn, events_batch) events_batch = [] + logger.info("Writing remaining events to datastore") insert_events(datastore_conn, events_batch) From e4f1fc2d15c825dd82293442deb36c3b0ed7c088 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Tue, 28 Sep 2021 16:50:02 +0300 Subject: [PATCH 12/87] Add init version off jrps requests class. --- datasets/nfts/nfts/cli.py | 11 +++- datasets/nfts/nfts/materialize.py | 88 ++++++++++++++++++++++++++++++- 2 files changed, 97 insertions(+), 2 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 8b9a62ef..86f4527e 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -10,7 +10,7 @@ from web3 import Web3, IPCProvider, HTTPProvider from .data import event_types, nft_event, BlockBounds from .datastore import setup_database -from .materialize import create_dataset +from .materialize import create_dataset, EthereumBatchloader logging.basicConfig(level=logging.INFO) @@ -48,6 +48,8 @@ def handle_materialize(args: argparse.Namespace) -> None: elif args.end is not None: raise ValueError("You cannot set --end unless you also set --start") + batch_loader = EthereumBatchloader(jrpc_url=args.jrpc) + logger.info(f"Materializing NFT events to datastore: {args.datastore}") logger.info(f"Block bounds: {bounds}") @@ -61,6 +63,7 @@ def handle_materialize(args: argparse.Namespace) -> None: event_type, bounds, args.batch_size, + batch_loader ) @@ -103,6 +106,12 @@ def main() -> None: type=web3_connection, help=f"Web3 provider to use when collecting data directly from the Ethereum blockchain (default: {default_web3_provider})", ) + parser_materialize.add_argument( + "--jrpc", + 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", diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index bc88462c..aef64b15 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,6 +1,9 @@ import logging import sqlite3 -from typing import Iterator, List, Optional +from typing import Any, Iterator, List, Optional +import json + +from sqlalchemy.sql.expression import select from moonstreamdb.models import ( EthereumAddress, @@ -12,6 +15,7 @@ from sqlalchemy import or_ from sqlalchemy.orm import Session from tqdm import tqdm from web3 import Web3 +import requests from .data import BlockBounds, EventType, NFTEvent, event_types from .datastore import insert_events @@ -20,6 +24,86 @@ logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) +class EthereumBatchloader: + def __init__(self, jrpc_url) -> None: + + self.jrpc_url = jrpc_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 put_to_batch(self, command: str, *params, **kwargs): + """ + Put command request to batch + """ + + self.message_number += 1 + rpc = { + "jsonrpc": "2.0", + "id": self.message_number, + "method": command, + "params": [i for i in params], + } + + self.requests_banch.append(rpc) + + self.commands.append(command) + + def send_message(self, payload): + headers = {"Content-Type": "application/json"} + + try: + r = requests.post(self.jrpc_url, headers=headers, data=payload) + except Exception as e: + print(e) + return r + + def send_json_message(self, message): + encoded_json = json.dumps(message) + response = self.send_message(encoded_json.encode("utf8")).json() + return response + + def process_batch(self): + """ + Start processing batch of requests + return dict with banches of responces + """ + + responses = self.send_json_message(self.requests_banch) + + returned_objects = {} + + for i, response in enumerate(responses): + if not returned_objects.get(self.commands[i]): + returned_objects[self.commands[i]] = [response] + else: + returned_objects[self.commands[i]].append(response) + + self.commands.clear() + self.requests_banch.clear() + self.message_number = 0 + + return returned_objects + + def enrich_from_web3(web3_client: Web3, nft_event: NFTEvent) -> NFTEvent: """ Adds block number, value, timestamp from web3 if they are None (because that transaction is missing in db) @@ -114,6 +198,7 @@ def create_dataset( event_type: EventType, bounds: Optional[BlockBounds] = None, batch_size: int = 1000, + batch_loader: EthereumBatchloader = None, ) -> None: """ Creates Moonstream NFTs dataset in the given SQLite datastore. @@ -128,3 +213,4 @@ def create_dataset( events_batch = [] logger.info("Writing remaining events to datastore") insert_events(datastore_conn, events_batch) + From c4db62be6565e9f80d56ea7bab4b9c8f14132380 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Tue, 28 Sep 2021 16:52:32 +0300 Subject: [PATCH 13/87] Remoce import. --- datasets/nfts/nfts/materialize.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index aef64b15..6c592b7c 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -3,8 +3,6 @@ import sqlite3 from typing import Any, Iterator, List, Optional import json -from sqlalchemy.sql.expression import select - from moonstreamdb.models import ( EthereumAddress, EthereumLabel, From 9a16ad207bd7121d27858fae591bc4f27a5ea46e Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Wed, 29 Sep 2021 00:25:01 +0300 Subject: [PATCH 14/87] added batching support for request to node --- datasets/nfts/nfts/materialize.py | 139 ++++++++++++++++-------------- 1 file changed, 74 insertions(+), 65 deletions(-) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 6c592b7c..832ebb73 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,6 +1,6 @@ import logging import sqlite3 -from typing import Any, Iterator, List, Optional +from typing import Any, Iterator, List, Optional, Set import json from moonstreamdb.models import ( @@ -15,7 +15,7 @@ from tqdm import tqdm from web3 import Web3 import requests -from .data import BlockBounds, EventType, NFTEvent, event_types +from .data import BlockBounds, EventType, NFTEvent, event_types, nft_event from .datastore import insert_events logging.basicConfig(level=logging.INFO) @@ -32,7 +32,7 @@ class EthereumBatchloader: def load_blocks(self, block_list: List[int], with_transactions: bool): """ - Request list of blocks + Request list of blocks """ rpc = [ { @@ -48,22 +48,22 @@ class EthereumBatchloader: response = self.send_json_message(rpc) return response - def put_to_batch(self, command: str, *params, **kwargs): + def load_transactions(self, transaction_hashes: List[str]): """ - Put command request to batch + Request list of transactions """ - self.message_number += 1 - rpc = { - "jsonrpc": "2.0", - "id": self.message_number, - "method": command, - "params": [i for i in params], - } - - self.requests_banch.append(rpc) - - self.commands.append(command) + 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"} @@ -76,48 +76,53 @@ class EthereumBatchloader: def send_json_message(self, message): encoded_json = json.dumps(message) - response = self.send_message(encoded_json.encode("utf8")).json() + raw_response = self.send_message(encoded_json.encode("utf8")) + response = raw_response.json() return response - def process_batch(self): - """ - Start processing batch of requests - return dict with banches of responces - """ - responses = self.send_json_message(self.requests_banch) - - returned_objects = {} - - for i, response in enumerate(responses): - if not returned_objects.get(self.commands[i]): - returned_objects[self.commands[i]] = [response] - else: - returned_objects[self.commands[i]].append(response) - - self.commands.clear() - self.requests_banch.clear() - self.message_number = 0 - - return returned_objects - - -def enrich_from_web3(web3_client: Web3, nft_event: NFTEvent) -> NFTEvent: +def enrich_from_web3( + web3_client: Web3, nft_events: NFTEvent, batch_loader: EthereumBatchloader +) -> NFTEvent: """ Adds block number, value, timestamp from web3 if they are None (because that transaction is missing in db) """ - if ( - nft_event.block_number is None - or nft_event.value is None - or nft_event.timestamp is None - ): - logger.info("Enriching from web3") - transaction = web3_client.eth.get_transaction(nft_event.transaction_hash) - nft_event.value = transaction["value"] - nft_event.block_number = transaction["blockNumber"] - block = web3_client.eth.get_block(transaction["blockNumber"]) - nft_event.timestamp = block["timestamp"] - return nft_event + transactions_to_query = { + nft_event.transaction_hash + for nft_event in nft_events + if (nft_event.value is None or nft_event.block_number is None) + } + + jrpc_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 jrpc_response + } + blocks_to_query: Set[int] = set() + indices_to_update: List[int] = [] + for index, nft_event in enumerate(nft_events): + if ( + nft_event.block_number is None + or nft_event.value is None + or nft_event.timestamp is None + ): + nft_event.value, nft_event.block_number = transactions_map[ + nft_event.transaction_hash + ] + blocks_to_query.add(nft_event.block_number) + indices_to_update.append(index) + + jrpc_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 jrpc_response + } + for index in indices_to_update: + nft_events[index].timestamp = blocks_map[nft_event.block_number] + return nft_events def get_events( @@ -125,7 +130,7 @@ def get_events( web3_client: Web3, event_type: EventType, bounds: Optional[BlockBounds] = None, - batch_size: int = 1000, + batch_size: int = 200, ) -> Iterator[NFTEvent]: query = ( db_session.query( @@ -147,6 +152,7 @@ def get_events( EthereumTransaction.block_number == EthereumBlock.block_number, ) .filter(EthereumLabel.label == event_type.value) + .order_by(EthereumLabel.created_at) ) if bounds is not None: bounds_filters = [ @@ -185,8 +191,7 @@ def get_events( block_number=block_number, timestamp=timestamp, ) - event = enrich_from_web3(web3_client, raw_event) - yield event + yield raw_event def create_dataset( @@ -195,20 +200,24 @@ def create_dataset( web3_client: Web3, event_type: EventType, bounds: Optional[BlockBounds] = None, - batch_size: int = 1000, + batch_size: int = 200, batch_loader: EthereumBatchloader = None, ) -> None: """ Creates Moonstream NFTs dataset in the given SQLite datastore. """ - events = get_events(db_session, web3_client, event_type, bounds, batch_size) - events_batch: List[NFTEvent] = [] - for event in tqdm(events, desc="Events processed", colour="#DD6E0F"): - events_batch.append(event) - if len(events_batch) == batch_size: + raw_events = get_events(db_session, web3_client, event_type, bounds, batch_size) + raw_events_batch: List[NFTEvent] = [] + for event in tqdm(raw_events, desc="Events processed", colour="#DD6E0F"): + raw_events_batch.append(event) + if len(raw_events_batch) == batch_size: logger.info("Writing batch of events to datastore") - insert_events(datastore_conn, events_batch) - events_batch = [] + insert_events( + datastore_conn, + enrich_from_web3(web3_client, raw_events_batch, batch_loader), + ) + raw_events_batch = [] logger.info("Writing remaining events to datastore") - insert_events(datastore_conn, events_batch) - + insert_events( + datastore_conn, enrich_from_web3(web3_client, raw_events_batch, batch_loader) + ) From 405aa3871e753b9d90fbd3514ea33f79821603c3 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Wed, 29 Sep 2021 14:44:57 +0300 Subject: [PATCH 15/87] added checkpoint --- datasets/nfts/nfts/datastore.py | 62 +++++++++++++++++++++++--- datasets/nfts/nfts/materialize.py | 72 +++++++++++++++++++------------ 2 files changed, 100 insertions(+), 34 deletions(-) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index c50527c7..2f0552b9 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -2,11 +2,15 @@ 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, List, Tuple +from typing import Any, List, Tuple, Optional + +from .data import EventType, NFTEvent, nft_event + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) -from .data import EventType, NFTEvent event_tables = {EventType.TRANSFER: "transfers", EventType.MINT: "mints"} @@ -18,6 +22,14 @@ CREATE_NFTS_TABLE_QUERY = """CREATE TABLE nfts ); """ +CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE checkpoint + ( + event_type STRING, + offset INTEGER, + transaction_hash STRING + ); +""" + def create_events_table_query(event_type: EventType) -> str: creation_query = f""" @@ -29,8 +41,9 @@ CREATE TABLE {event_tables[event_type]} token_id TEXT, from_address TEXT, to_address TEXT, - value INTEGER, - timestamp INTEGER + transaction_value INTEGER, + timestamp INTEGER, + UNIQUE (transaction_hash, nft_address, from_address, to_address, token_id) ); """ return creation_query @@ -44,6 +57,7 @@ def setup_database(conn: sqlite3.Connection) -> None: 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() @@ -59,7 +73,7 @@ INSERT INTO {event_tables[event_type]}( token_id, from_address, to_address, - value, + transaction_value, timestamp ) VALUES (?, ?, ?, ?, ?, ?, ?, ?) """ @@ -83,6 +97,32 @@ def nft_event_to_tuple(event: NFTEvent) -> Tuple[Any]: ) +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 insert_checkpoint( + conn: sqlite3.Connection, event_type: EventType, offset: int, transaction_hash: str +): + query = f""" + INSERT INTO checkpoint ( + event_type, + offset, + transaction_hash + ) VALUES (?, ?, ?) + """ + cur = conn.cursor() + cur.execute(query, [event_type.value, offset, transaction_hash]) + + def insert_events(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: """ Inserts the given events into the appropriate events table in the given SQLite database. @@ -102,8 +142,18 @@ def insert_events(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: for event in events if event.event_type == EventType.MINT ] + # transfers = [] + # mints = [] + # for event in events: + # if event.event_type == EventType.TRANSFER: + # transfers.append(nft_event_to_tuple(event)) + # elif event.event_type == EventType.MINT: + # mints.append(nft_event_to_tuple(event)) + 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 diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 832ebb73..107c2dcd 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -16,7 +16,7 @@ from web3 import Web3 import requests from .data import BlockBounds, EventType, NFTEvent, event_types, nft_event -from .datastore import insert_events +from .datastore import get_checkpoint_offset, insert_checkpoint, insert_events logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) @@ -69,7 +69,7 @@ class EthereumBatchloader: headers = {"Content-Type": "application/json"} try: - r = requests.post(self.jrpc_url, headers=headers, data=payload) + r = requests.post(self.jrpc_url, headers=headers, data=payload, timeout=300) except Exception as e: print(e) return r @@ -82,17 +82,24 @@ class EthereumBatchloader: def enrich_from_web3( - web3_client: Web3, nft_events: NFTEvent, batch_loader: EthereumBatchloader -) -> NFTEvent: + web3_client: 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 = { - nft_event.transaction_hash - for nft_event in nft_events - if (nft_event.value is None or nft_event.block_number is None) - } + transactions_to_query = set() + indices_to_update: List[int] = [] + for index, nft_event in enumerate(nft_events): + if ( + nft_event.block_number is None + or nft_event.value is None + or nft_event.timestamp is None + ): + transactions_to_query.add(nft_event.transaction_hash) + indices_to_update.append(index) + if len(transactions_to_query) == 0: + return nft_events jrpc_response = batch_loader.load_transactions(list(transactions_to_query)) transactions_map = { result["result"]["hash"]: ( @@ -101,20 +108,16 @@ def enrich_from_web3( ) for result in jrpc_response } - blocks_to_query: Set[int] = set() - indices_to_update: List[int] = [] - for index, nft_event in enumerate(nft_events): - if ( - nft_event.block_number is None - or nft_event.value is None - or nft_event.timestamp is None - ): - nft_event.value, nft_event.block_number = transactions_map[ - nft_event.transaction_hash - ] - blocks_to_query.add(nft_event.block_number) - indices_to_update.append(index) + 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(nft_events[index].block_number) + + if len(blocks_to_query) == 0: + return nft_events jrpc_response = batch_loader.load_blocks(list(blocks_to_query), False) blocks_map = { int(result["result"]["number"], 16): int(result["result"]["timestamp"], 16) @@ -127,10 +130,10 @@ def enrich_from_web3( def get_events( db_session: Session, - web3_client: Web3, event_type: EventType, bounds: Optional[BlockBounds] = None, - batch_size: int = 200, + offset: int = 0, + batch_size: int = 1000, ) -> Iterator[NFTEvent]: query = ( db_session.query( @@ -165,7 +168,6 @@ def get_events( ) query = query.filter(or_(*bounds_filters)) - offset = 0 while True: events = query.offset(offset).limit(batch_size).all() if not events: @@ -200,21 +202,35 @@ def create_dataset( web3_client: Web3, event_type: EventType, bounds: Optional[BlockBounds] = None, - batch_size: int = 200, + batch_size: int = 1000, batch_loader: EthereumBatchloader = None, ) -> None: """ Creates Moonstream NFTs dataset in the given SQLite datastore. """ - raw_events = get_events(db_session, web3_client, event_type, bounds, batch_size) + 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}") + + raw_events = get_events(db_session, event_type, bounds, offset, batch_size) raw_events_batch: List[NFTEvent] = [] + for event in tqdm(raw_events, desc="Events processed", colour="#DD6E0F"): raw_events_batch.append(event) if len(raw_events_batch) == batch_size: logger.info("Writing batch of events to datastore") + insert_events( datastore_conn, - enrich_from_web3(web3_client, raw_events_batch, batch_loader), + raw_events, + ) + offset += batch_size + + insert_checkpoint( + datastore_conn, event_type, offset, event.transaction_hash ) raw_events_batch = [] logger.info("Writing remaining events to datastore") From fe4fa6c6fde55f87d978c11a1cbbe611fb24eb43 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Wed, 29 Sep 2021 15:41:50 +0300 Subject: [PATCH 16/87] temporary fix --- datasets/nfts/nfts/cli.py | 2 +- datasets/nfts/nfts/datastore.py | 15 ++++++--------- datasets/nfts/nfts/materialize.py | 22 +++++++++++----------- datasets/nfts/setup.py | 3 ++- 4 files changed, 20 insertions(+), 22 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 86f4527e..21b704bb 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -61,9 +61,9 @@ def handle_materialize(args: argparse.Namespace) -> None: db_session, args.web3, event_type, + batch_loader, bounds, args.batch_size, - batch_loader ) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index 2f0552b9..ff9466fc 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -80,7 +80,9 @@ INSERT INTO {event_tables[event_type]}( return query -def nft_event_to_tuple(event: NFTEvent) -> Tuple[Any]: +def nft_event_to_tuple( + event: NFTEvent, +) -> Tuple[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. @@ -121,6 +123,7 @@ def insert_checkpoint( """ cur = conn.cursor() cur.execute(query, [event_type.value, offset, transaction_hash]) + conn.commit() def insert_events(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: @@ -136,19 +139,13 @@ def insert_events(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: for event in events if event.event_type == EventType.TRANSFER ] - cur.executemany(insert_events_query(EventType.TRANSFER), transfers) + mints = [ nft_event_to_tuple(event) for event in events if event.event_type == EventType.MINT ] - # transfers = [] - # mints = [] - # for event in events: - # if event.event_type == EventType.TRANSFER: - # transfers.append(nft_event_to_tuple(event)) - # elif event.event_type == EventType.MINT: - # mints.append(nft_event_to_tuple(event)) + cur.executemany(insert_events_query(EventType.TRANSFER), transfers) cur.executemany(insert_events_query(EventType.MINT), mints) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 107c2dcd..408c0fd7 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,6 +1,6 @@ import logging import sqlite3 -from typing import Any, Iterator, List, Optional, Set +from typing import Any, cast, Iterator, List, Optional, Set import json from moonstreamdb.models import ( @@ -82,7 +82,9 @@ class EthereumBatchloader: def enrich_from_web3( - web3_client: Web3, nft_events: List[NFTEvent], batch_loader: EthereumBatchloader + web3_client: 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) @@ -101,6 +103,7 @@ def enrich_from_web3( if len(transactions_to_query) == 0: return nft_events jrpc_response = batch_loader.load_transactions(list(transactions_to_query)) + breakpoint() transactions_map = { result["result"]["hash"]: ( int(result["result"]["value"], 16), @@ -114,7 +117,7 @@ def enrich_from_web3( nft_events[index].value, nft_events[index].block_number = transactions_map[ nft_events[index].transaction_hash ] - blocks_to_query.add(nft_events[index].block_number) + blocks_to_query.add(cast(int, nft_events[index].block_number)) if len(blocks_to_query) == 0: return nft_events @@ -124,7 +127,7 @@ def enrich_from_web3( for result in jrpc_response } for index in indices_to_update: - nft_events[index].timestamp = blocks_map[nft_event.block_number] + nft_events[index].timestamp = blocks_map[cast(int, nft_event.block_number)] return nft_events @@ -132,7 +135,7 @@ def get_events( db_session: Session, event_type: EventType, bounds: Optional[BlockBounds] = None, - offset: int = 0, + initial_offset: int = 0, batch_size: int = 1000, ) -> Iterator[NFTEvent]: query = ( @@ -167,7 +170,7 @@ def get_events( EthereumTransaction.block_number <= bounds.ending_block ) query = query.filter(or_(*bounds_filters)) - + offset = initial_offset while True: events = query.offset(offset).limit(batch_size).all() if not events: @@ -201,9 +204,9 @@ def create_dataset( db_session: Session, web3_client: Web3, event_type: EventType, + batch_loader: EthereumBatchloader, bounds: Optional[BlockBounds] = None, batch_size: int = 1000, - batch_loader: EthereumBatchloader = None, ) -> None: """ Creates Moonstream NFTs dataset in the given SQLite datastore. @@ -223,10 +226,7 @@ def create_dataset( if len(raw_events_batch) == batch_size: logger.info("Writing batch of events to datastore") - insert_events( - datastore_conn, - raw_events, - ) + insert_events(datastore_conn, raw_events_batch) offset += batch_size insert_checkpoint( diff --git a/datasets/nfts/setup.py b/datasets/nfts/setup.py index 6cf9ef9f..23c5542a 100644 --- a/datasets/nfts/setup.py +++ b/datasets/nfts/setup.py @@ -35,9 +35,10 @@ setup( "humbug", "tqdm", "web3", + "requests", ], extras_require={ - "dev": ["black", "mypy"], + "dev": ["black", "mypy", "types-requests"], "distribute": ["setuptools", "twine", "wheel"], }, entry_points={"console_scripts": []}, From c0d3f23500eebe1abe21f41a5f9b5e52ab5f2752 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Wed, 29 Sep 2021 20:47:36 +0300 Subject: [PATCH 17/87] removed unique constraint --- datasets/nfts/nfts/datastore.py | 3 +-- datasets/nfts/nfts/materialize.py | 41 +++++++++++++++++++++---------- 2 files changed, 29 insertions(+), 15 deletions(-) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index ff9466fc..b0d15be9 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -42,8 +42,7 @@ CREATE TABLE {event_tables[event_type]} from_address TEXT, to_address TEXT, transaction_value INTEGER, - timestamp INTEGER, - UNIQUE (transaction_hash, nft_address, from_address, to_address, token_id) + timestamp INTEGER ); """ return creation_query diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 408c0fd7..c1ecdff4 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -9,13 +9,13 @@ from moonstreamdb.models import ( EthereumTransaction, EthereumBlock, ) -from sqlalchemy import or_ +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, event_types, nft_event +from .data import BlockBounds, EventType, NFTEvent, event_types from .datastore import get_checkpoint_offset, insert_checkpoint, insert_events logging.basicConfig(level=logging.INFO) @@ -102,6 +102,7 @@ def enrich_from_web3( if len(transactions_to_query) == 0: return nft_events + logger.info("Calling jrpc") jrpc_response = batch_loader.load_transactions(list(transactions_to_query)) breakpoint() transactions_map = { @@ -158,17 +159,18 @@ def get_events( EthereumTransaction.block_number == EthereumBlock.block_number, ) .filter(EthereumLabel.label == event_type.value) - .order_by(EthereumLabel.created_at) + .order_by( + EthereumLabel.created_at.asc(), + EthereumLabel.transaction_hash.asc(), + EthereumLabel.address_id.asc(), + ) ) if bounds is not None: - bounds_filters = [ - EthereumTransaction.hash == None, - EthereumTransaction.block_number >= bounds.starting_block, - ] + time_filters = [EthereumTransaction.block_number >= bounds.starting_block] if bounds.ending_block is not None: - bounds_filters.append( - EthereumTransaction.block_number <= bounds.ending_block - ) + time_filters.append(EthereumTransaction.block_number <= bounds.ending_block) + bounds_filters = [EthereumTransaction.hash == None, and_(*time_filters)] + query = query.filter(or_(*bounds_filters)) offset = initial_offset while True: @@ -218,7 +220,7 @@ def create_dataset( offset = 0 logger.info(f"Did not found any checkpoint for {event_type.value}") - raw_events = get_events(db_session, event_type, bounds, offset, batch_size) + raw_events = get_events(db_session, event_type, None, offset, batch_size) raw_events_batch: List[NFTEvent] = [] for event in tqdm(raw_events, desc="Events processed", colour="#DD6E0F"): @@ -226,14 +228,27 @@ def create_dataset( if len(raw_events_batch) == batch_size: logger.info("Writing batch of events to datastore") - insert_events(datastore_conn, raw_events_batch) + insert_events( + datastore_conn, + enrich_from_web3(web3_client, raw_events_batch, batch_loader), + ) offset += batch_size insert_checkpoint( - datastore_conn, event_type, offset, event.transaction_hash + datastore_conn, + event_type, + offset, + event.transaction_hash, ) raw_events_batch = [] logger.info("Writing remaining events to datastore") insert_events( datastore_conn, enrich_from_web3(web3_client, raw_events_batch, batch_loader) ) + offset += len(raw_events_batch) + insert_checkpoint( + datastore_conn, + event_type, + offset, + raw_events_batch[-1].transaction_hash, + ) From 4be1fe4d7af09baebc03f5c9527e6d4439e3a447 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Wed, 29 Sep 2021 12:56:39 -0700 Subject: [PATCH 18/87] Added "nfts derive" command Removed old web3 provider code in favor of @Andrei-Dolgolev's batching interface. --- datasets/nfts/nfts/cli.py | 53 ++++++++++++++------------- datasets/nfts/nfts/datastore.py | 10 +++--- datasets/nfts/nfts/derive.py | 59 +++++++++++++++++++++++++++++++ datasets/nfts/nfts/materialize.py | 46 +++++++++++++++--------- 4 files changed, 121 insertions(+), 47 deletions(-) create mode 100644 datasets/nfts/nfts/derive.py diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 21b704bb..32a2d61c 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -10,6 +10,7 @@ from web3 import Web3, IPCProvider, HTTPProvider from .data import event_types, nft_event, BlockBounds from .datastore import setup_database +from .derive import current_owners from .materialize import create_dataset, EthereumBatchloader @@ -17,24 +18,6 @@ logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) -def web3_connection(web3_uri: Optional[str] = None) -> Web3: - """ - Connect to the given web3 provider. You may specify a web3 provider either as a path to an IPC - socket on your filesystem or as an HTTP(S) URI to a JSON RPC provider. - - If web3_uri is not provided or is set to None, this function attempts to use the default behavior - of the web3.py IPCProvider (one of the steps is looking for .ethereum/geth.ipc, but there may be others). - """ - web3_provider: Union[IPCProvider, HTTPProvider] = Web3.IPCProvider() - if web3_uri is not None: - if web3_uri.startswith("http://") or web3_uri.startswith("https://"): - web3_provider = Web3.HTTPProvider(web3_uri) - else: - web3_provider = Web3.IPCProvider(web3_uri) - web3_client = Web3(web3_provider) - return web3_client - - def handle_initdb(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.datastore)) as conn: setup_database(conn) @@ -48,7 +31,7 @@ def handle_materialize(args: argparse.Namespace) -> None: elif args.end is not None: raise ValueError("You cannot set --end unless you also set --start") - batch_loader = EthereumBatchloader(jrpc_url=args.jrpc) + batch_loader = EthereumBatchloader(jsonrpc_url=args.jsonrpc) logger.info(f"Materializing NFT events to datastore: {args.datastore}") logger.info(f"Block bounds: {bounds}") @@ -59,7 +42,6 @@ def handle_materialize(args: argparse.Namespace) -> None: create_dataset( moonstream_datastore, db_session, - args.web3, event_type, batch_loader, bounds, @@ -67,6 +49,12 @@ def handle_materialize(args: argparse.Namespace) -> None: ) +def handle_derive(args: argparse.Namespace) -> None: + with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: + results = current_owners(moonstream_datastore) + logger.info("Done!") + + def main() -> None: """ "nfts" command handler. @@ -76,6 +64,12 @@ def main() -> None: # 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" @@ -101,13 +95,7 @@ def main() -> None: help="Path to SQLite database representing the dataset", ) parser_materialize.add_argument( - "--web3", - default=default_web3_provider, - type=web3_connection, - help=f"Web3 provider to use when collecting data directly from the Ethereum blockchain (default: {default_web3_provider})", - ) - parser_materialize.add_argument( - "--jrpc", + "--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})", @@ -133,6 +121,17 @@ def main() -> None: ) 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.set_defaults(func=handle_derive) + args = parser.parse_args() args.func(args) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index b0d15be9..9dc96b4a 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -14,7 +14,7 @@ logger = logging.getLogger(__name__) event_tables = {EventType.TRANSFER: "transfers", EventType.MINT: "mints"} -CREATE_NFTS_TABLE_QUERY = """CREATE TABLE nfts +CREATE_NFTS_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS nfts ( address TEXT NOT NULL UNIQUE ON CONFLICT FAIL, name TEXT, @@ -22,8 +22,8 @@ CREATE_NFTS_TABLE_QUERY = """CREATE TABLE nfts ); """ -CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE checkpoint - ( +CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS checkpoint + ( event_type STRING, offset INTEGER, transaction_hash STRING @@ -33,7 +33,7 @@ CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE checkpoint def create_events_table_query(event_type: EventType) -> str: creation_query = f""" -CREATE TABLE {event_tables[event_type]} +CREATE TABLE IF NOT EXISTS {event_tables[event_type]} ( transaction_hash TEXT, block_number INTEGER, @@ -53,10 +53,12 @@ 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() diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py new file mode 100644 index 00000000..dc13c7c4 --- /dev/null +++ b/datasets/nfts/nfts/derive.py @@ -0,0 +1,59 @@ +""" +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 +from typing import List, Tuple +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 + + +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) + + +def current_owners(conn: sqlite3.Connection) -> List[Tuple]: + """ + 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, CAST(last_value(to_address) AS TEXT) AS owner 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) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index c1ecdff4..664f4ce0 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,3 +1,4 @@ +from dataclasses import is_dataclass import logging import sqlite3 from typing import Any, cast, Iterator, List, Optional, Set @@ -23,9 +24,8 @@ logger = logging.getLogger(__name__) class EthereumBatchloader: - def __init__(self, jrpc_url) -> None: - - self.jrpc_url = jrpc_url + def __init__(self, jsonrpc_url) -> None: + self.jsonrpc_url = jsonrpc_url self.message_number = 0 self.commands: List[Any] = [] self.requests_banch: List[Any] = [] @@ -69,7 +69,9 @@ class EthereumBatchloader: headers = {"Content-Type": "application/json"} try: - r = requests.post(self.jrpc_url, headers=headers, data=payload, timeout=300) + r = requests.post( + self.jsonrpc_url, headers=headers, data=payload, timeout=300 + ) except Exception as e: print(e) return r @@ -82,9 +84,9 @@ class EthereumBatchloader: def enrich_from_web3( - web3_client: Web3, nft_events: List[NFTEvent], batch_loader: EthereumBatchloader, + bounds: Optional[BlockBounds] = None, ) -> List[NFTEvent]: """ Adds block number, value, timestamp from web3 if they are None (because that transaction is missing in db) @@ -102,15 +104,16 @@ def enrich_from_web3( if len(transactions_to_query) == 0: return nft_events - logger.info("Calling jrpc") - jrpc_response = batch_loader.load_transactions(list(transactions_to_query)) - breakpoint() + 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 jrpc_response + for result in jsonrpc_transactions_response } blocks_to_query: Set[int] = set() @@ -122,14 +125,26 @@ def enrich_from_web3( if len(blocks_to_query) == 0: return nft_events - jrpc_response = batch_loader.load_blocks(list(blocks_to_query), False) + 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 jrpc_response + 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 check_bounds(event: NFTEvent) -> bool: + if bounds is None: + return True + is_admissible = True + if event.block_number < bounds.starting_block: + is_admissible = False + if bounds.ending_block is not None and event.block_number > bounds.ending_block: + is_admissible = False + return is_admissible + + admissible_events = [event for event in nft_events if check_bounds(event)] + return admissible_events def get_events( @@ -204,7 +219,6 @@ def get_events( def create_dataset( datastore_conn: sqlite3.Connection, db_session: Session, - web3_client: Web3, event_type: EventType, batch_loader: EthereumBatchloader, bounds: Optional[BlockBounds] = None, @@ -220,7 +234,7 @@ def create_dataset( offset = 0 logger.info(f"Did not found any checkpoint for {event_type.value}") - raw_events = get_events(db_session, event_type, None, offset, batch_size) + raw_events = get_events(db_session, event_type, bounds, offset, batch_size) raw_events_batch: List[NFTEvent] = [] for event in tqdm(raw_events, desc="Events processed", colour="#DD6E0F"): @@ -230,7 +244,7 @@ def create_dataset( insert_events( datastore_conn, - enrich_from_web3(web3_client, raw_events_batch, batch_loader), + enrich_from_web3(raw_events_batch, batch_loader, bounds), ) offset += batch_size @@ -243,7 +257,7 @@ def create_dataset( raw_events_batch = [] logger.info("Writing remaining events to datastore") insert_events( - datastore_conn, enrich_from_web3(web3_client, raw_events_batch, batch_loader) + datastore_conn, enrich_from_web3(raw_events_batch, batch_loader, bounds) ) offset += len(raw_events_batch) insert_checkpoint( From 3f57c985f750b50ca4ac3e02a7d598ee69a7ee8c Mon Sep 17 00:00:00 2001 From: kompotkot Date: Thu, 30 Sep 2021 11:13:11 +0000 Subject: [PATCH 19/87] Added some additional info for common routes --- backend/moonstream/api.py | 26 +++++++++++++++++++------- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/backend/moonstream/api.py b/backend/moonstream/api.py index 85032c86..74ee466c 100644 --- a/backend/moonstream/api.py +++ b/backend/moonstream/api.py @@ -25,12 +25,15 @@ logger = logging.getLogger(__name__) tags_metadata = [ - {"name": "addressinfo", "description": "Address public information."}, - {"name": "labels", "description": "Addresses label information."}, - {"name": "nft", "description": "NFT market summaries"}, - {"name": "streams", "description": "Operations with data stream and filters."}, - {"name": "subscriptions", "description": "Operations with subscriptions."}, - {"name": "time", "description": "Timestamp endpoints."}, + {"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."}, @@ -74,23 +77,32 @@ app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) @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 """ From cb2c65b0edc0e4760cdda5115e3b7c55a49743ce Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Thu, 30 Sep 2021 17:35:05 +0300 Subject: [PATCH 20/87] added crawling of erc721 --- datasets/nfts/nfts/data.py | 9 ++++++ datasets/nfts/nfts/datastore.py | 29 ++++++++++++++++-- datasets/nfts/nfts/materialize.py | 51 +++++++++++++++++++++++++++++-- 3 files changed, 84 insertions(+), 5 deletions(-) diff --git a/datasets/nfts/nfts/data.py b/datasets/nfts/nfts/data.py index df967ead..da70e5cb 100644 --- a/datasets/nfts/nfts/data.py +++ b/datasets/nfts/nfts/data.py @@ -3,6 +3,7 @@ Data structures used in (and as part of the maintenance of) the Moonstream NFTs """ from dataclasses import dataclass from enum import Enum +from os import name from typing import Optional @@ -15,6 +16,7 @@ class BlockBounds: class EventType(Enum): TRANSFER = "nft_transfer" MINT = "nft_mint" + ERC721 = "erc721" event_types = {event_type.value: event_type for event_type in EventType} @@ -38,3 +40,10 @@ class NFTEvent: 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/datastore.py b/datasets/nfts/nfts/datastore.py index 9dc96b4a..acd41964 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -6,7 +6,7 @@ import logging import sqlite3 from typing import Any, List, Tuple, Optional -from .data import EventType, NFTEvent, nft_event +from .data import EventType, NFTEvent, NFTMetadata logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) @@ -18,7 +18,8 @@ CREATE_NFTS_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS nfts ( address TEXT NOT NULL UNIQUE ON CONFLICT FAIL, name TEXT, - symbol TEXT + symbol TEXT, + UNIQUE(address, name, symbol) ); """ @@ -127,6 +128,30 @@ def insert_checkpoint( 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. diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 664f4ce0..1464b128 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -16,8 +16,13 @@ from tqdm import tqdm from web3 import Web3 import requests -from .data import BlockBounds, EventType, NFTEvent, event_types -from .datastore import get_checkpoint_offset, insert_checkpoint, insert_events +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__) @@ -164,6 +169,7 @@ def get_events( EthereumTransaction.block_number, EthereumBlock.timestamp, ) + .filter(EthereumLabel.label == event_type.value) .join(EthereumAddress, EthereumLabel.address_id == EthereumAddress.id) .outerjoin( EthereumTransaction, @@ -173,7 +179,6 @@ def get_events( EthereumBlock, EthereumTransaction.block_number == EthereumBlock.block_number, ) - .filter(EthereumLabel.label == event_type.value) .order_by( EthereumLabel.created_at.asc(), EthereumLabel.transaction_hash.asc(), @@ -234,6 +239,9 @@ def create_dataset( 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) + return raw_events = get_events(db_session, event_type, bounds, offset, batch_size) raw_events_batch: List[NFTEvent] = [] @@ -266,3 +274,40 @@ def create_dataset( offset, raw_events_batch[-1].transaction_hash, ) + + +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, "ERC721 checkpoint") + logger.info(f"Already added {offset}") + + logger.info(f"Added total of {offset-initial_offset} nfts metadata") From da3db29e0a508375ee9cb5af1d14152971aa8e97 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Sat, 2 Oct 2021 03:03:08 +0300 Subject: [PATCH 21/87] added qurying over created adds, and other fixes --- datasets/nfts/nfts/data.py | 1 + datasets/nfts/nfts/datastore.py | 27 ++++---- datasets/nfts/nfts/materialize.py | 102 ++++++++++++++++-------------- 3 files changed, 69 insertions(+), 61 deletions(-) diff --git a/datasets/nfts/nfts/data.py b/datasets/nfts/nfts/data.py index da70e5cb..7358dcd4 100644 --- a/datasets/nfts/nfts/data.py +++ b/datasets/nfts/nfts/data.py @@ -31,6 +31,7 @@ def nft_event(raw_event: str) -> EventType: @dataclass class NFTEvent: + event_id: str event_type: EventType nft_address: str token_id: str diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index acd41964..558b54e8 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -15,7 +15,7 @@ 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, @@ -26,8 +26,7 @@ CREATE_NFTS_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS nfts CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS checkpoint ( event_type STRING, - offset INTEGER, - transaction_hash STRING + offset INTEGER ); """ @@ -35,7 +34,8 @@ CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS checkpoint 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), @@ -68,7 +68,8 @@ def insert_events_query(event_type: EventType) -> str: Generates a query which inserts NFT events into the appropriate events table. """ query = f""" -INSERT INTO {event_tables[event_type]}( +INSERT OR IGNORE INTO {event_tables[event_type]}( + event_id, transaction_hash, block_number, nft_address, @@ -77,19 +78,20 @@ INSERT INTO {event_tables[event_type]}( to_address, transaction_value, timestamp -) VALUES (?, ?, ?, ?, ?, ?, ?, ?) +) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) """ return query def nft_event_to_tuple( event: NFTEvent, -) -> Tuple[str, str, str, str, str, str, str, str]: +) -> 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), @@ -113,18 +115,15 @@ def get_checkpoint_offset( return None -def insert_checkpoint( - conn: sqlite3.Connection, event_type: EventType, offset: int, transaction_hash: str -): +def insert_checkpoint(conn: sqlite3.Connection, event_type: EventType, offset: int): query = f""" INSERT INTO checkpoint ( event_type, - offset, - transaction_hash - ) VALUES (?, ?, ?) + offset + ) VALUES (?, ?) """ cur = conn.cursor() - cur.execute(query, [event_type.value, offset, transaction_hash]) + cur.execute(query, [event_type.value, offset]) conn.commit() diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 1464b128..29479959 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -152,15 +152,28 @@ def enrich_from_web3( return admissible_events -def get_events( +def add_events( + datastore_conn: sqlite3.Connection, db_session: Session, event_type: EventType, + batch_loader: EthereumBatchloader, + initial_offset=0, bounds: Optional[BlockBounds] = None, - initial_offset: int = 0, - batch_size: int = 1000, -) -> Iterator[NFTEvent]: + 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, @@ -181,8 +194,6 @@ def get_events( ) .order_by( EthereumLabel.created_at.asc(), - EthereumLabel.transaction_hash.asc(), - EthereumLabel.address_id.asc(), ) ) if bounds is not None: @@ -192,13 +203,23 @@ def get_events( bounds_filters = [EthereumTransaction.hash == None, and_(*time_filters)] query = query.filter(or_(*bounds_filters)) - offset = initial_offset - while True: - events = query.offset(offset).limit(batch_size).all() + + 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: - break - offset += batch_size + continue + + raw_events_batch = [] for ( + event_id, label, address, label_data, @@ -208,6 +229,7 @@ def get_events( timestamp, ) in events: raw_event = NFTEvent( + event_id=event_id, event_type=event_types[label], nft_address=address, token_id=label_data["tokenId"], @@ -218,7 +240,16 @@ def get_events( block_number=block_number, timestamp=timestamp, ) - yield raw_event + raw_events_batch.append(raw_event) + + logger.info(f"Adding {len(raw_events_batch)} to database") + insert_events( + datastore_conn, enrich_from_web3(raw_events_batch, batch_loader, bounds) + ) + 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( @@ -227,7 +258,7 @@ def create_dataset( event_type: EventType, batch_loader: EthereumBatchloader, bounds: Optional[BlockBounds] = None, - batch_size: int = 1000, + batch_size: int = 10, ) -> None: """ Creates Moonstream NFTs dataset in the given SQLite datastore. @@ -241,39 +272,16 @@ def create_dataset( if event_type == EventType.ERC721: add_contracts_metadata(datastore_conn, db_session, offset, batch_size) - return - raw_events = get_events(db_session, event_type, bounds, offset, batch_size) - raw_events_batch: List[NFTEvent] = [] - - for event in tqdm(raw_events, desc="Events processed", colour="#DD6E0F"): - raw_events_batch.append(event) - if len(raw_events_batch) == batch_size: - logger.info("Writing batch of events to datastore") - - insert_events( - datastore_conn, - enrich_from_web3(raw_events_batch, batch_loader, bounds), - ) - offset += batch_size - - insert_checkpoint( - datastore_conn, - event_type, - offset, - event.transaction_hash, - ) - raw_events_batch = [] - logger.info("Writing remaining events to datastore") - insert_events( - datastore_conn, enrich_from_web3(raw_events_batch, batch_loader, bounds) - ) - offset += len(raw_events_batch) - insert_checkpoint( - datastore_conn, - event_type, - offset, - raw_events_batch[-1].transaction_hash, - ) + else: + add_events( + datastore_conn, + db_session, + event_type, + batch_loader, + offset, + bounds, + batch_size, + ) def add_contracts_metadata( @@ -307,7 +315,7 @@ def add_contracts_metadata( ) ) insert_address_metadata(datastore_conn, events_batch) - insert_checkpoint(datastore_conn, EventType.ERC721, offset, "ERC721 checkpoint") + insert_checkpoint(datastore_conn, EventType.ERC721, offset) logger.info(f"Already added {offset}") logger.info(f"Added total of {offset-initial_offset} nfts metadata") From 3dec9fc5f69fee9e8d25ed1d84e8f46d486af1d3 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Sat, 2 Oct 2021 16:46:28 +0300 Subject: [PATCH 22/87] removed calling enrich from web3 --- datasets/nfts/nfts/materialize.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 29479959..e4f60561 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -244,8 +244,8 @@ def add_events( logger.info(f"Adding {len(raw_events_batch)} to database") insert_events( - datastore_conn, enrich_from_web3(raw_events_batch, batch_loader, bounds) - ) + 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 From 2f3978d4165e4189206e79bb45ebf2e71eba4fb8 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 2 Oct 2021 11:16:16 -0700 Subject: [PATCH 23/87] Added "nfts import-data" command Tested on small databases. Yet to test on real datasets. First test will be merge of @Yhtiyar's dataset with transfers and my dataset with mints. --- datasets/nfts/nfts/cli.py | 40 +++++++++- datasets/nfts/nfts/datastore.py | 126 +++++++++++++++++++++++++++++--- 2 files changed, 151 insertions(+), 15 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 32a2d61c..fbb58590 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -3,13 +3,12 @@ import contextlib import logging import os import sqlite3 -from typing import Optional, Union +from typing import Optional from moonstreamdb.db import yield_db_session_ctx -from web3 import Web3, IPCProvider, HTTPProvider from .data import event_types, nft_event, BlockBounds -from .datastore import setup_database +from .datastore import setup_database, import_data from .derive import current_owners from .materialize import create_dataset, EthereumBatchloader @@ -23,6 +22,14 @@ def handle_initdb(args: argparse.Namespace) -> None: 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_materialize(args: argparse.Namespace) -> None: event_type = nft_event(args.type) bounds: Optional[BlockBounds] = None @@ -132,6 +139,33 @@ def main() -> None: ) 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) + args = parser.parse_args() args.func(args) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index 558b54e8..acbf9658 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -4,7 +4,7 @@ a datastore for a Moonstream NFTs dataset. """ import logging import sqlite3 -from typing import Any, List, Tuple, Optional +from typing import Any, cast, List, Tuple, Optional, Union from .data import EventType, NFTEvent, NFTMetadata @@ -15,7 +15,7 @@ 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, @@ -23,6 +23,10 @@ CREATE_NFTS_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS nfts ); """ +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, @@ -34,7 +38,7 @@ CREATE_CHECKPOINT_TABLE_QUERY = """CREATE TABLE IF NOT EXISTS checkpoint 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, @@ -49,6 +53,34 @@ CREATE TABLE IF NOT EXISTS {event_tables[event_type]} 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, + block_number, + nft_address, + token_id, + from_address, + to_address, + transaction_value, + timestamp +FROM {event_tables[event_type]}; + """ + + return selection_query + + def setup_database(conn: sqlite3.Connection) -> None: """ Sets up the schema of the Moonstream NFTs dataset in the given SQLite database. @@ -117,10 +149,10 @@ def get_checkpoint_offset( def insert_checkpoint(conn: sqlite3.Connection, event_type: EventType, offset: int): query = f""" - INSERT INTO checkpoint ( - event_type, - offset - ) VALUES (?, ?) +INSERT INTO checkpoint ( + event_type, + offset +) VALUES (?, ?) """ cur = conn.cursor() cur.execute(query, [event_type.value, offset]) @@ -132,11 +164,11 @@ def insert_address_metadata( ) -> None: cur = conn.cursor() query = f""" - INSERT INTO nfts ( - address, - name, - symbol - ) VALUES (?, ?, ?) +INSERT INTO nfts ( + address, + name, + symbol +) VALUES (?, ?, ?) """ try: nfts = [ @@ -179,3 +211,73 @@ def insert_events(conn: sqlite3.Connection, events: List[NFTEvent]) -> None: 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 source_cur: + if event_type == EventType.ERC721: + batch.append(NFTMetadata(*cast(Tuple[str, str, str], row))) + else: + batch.append( + NFTEvent( + *cast( + Tuple[ + str, + EventType, + str, + str, + str, + str, + str, + Optional[int], + Optional[int], + Optional[int], + ], + row, + ) + ) + ) + + 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)) From f8fb803fd4e5208835fead57b6ad948dcc9351c2 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Sat, 2 Oct 2021 12:22:24 -0700 Subject: [PATCH 24/87] Handle checkpoints correctly when importing data Also added "nfts" command as a console script in setup.py --- datasets/nfts/nfts/datastore.py | 81 +++++++++++++++++++++++++-------- datasets/nfts/setup.py | 6 ++- 2 files changed, 66 insertions(+), 21 deletions(-) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index acbf9658..066090f4 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -4,7 +4,9 @@ a datastore for a Moonstream NFTs dataset. """ import logging import sqlite3 -from typing import Any, cast, List, Tuple, Optional, Union +from typing import Any, cast, List, Tuple, Optional + +from tqdm import tqdm from .data import EventType, NFTEvent, NFTMetadata @@ -147,6 +149,19 @@ def get_checkpoint_offset( 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 ( @@ -247,29 +262,47 @@ def import_data( batch: List[Any] = [] - for row in source_cur: + for row in tqdm(source_cur, desc="Rows processed"): if event_type == EventType.ERC721: batch.append(NFTMetadata(*cast(Tuple[str, str, str], row))) else: - batch.append( - NFTEvent( - *cast( - Tuple[ - str, - EventType, - str, - str, - str, - str, - str, - Optional[int], - Optional[int], - Optional[int], - ], - row, - ) - ) + ( + event_id, + nft_address, + token_id, + from_address, + to_address, + transaction_hash, + value, + block_number, + timestamp, + ) = cast( + Tuple[ + str, + str, + str, + str, + str, + str, + Optional[int], + Optional[int], + Optional[int], + ], + row, ) + event = NFTEvent( + event_id, + event_type, # Original argument to this function + nft_address, + token_id, + from_address, + to_address, + transaction_hash, + value, + block_number, + timestamp, + ) + batch.append(event) if len(batch) == batch_size: if event_type == EventType.ERC721: @@ -281,3 +314,11 @@ def import_data( 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) diff --git a/datasets/nfts/setup.py b/datasets/nfts/setup.py index 23c5542a..d0b5a435 100644 --- a/datasets/nfts/setup.py +++ b/datasets/nfts/setup.py @@ -41,5 +41,9 @@ setup( "dev": ["black", "mypy", "types-requests"], "distribute": ["setuptools", "twine", "wheel"], }, - entry_points={"console_scripts": []}, + entry_points={ + "console_scripts": [ + "nfts=nfts.cli:main", + ] + }, ) From 3e4acd4d5c00ae216721c5493c1ae7aa3e77a990 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Mon, 4 Oct 2021 16:49:35 +0300 Subject: [PATCH 25/87] Add distribution values request. --- datasets/nfts/nfts/cli.py | 25 +++++++++++++++++++++++-- datasets/nfts/nfts/derive.py | 23 +++++++++++++++++++++++ 2 files changed, 46 insertions(+), 2 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 32a2d61c..f8fc0b14 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -10,7 +10,7 @@ from web3 import Web3, IPCProvider, HTTPProvider from .data import event_types, nft_event, BlockBounds from .datastore import setup_database -from .derive import current_owners +from .derive import current_owners, current_values_distribution from .materialize import create_dataset, EthereumBatchloader @@ -18,6 +18,12 @@ logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) +derive_functions = { + "current_owners": current_owners, + "current_values_distribution": current_values_distribution, +} + + def handle_initdb(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.datastore)) as conn: setup_database(conn) @@ -51,7 +57,15 @@ def handle_materialize(args: argparse.Namespace) -> None: def handle_derive(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: - results = current_owners(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!") @@ -130,6 +144,13 @@ def main() -> None: 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) args = parser.parse_args() diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index dc13c7c4..ee0632d7 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -57,3 +57,26 @@ def current_owners(conn: sqlite3.Connection) -> List[Tuple]: conn.rollback() logger.error("Could not create derived dataset: current_owners") logger.error(e) + + +def current_values_distribution(conn: sqlite3.Connection) -> List[Tuple]: + """ + Requires a connection to a dataset in which the raw data (esp. transfers) 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 nft_address as address, market_value as value, CUME_DIST() over (PARTITION BY nft_address ORDER BY market_value) as cumulate_value from current_market_values;""" + 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_owners") + logger.error(e) From 6794cbf74b92bca4f9e51c3b71fbced782fc70e9 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Mon, 4 Oct 2021 08:26:33 -0700 Subject: [PATCH 26/87] Fixed import data column order This was a nasty bug. --- datasets/nfts/nfts/cli.py | 5 +-- datasets/nfts/nfts/datastore.py | 25 ++++++++------- datasets/nfts/nfts/derive.py | 57 +++++++++++++++++++++++++++++++-- 3 files changed, 71 insertions(+), 16 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index fbb58590..b20d44f0 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -9,7 +9,7 @@ from moonstreamdb.db import yield_db_session_ctx from .data import event_types, nft_event, BlockBounds from .datastore import setup_database, import_data -from .derive import current_owners +from .derive import current_owners, current_market_values from .materialize import create_dataset, EthereumBatchloader @@ -58,7 +58,8 @@ def handle_materialize(args: argparse.Namespace) -> None: def handle_derive(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: - results = current_owners(moonstream_datastore) + current_owners(moonstream_datastore) + current_market_values(moonstream_datastore) logger.info("Done!") diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index 066090f4..a9896294 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -70,12 +70,12 @@ def select_events_table_query(event_type: EventType) -> str: SELECT event_id, transaction_hash, - block_number, nft_address, token_id, from_address, to_address, transaction_value, + block_number, timestamp FROM {event_tables[event_type]}; """ @@ -266,13 +266,14 @@ def import_data( 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, - transaction_hash, value, block_number, timestamp, @@ -291,16 +292,16 @@ def import_data( row, ) event = NFTEvent( - event_id, - event_type, # Original argument to this function - nft_address, - token_id, - from_address, - to_address, - transaction_hash, - value, - block_number, - timestamp, + 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) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index dc13c7c4..53f50637 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -30,14 +30,33 @@ class LastValue: 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 + + 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) -def current_owners(conn: sqlite3.Connection) -> List[Tuple]: +def current_owners(conn: sqlite3.Connection) -> None: """ Requires a connection to a dataset in which the raw data (esp. transfers) has already been loaded. @@ -46,7 +65,12 @@ def current_owners(conn: sqlite3.Connection) -> List[Tuple]: drop_existing_current_owners_query = "DROP TABLE IF EXISTS current_owners;" current_owners_query = """ CREATE TABLE current_owners AS - SELECT nft_address, token_id, CAST(last_value(to_address) AS TEXT) AS owner FROM transfers + 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: @@ -57,3 +81,32 @@ def current_owners(conn: sqlite3.Connection) -> List[Tuple]: 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") + logger.error(e) From c543ab92f50e7bf55e71733464eadbcf49106cd0 Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Mon, 4 Oct 2021 19:24:11 +0300 Subject: [PATCH 27/87] added enrich command --- datasets/nfts/nfts/cli.py | 52 +++++++++++- datasets/nfts/nfts/datastore.py | 110 +++++++++++++++++++++++++ datasets/nfts/nfts/materialize.py | 128 ------------------------------ 3 files changed, 159 insertions(+), 131 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index fbb58590..a5d28efc 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -7,10 +7,11 @@ from typing import Optional from moonstreamdb.db import yield_db_session_ctx -from .data import event_types, nft_event, BlockBounds +from .data import EventType, event_types, nft_event, BlockBounds from .datastore import setup_database, import_data from .derive import current_owners -from .materialize import create_dataset, EthereumBatchloader +from .enrich import EthereumBatchloader, enrich +from .materialize import create_dataset logging.basicConfig(level=logging.INFO) @@ -50,12 +51,33 @@ def handle_materialize(args: argparse.Namespace) -> None: moonstream_datastore, db_session, event_type, - batch_loader, 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: results = current_owners(moonstream_datastore) @@ -166,6 +188,30 @@ def main() -> None: ) parser_import_data.set_defaults(func=handle_import_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) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index 066090f4..47929ec3 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -83,6 +83,116 @@ 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. diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index e4f60561..3b199208 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -1,4 +1,3 @@ -from dataclasses import is_dataclass import logging import sqlite3 from typing import Any, cast, Iterator, List, Optional, Set @@ -28,135 +27,10 @@ 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) - 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, - bounds: Optional[BlockBounds] = None, -) -> 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 is None - or nft_event.value is None - or nft_event.timestamp is 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)] - - def check_bounds(event: NFTEvent) -> bool: - if bounds is None: - return True - is_admissible = True - if event.block_number < bounds.starting_block: - is_admissible = False - if bounds.ending_block is not None and event.block_number > bounds.ending_block: - is_admissible = False - return is_admissible - - admissible_events = [event for event in nft_events if check_bounds(event)] - return admissible_events - - def add_events( datastore_conn: sqlite3.Connection, db_session: Session, event_type: EventType, - batch_loader: EthereumBatchloader, initial_offset=0, bounds: Optional[BlockBounds] = None, batch_size: int = 10, @@ -256,7 +130,6 @@ def create_dataset( datastore_conn: sqlite3.Connection, db_session: Session, event_type: EventType, - batch_loader: EthereumBatchloader, bounds: Optional[BlockBounds] = None, batch_size: int = 10, ) -> None: @@ -277,7 +150,6 @@ def create_dataset( datastore_conn, db_session, event_type, - batch_loader, offset, bounds, batch_size, From 6ed3bc3122c8a9576173aaef32476f6d5d091a0e Mon Sep 17 00:00:00 2001 From: yhtiyar Date: Tue, 5 Oct 2021 15:29:17 +0300 Subject: [PATCH 28/87] added enrich --- datasets/nfts/nfts/enrich.py | 161 +++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 datasets/nfts/nfts/enrich.py 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) From 45b84785e377297868e48209c5e89fd71681c53c Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Tue, 5 Oct 2021 19:33:53 +0300 Subject: [PATCH 29/87] Add ability copy sqlite3 database with aplling filter. --- datasets/nfts/nfts/cli.py | 96 +++++++++++++++++++++++++++------ datasets/nfts/nfts/datastore.py | 34 ++++++++++++ 2 files changed, 113 insertions(+), 17 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 71d6dc5d..9e137cee 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -3,13 +3,14 @@ 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 +from .datastore import setup_database, import_data, filter_data from .derive import current_owners, current_market_values, current_values_distribution from .materialize import create_dataset @@ -38,6 +39,54 @@ def handle_import_data(args: argparse.Namespace) -> None: import_data(target_conn, source_conn, event_type, args.batch_size) +def handel_generate_filtered(args: argparse.Namespace) -> None: + + with contextlib.closing(sqlite3.connect(args.source)) as source_conn: + + if not args.target: + # generate name if not set + path_list = args.source.split("/") + file = path_list.pop() + old_prefix, ext = file.split(".") + new_prefix = old_prefix + if args.start_time: + new_prefix += f"-{args.start_time}" + if args.end_time: + new_prefix += f"-{args.end_time}" + if args.type: + new_prefix += f"-{args.type}" + + name = f"{new_prefix}.{ext}" + + else: + name = f"{args.target}" + + if name == args.source: + name = f"{name}.dump" + path_list.append(name) + print(f"Creating new database:{name}") + new_db_path = "/".join(path_list) + copyfile(args.source, new_db_path) + + # with io.open(name, "w") as f: + # for linha in source_conn.iterdump(): + # f.write("%s\n" % linha) + os + + # do connection + with contextlib.closing(sqlite3.connect(new_db_path)) as source_conn: + print("Start filtering") + filter_data(source_conn, args) + 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 @@ -55,11 +104,7 @@ def handle_materialize(args: argparse.Namespace) -> None: sqlite3.connect(args.datastore) ) as moonstream_datastore: create_dataset( - moonstream_datastore, - db_session, - event_type, - bounds, - args.batch_size, + moonstream_datastore, db_session, event_type, bounds, args.batch_size, ) @@ -71,17 +116,11 @@ def handle_enrich(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: enrich( - moonstream_datastore, - EventType.TRANSFER, - batch_loader, - args.batch_size, + moonstream_datastore, EventType.TRANSFER, batch_loader, args.batch_size, ) enrich( - moonstream_datastore, - EventType.MINT, - batch_loader, - args.batch_size, + moonstream_datastore, EventType.MINT, batch_loader, args.batch_size, ) @@ -188,9 +227,7 @@ def main() -> None: 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", + "--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" @@ -210,6 +247,31 @@ def main() -> None: ) parser_import_data.set_defaults(func=handle_import_data) + # crete dump for apply filters + + parser_filtered_copy = subcommands.add_parser( + "copy", description="Create copy of database with applied filters.", + ) + parser_filtered_copy.add_argument( + "--target", 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( + "--type", + choices=event_types, + help="Type of data you would like to import from source to target", + ) + 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=handel_generate_filtered) + parser_enrich = subcommands.add_parser( "enrich", description="enrich dataset from geth node" ) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index 0c59537d..e649bf91 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -433,3 +433,37 @@ def import_data( 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, cli_args): + """ + Run Deletes query depends on filters + """ + + cur = sqlite_db.cursor() + print(f"Remove by timestamp < {cli_args.start_time}") + if cli_args.start_time: + cur.execute(f"DELETE from transfers where timestamp < {cli_args.start_time}") + print(f"filtered out: {cur.rowcount}") + sqlite_db.commit() + cur.execute(f"DELETE from mints where timestamp < {cli_args.start_time}") + print(f"filtered out: {cur.rowcount}") + sqlite_db.commit() + + print(f"Remove by timestamp > {cli_args.end_time}") + if cli_args.end_time: + cur.execute(f"DELETE from transfers where timestamp > {cli_args.end_time}") + print(f"filtered out: {cur.rowcount}") + sqlite_db.commit() + cur.execute(f"DELETE from mints where timestamp > {cli_args.end_time}") + print(f"filtered out: {cur.rowcount}") + sqlite_db.commit() + + # print(f"Remove by type != '{cli_args.type}") + # if cli_args.type: + # cur.execute(f"DELETE from transfers where type != '{cli_args.type}'") + # print(f"filtered out: {cur.rowcount}") + # sqlite_db.commit() + # cur.execute(f"DELETE from mints where type != '{cli_args.type}'") + # print(f"filtered out: {cur.rowcount}") + # sqlite_db.commit() From b635412a3deb4f8b5119909c68df1a74b2b634a2 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Tue, 5 Oct 2021 19:36:14 +0300 Subject: [PATCH 30/87] Remove comments. --- datasets/nfts/nfts/cli.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 9e137cee..e11c60b1 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -68,11 +68,6 @@ def handel_generate_filtered(args: argparse.Namespace) -> None: new_db_path = "/".join(path_list) copyfile(args.source, new_db_path) - # with io.open(name, "w") as f: - # for linha in source_conn.iterdump(): - # f.write("%s\n" % linha) - os - # do connection with contextlib.closing(sqlite3.connect(new_db_path)) as source_conn: print("Start filtering") From 1b69699fde1fa4a2f7a0e5d24294ee3ea423efb7 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Tue, 5 Oct 2021 19:37:28 +0300 Subject: [PATCH 31/87] Add simpler solution for distribution. --- datasets/nfts/nfts/derive.py | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 0eb46cde..5e06989e 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -120,8 +120,23 @@ def current_values_distribution(conn: sqlite3.Connection) -> List[Tuple]: "DROP TABLE IF EXISTS market_values_distribution;" ) current_values_distribution_query = """ - CREATE TABLE market_values_distribution AS - select nft_address as address, market_value as value, CUME_DIST() over (PARTITION BY nft_address ORDER BY market_value) as cumulate_value from current_market_values;""" + CREATE TABLE market_values_distribution AS + select + 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 + 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) From 9605f4ef52def7068974e7eba056e7956fb971e6 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Tue, 5 Oct 2021 19:49:30 +0300 Subject: [PATCH 32/87] Add transfer_statistics_by_address. --- datasets/nfts/nfts/cli.py | 1 + datasets/nfts/nfts/derive.py | 44 ++++++++++++++++++++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index e11c60b1..d3833d46 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -23,6 +23,7 @@ derive_functions = { "current_owners": current_owners, "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, + "transfer_statistics_by_address": transfer_statistics_by_address, } diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 5e06989e..b2ce8983 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -146,3 +146,47 @@ def current_values_distribution(conn: sqlite3.Connection) -> List[Tuple]: 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: current_values_distribution") + logger.error(e) From c0b315ddaea4eb5ffa732e282e1ac9973c687a41 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Tue, 5 Oct 2021 11:33:00 -0700 Subject: [PATCH 33/87] --derive_functions -> --derive-functions --- datasets/nfts/nfts/cli.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 71d6dc5d..fa27e41a 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -176,7 +176,7 @@ def main() -> None: ) parser_derive.add_argument( "-f", - "--derive_functions", + "--derive-functions", required=False, nargs="+", help=f"Functions wich will call from derive module availabel {list(derive_functions.keys())}", From b7b0f2201b858c59fccc9a6d536bb7c619f6c2e6 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 6 Oct 2021 18:12:57 +0200 Subject: [PATCH 34/87] added nft analysis notebook --- datasets/notepads/NFT_Analysis_charts.ipynb | 601 ++++++++++++++++++++ 1 file changed, 601 insertions(+) create mode 100644 datasets/notepads/NFT_Analysis_charts.ipynb diff --git a/datasets/notepads/NFT_Analysis_charts.ipynb b/datasets/notepads/NFT_Analysis_charts.ipynb new file mode 100644 index 00000000..756f50a4 --- /dev/null +++ b/datasets/notepads/NFT_Analysis_charts.ipynb @@ -0,0 +1,601 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import sqlite3\n", + "import numpy as np\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": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "conTXs = sqlite3.connect('./nfts-002.sqlite')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = pd.read_sql_query(\"SELECT * FROM checkpoint\", conTXs)\n", + "mints = pd.read_sql_query(\"SELECT * FROM mints\", conTXs)\n", + "nfts = pd.read_sql_query(\"SELECT * FROM nfts\", conTXs)\n", + "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sql\n", + "0 CREATE TABLE nfts\\n (\\n address TEXT...\n", + "1 CREATE TABLE checkpoint\\n (\\n event_...\n", + "2 CREATE TABLE mints\\n (\\n event_id TE...\n", + "3 CREATE TABLE transfers\\n (\\n event_i...\n", + "4 CREATE TABLE current_owners(\\n nft_address TE...\n", + "5 CREATE TABLE current_market_values(\\n nft_add...\n" + ] + } + ], + "source": [ + "stolbiki = pd.read_sql_query(\"SELECT sql FROM sqlite_master where type='table'\", conTXs) \n", + "print(stolbiki)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# checkpoint.head(40)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + "
event_idtransaction_hashblock_numbernft_addresstoken_idfrom_addressto_addresstransaction_valuetimestamp
0ce7b6ba0-218f-40c7-8d8c-4e3bfc822a410x804cee46e672b17b477658b99c25c8b75f31553278ad...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62057287012905433418913509099434869470284131894829...0x79A8b5Fcc051c843DFCB753eE38d113675E5367D0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f01609460206
1c81d8767-a523-410e-9f4a-21a25f8e906f0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62051225542446027558019364995253890488984869511709...0x2c338BAf69A57A17E69dB86933310e92f64ab69d0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f01609460206
2d9494633-61fd-4cd6-bd42-e736e09829560x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e...115650440x6Fa769EED284a94A73C15299e1D3719B29Ae2F52510600260x9503DE24f4210dA79c5e5BCCD198B2727387a5190x8B36486EA2E0b70A505D92d30c31CC3197ba570701609459570
3801c3aae-9b72-4a4b-b40b-1cf93308eeea0xe74d08ee2cbe4b6b873258462ec5523999433569df66...115650420xB2D6fb1Dc231F97F8cC89467B52F7C4F784840444265098311422702060752376543910232329671779809...0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e60x000000000000000000000000000000000000000001609459545
\n", + "
" + ], + "text/plain": [ + " event_id \\\n", + "0 ce7b6ba0-218f-40c7-8d8c-4e3bfc822a41 \n", + "1 c81d8767-a523-410e-9f4a-21a25f8e906f \n", + "2 d9494633-61fd-4cd6-bd42-e736e0982956 \n", + "3 801c3aae-9b72-4a4b-b40b-1cf93308eeea \n", + "\n", + " transaction_hash block_number \\\n", + "0 0x804cee46e672b17b477658b99c25c8b75f31553278ad... 11565099 \n", + "1 0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46... 11565099 \n", + "2 0x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e... 11565044 \n", + "3 0xe74d08ee2cbe4b6b873258462ec5523999433569df66... 11565042 \n", + "\n", + " nft_address \\\n", + "0 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "1 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "2 0x6Fa769EED284a94A73C15299e1D3719B29Ae2F52 \n", + "3 0xB2D6fb1Dc231F97F8cC89467B52F7C4F78484044 \n", + "\n", + " token_id \\\n", + "0 7287012905433418913509099434869470284131894829... \n", + "1 1225542446027558019364995253890488984869511709... \n", + "2 51060026 \n", + "3 4265098311422702060752376543910232329671779809... \n", + "\n", + " from_address \\\n", + "0 0x79A8b5Fcc051c843DFCB753eE38d113675E5367D \n", + "1 0x2c338BAf69A57A17E69dB86933310e92f64ab69d \n", + "2 0x9503DE24f4210dA79c5e5BCCD198B2727387a519 \n", + "3 0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e6 \n", + "\n", + " to_address transaction_value timestamp \n", + "0 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0 1609460206 \n", + "1 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0 1609460206 \n", + "2 0x8B36486EA2E0b70A505D92d30c31CC3197ba5707 0 1609459570 \n", + "3 0x0000000000000000000000000000000000000000 0 1609459545 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transfers.head(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# transfers[transfers[\"transaction_value\"].isnull()]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# transfers[\"transaction_value\"].head(16)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", + "\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": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'NFT transfers value over time')" + ] + }, + "execution_count": 10, + "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": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of unique addresses: 6749\n" + ] + } + ], + "source": [ + "print(\"number of unique addresses:\", transfers[\"nft_address\"].nunique())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# num_df = (transfers[[\"nft_address\", \"transaction_value\", \"timestamp\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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", + "ax = sns.displot(from_series, stat=\"count\", bins=200, log_scale=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#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()\n", + "#summ all same number of transactions over all addresses\n", + "# num_df = num_df.value_counts(normalize=False, sort=True)\n", + "# to_series = num_df.rename(\"Number of Transactions to an address\")\n", + "ax = sns.displot(to_series, stat=\"probability\", bins=12, log_scale=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_address\n", + "0x0000000000000000000000000000000000000000 118598\n", + "0x0000000000000000000000000000000000000001 7304\n", + "0x0000000000000000000000000000000000000069 1\n", + "0x00000000000000000000000000000000000000ff 1\n", + "0x0000000000000000000000000000000000001388 1\n", + " ... \n", + "0xfff98e0Af7Dfa591f97a768dcd71C39fA6CC7C16 2\n", + "0xfffAAD6BA8F5Cb255111EE0bB8E06e2766cb8e49 86\n", + "0xfffFa8f60d2eC6a559ef3617576ED28Bc397D360 4\n", + "0xfffaA912b2740381eB753A03E9c13c661CeFC0ed 36\n", + "0xffff0C5C628171f26B06322Db50dA0A6D1C8DD5a 3\n", + "Name: to_address, Length: 420342, dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "to_series" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "278519" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from_series.size" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "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')\n", + "# df = df.fillna(0.00001)\n", + "# from_series.to_frame().join(to_series)\n", + "df=df[df[\"to_count\"]<10e3]\n", + "df=df[df[\"from_count\"]<10e3]" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.displot(df, stat=\"count\", bins=12, log_scale=True)#multiple='dodge'" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.displot(df, log_scale=True, kind=\"kde\")" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "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": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.histplot(df_small, multiple=\"dodge\")\n", + "ax.fill(True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "plt.bar(df.index,df.to_count,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n, bins, patches = plt.hist(df['to_count'], density=False, facecolor='g', alpha=0.75, log=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [], + "source": [ + "max_value = pd.to_numeric(transfers[\"transaction_value\"], errors='coerce')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "token_id\n", + "0 1.000000e+20\n", + "1 3.000000e+20\n", + "10 3.200000e+19\n", + "100 4.114000e+19\n", + "Name: transaction_value, dtype: float64" + ] + }, + "execution_count": 180, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max_value[\"token_id\"]=transfers[\"token_id\"]\n", + "max_value.groupby(transfers[\"token_id\"]).max()\n", + "max_value.head(4)" + ] + }, + { + "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 +} From 5bcf6c4bfc3ff84c871312b09da4c670cda3b984 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 6 Oct 2021 19:09:00 +0200 Subject: [PATCH 35/87] renamed notepads to notebooks and moved to /nfts --- datasets/{notepads => nfts/notebooks}/NFT_Analysis_charts.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename datasets/{notepads => nfts/notebooks}/NFT_Analysis_charts.ipynb (100%) diff --git a/datasets/notepads/NFT_Analysis_charts.ipynb b/datasets/nfts/notebooks/NFT_Analysis_charts.ipynb similarity index 100% rename from datasets/notepads/NFT_Analysis_charts.ipynb rename to datasets/nfts/notebooks/NFT_Analysis_charts.ipynb From 5ffa9c4f2771b6fad78a00b0f6da09a7b2f7cad2 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Wed, 6 Oct 2021 22:36:44 +0300 Subject: [PATCH 36/87] Add table: Values distributions Transfers days holding First transfers after mints days distributions. Add fixes. Remove type filter now is unrequired. --- datasets/nfts/nfts/cli.py | 61 +++++----- datasets/nfts/nfts/datastore.py | 39 +++---- datasets/nfts/nfts/derive.py | 178 +++++++++++++++++++++++++++++- datasets/nfts/nfts/materialize.py | 11 +- 4 files changed, 222 insertions(+), 67 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index d3833d46..728a980a 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -11,7 +11,13 @@ 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 +from .derive import ( + current_owners, + current_market_values, + current_values_distribution, + transfer_statistics_by_address, + qurtile_generating, +) from .materialize import create_dataset @@ -24,6 +30,7 @@ derive_functions = { "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, "transfer_statistics_by_address": transfer_statistics_by_address, + "qurtile_generating": qurtile_generating, } @@ -40,39 +47,28 @@ def handle_import_data(args: argparse.Namespace) -> None: import_data(target_conn, source_conn, event_type, args.batch_size) -def handel_generate_filtered(args: argparse.Namespace) -> None: +def handle_filter_data(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.source)) as source_conn: - if not args.target: - # generate name if not set - path_list = args.source.split("/") - file = path_list.pop() - old_prefix, ext = file.split(".") - new_prefix = old_prefix - if args.start_time: - new_prefix += f"-{args.start_time}" - if args.end_time: - new_prefix += f"-{args.end_time}" - if args.type: - new_prefix += f"-{args.type}" - - name = f"{new_prefix}.{ext}" - + if args.target == args.source: + sqlite_path = f"{args.target}.dump" else: - name = f"{args.target}" + sqlite_path = args.target - if name == args.source: - name = f"{name}.dump" - path_list.append(name) - print(f"Creating new database:{name}") - new_db_path = "/".join(path_list) - copyfile(args.source, new_db_path) + print(f"Creating new database:{sqlite_path}") + + copyfile(args.source, sqlite_path) # do connection - with contextlib.closing(sqlite3.connect(new_db_path)) as source_conn: + with contextlib.closing(sqlite3.connect(sqlite_path)) as source_conn: print("Start filtering") - filter_data(source_conn, args) + filter_data( + source_conn, + start_time=args.start_time, + end_time=args.end_time, + type=args.type, + ) print("Filtering end.") for index, function_name in enumerate(derive_functions.keys()): print( @@ -243,22 +239,17 @@ def main() -> None: ) parser_import_data.set_defaults(func=handle_import_data) - # crete dump for apply filters + # Create dump of filtered data parser_filtered_copy = subcommands.add_parser( - "copy", description="Create copy of database with applied filters.", + "filter-data", description="Create copy of database with applied filters.", ) parser_filtered_copy.add_argument( - "--target", help="Datastore into which you want to import data", + "--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( - "--type", - choices=event_types, - help="Type of data you would like to import from source to target", - ) parser_filtered_copy.add_argument( "--start-time", required=False, type=int, help="Start timestamp.", ) @@ -266,7 +257,7 @@ def main() -> None: "--end-time", required=False, type=int, help="End timestamp.", ) - parser_filtered_copy.set_defaults(func=handel_generate_filtered) + parser_filtered_copy.set_defaults(func=handle_filter_data) parser_enrich = subcommands.add_parser( "enrich", description="enrich dataset from geth node" diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index e649bf91..e78ce9ae 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -435,35 +435,30 @@ def import_data( insert_checkpoint(target_conn, event_type, source_offset) -def filter_data(sqlite_db: sqlite3.Connection, cli_args): +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 < {cli_args.start_time}") - if cli_args.start_time: - cur.execute(f"DELETE from transfers where timestamp < {cli_args.start_time}") - print(f"filtered out: {cur.rowcount}") + 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 < {cli_args.start_time}") - print(f"filtered out: {cur.rowcount}") + 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 > {cli_args.end_time}") - if cli_args.end_time: - cur.execute(f"DELETE from transfers where timestamp > {cli_args.end_time}") - print(f"filtered out: {cur.rowcount}") + 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 > {cli_args.end_time}") - print(f"filtered out: {cur.rowcount}") + cur.execute(f"DELETE from mints where timestamp >= {end_time}") + print(f"Mints filtered out: {cur.rowcount}") sqlite_db.commit() - - # print(f"Remove by type != '{cli_args.type}") - # if cli_args.type: - # cur.execute(f"DELETE from transfers where type != '{cli_args.type}'") - # print(f"filtered out: {cur.rowcount}") - # sqlite_db.commit() - # cur.execute(f"DELETE from mints where type != '{cli_args.type}'") - # print(f"filtered out: {cur.rowcount}") - # sqlite_db.commit() diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index b2ce8983..e36e52d6 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -48,12 +48,38 @@ class LastNonzeroValue: return self.value +class QuartileFunction: + """ Split vlues to quartiles """ + + def __init__(self, num_qurtiles) -> None: + self.divider = 1 / num_qurtiles + + def __call__(self, value): + if value is None or value == "None": + value = 0 + quartile = self.divider + try: + while value > quartile: + quartile += self.divider + + if quartile > 1: + qurtile = 1 + + return qurtile + + 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("quartile_10", 1, QuartileFunction(10)) + conn.create_function("quartile_25", 1, QuartileFunction(25)) def current_owners(conn: sqlite3.Connection) -> None: @@ -111,7 +137,7 @@ def current_market_values(conn: sqlite3.Connection) -> None: logger.error("Could not create derived dataset: current_market_values") -def current_values_distribution(conn: sqlite3.Connection) -> List[Tuple]: +def current_values_distribution(conn: sqlite3.Connection) -> None: """ Requires a connection to a dataset in which current_market_values has already been loaded. """ @@ -190,3 +216,153 @@ def transfer_statistics_by_address(conn: sqlite3.Connection) -> None: conn.rollback() logger.error("Could not create derived dataset: current_values_distribution") logger.error(e) + + +def qurtile_generating(conn: sqlite3.Connection): + """ + Create qurtile wich depends on setted on class defenition + """ + ensure_custom_aggregate_functions(conn) + drop_calculate_qurtiles = ( + "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" + ) + calculate_qurtiles = """ + CREATE TABLE transfer_values_quartile_10_distribution_per_address AS + select qurtiled_sum.address as address, + SUM(qurtiled_sum.sum_of_qurtile) over (PARTITION BY qurtiled_sum.address order by qurtiled_sum.qurtiles ) as cululative_total, + qurtiled_sum.qurtiles as qurtiles + from ( + select + qurtiled.address, + count(qurtiled.relative_value)/count_value.count_value as sum_of_qurtile, + qurtiled.qurtiles as qurtiles + from + ( + select + cumulate.address as address, + quartile_10(cumulate.relative_value) as qurtiles, + 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 + ) as qurtiled + inner join ( + select + current_market_values.nft_address, + count(market_value) as count_value + from + current_market_values + group by + current_market_values.nft_address + ) as count_value on qurtiled.address = count_value.nft_address + ) as qurtiled_sum; + + """ + cur = conn.cursor() + try: + cur.execute(drop_calculate_qurtiles) + cur.execute(calculate_qurtiles) + conn.commit() + except Exception as e: + conn.rollback() + logger.error("Could not create derived dataset: current_values_distribution") + 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 + nft_address, + token_id, + min(timestamp) as firts_transfer + from + transfers + group by + nft_address, + token_id + ) as firsts_transfers on firsts_transfers.nft_address = mints.nft_address + and firsts_transfers.token_id = mints.token_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: current_values_distribution") + 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: current_values_distribution") + logger.error(e) diff --git a/datasets/nfts/nfts/materialize.py b/datasets/nfts/nfts/materialize.py index 3b199208..bad00102 100644 --- a/datasets/nfts/nfts/materialize.py +++ b/datasets/nfts/nfts/materialize.py @@ -66,9 +66,7 @@ def add_events( EthereumBlock, EthereumTransaction.block_number == EthereumBlock.block_number, ) - .order_by( - EthereumLabel.created_at.asc(), - ) + .order_by(EthereumLabel.created_at.asc(),) ) if bounds is not None: time_filters = [EthereumTransaction.block_number >= bounds.starting_block] @@ -147,12 +145,7 @@ def create_dataset( add_contracts_metadata(datastore_conn, db_session, offset, batch_size) else: add_events( - datastore_conn, - db_session, - event_type, - offset, - bounds, - batch_size, + datastore_conn, db_session, event_type, offset, bounds, batch_size, ) From 6a7e1af732ac9b70e849c60c8975329d5f18a9bb Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Wed, 6 Oct 2021 22:41:21 +0300 Subject: [PATCH 37/87] Commented qurtile distribution. --- datasets/nfts/nfts/cli.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 728a980a..33eff308 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -30,7 +30,9 @@ derive_functions = { "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, "transfer_statistics_by_address": transfer_statistics_by_address, - "qurtile_generating": qurtile_generating, + # "qurtile_generating": qurtile_generating, + "mint_holding_times": mint_holding_times, + "transfer_holding_times": transfer_holding_times, } From 813e000fc1dda7abf56a9889fdc4e157f5201ceb Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Wed, 6 Oct 2021 22:42:15 +0300 Subject: [PATCH 38/87] Add imports. --- datasets/nfts/nfts/cli.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 33eff308..c9b9af9d 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -17,6 +17,8 @@ from .derive import ( current_values_distribution, transfer_statistics_by_address, qurtile_generating, + mint_holding_times, + transfer_holding_times, ) from .materialize import create_dataset From 306e4c5ac6d5092b91f7383f9739c25074bb85fc Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Wed, 6 Oct 2021 22:44:35 +0300 Subject: [PATCH 39/87] Remove type. --- datasets/nfts/nfts/cli.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index c9b9af9d..d5757c02 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -68,10 +68,7 @@ def handle_filter_data(args: argparse.Namespace) -> None: 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, - type=args.type, + source_conn, start_time=args.start_time, end_time=args.end_time, ) print("Filtering end.") for index, function_name in enumerate(derive_functions.keys()): From 1b780626d9f9a7d90d1b88c7218fe468a92f9fec Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 15:06:21 +0200 Subject: [PATCH 40/87] updated with more exact charts and labels --- .../nfts/notebooks/NFT_Analysis_charts.ipynb | 601 ------------ datasets/nfts/notebooks/transfers_count.ipynb | 884 ++++++++++++++++++ 2 files changed, 884 insertions(+), 601 deletions(-) delete mode 100644 datasets/nfts/notebooks/NFT_Analysis_charts.ipynb create mode 100644 datasets/nfts/notebooks/transfers_count.ipynb diff --git a/datasets/nfts/notebooks/NFT_Analysis_charts.ipynb b/datasets/nfts/notebooks/NFT_Analysis_charts.ipynb deleted file mode 100644 index 756f50a4..00000000 --- a/datasets/nfts/notebooks/NFT_Analysis_charts.ipynb +++ /dev/null @@ -1,601 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 161, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import sqlite3\n", - "import numpy as np\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": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "conTXs = sqlite3.connect('./nfts-002.sqlite')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "checkpoint = pd.read_sql_query(\"SELECT * FROM checkpoint\", conTXs)\n", - "mints = pd.read_sql_query(\"SELECT * FROM mints\", conTXs)\n", - "nfts = pd.read_sql_query(\"SELECT * FROM nfts\", conTXs)\n", - "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " sql\n", - "0 CREATE TABLE nfts\\n (\\n address TEXT...\n", - "1 CREATE TABLE checkpoint\\n (\\n event_...\n", - "2 CREATE TABLE mints\\n (\\n event_id TE...\n", - "3 CREATE TABLE transfers\\n (\\n event_i...\n", - "4 CREATE TABLE current_owners(\\n nft_address TE...\n", - "5 CREATE TABLE current_market_values(\\n nft_add...\n" - ] - } - ], - "source": [ - "stolbiki = pd.read_sql_query(\"SELECT sql FROM sqlite_master where type='table'\", conTXs) \n", - "print(stolbiki)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# checkpoint.head(40)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "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", - "
event_idtransaction_hashblock_numbernft_addresstoken_idfrom_addressto_addresstransaction_valuetimestamp
0ce7b6ba0-218f-40c7-8d8c-4e3bfc822a410x804cee46e672b17b477658b99c25c8b75f31553278ad...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62057287012905433418913509099434869470284131894829...0x79A8b5Fcc051c843DFCB753eE38d113675E5367D0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f01609460206
1c81d8767-a523-410e-9f4a-21a25f8e906f0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62051225542446027558019364995253890488984869511709...0x2c338BAf69A57A17E69dB86933310e92f64ab69d0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f01609460206
2d9494633-61fd-4cd6-bd42-e736e09829560x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e...115650440x6Fa769EED284a94A73C15299e1D3719B29Ae2F52510600260x9503DE24f4210dA79c5e5BCCD198B2727387a5190x8B36486EA2E0b70A505D92d30c31CC3197ba570701609459570
3801c3aae-9b72-4a4b-b40b-1cf93308eeea0xe74d08ee2cbe4b6b873258462ec5523999433569df66...115650420xB2D6fb1Dc231F97F8cC89467B52F7C4F784840444265098311422702060752376543910232329671779809...0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e60x000000000000000000000000000000000000000001609459545
\n", - "
" - ], - "text/plain": [ - " event_id \\\n", - "0 ce7b6ba0-218f-40c7-8d8c-4e3bfc822a41 \n", - "1 c81d8767-a523-410e-9f4a-21a25f8e906f \n", - "2 d9494633-61fd-4cd6-bd42-e736e0982956 \n", - "3 801c3aae-9b72-4a4b-b40b-1cf93308eeea \n", - "\n", - " transaction_hash block_number \\\n", - "0 0x804cee46e672b17b477658b99c25c8b75f31553278ad... 11565099 \n", - "1 0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46... 11565099 \n", - "2 0x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e... 11565044 \n", - "3 0xe74d08ee2cbe4b6b873258462ec5523999433569df66... 11565042 \n", - "\n", - " nft_address \\\n", - "0 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", - "1 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", - "2 0x6Fa769EED284a94A73C15299e1D3719B29Ae2F52 \n", - "3 0xB2D6fb1Dc231F97F8cC89467B52F7C4F78484044 \n", - "\n", - " token_id \\\n", - "0 7287012905433418913509099434869470284131894829... \n", - "1 1225542446027558019364995253890488984869511709... \n", - "2 51060026 \n", - "3 4265098311422702060752376543910232329671779809... \n", - "\n", - " from_address \\\n", - "0 0x79A8b5Fcc051c843DFCB753eE38d113675E5367D \n", - "1 0x2c338BAf69A57A17E69dB86933310e92f64ab69d \n", - "2 0x9503DE24f4210dA79c5e5BCCD198B2727387a519 \n", - "3 0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e6 \n", - "\n", - " to_address transaction_value timestamp \n", - "0 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0 1609460206 \n", - "1 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0 1609460206 \n", - "2 0x8B36486EA2E0b70A505D92d30c31CC3197ba5707 0 1609459570 \n", - "3 0x0000000000000000000000000000000000000000 0 1609459545 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "transfers.head(4)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# transfers[transfers[\"transaction_value\"].isnull()]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# transfers[\"transaction_value\"].head(16)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", - "\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": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'NFT transfers value over time')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsoAAAGECAYAAAAvLAbBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABsg0lEQVR4nO3dd3hUZdoG8Ht6ySQhgRR670gRUBEVESnS61oQe1u7q35YWGVx3cW21rWsbS34+eGK2FgLWKkCIkivgQBppE2S6Wfe748zczKTTPqcmQHu33V5kUySOe+cKN558rzPqxFCCBARERERURhtvBdARERERJSIGJSJiIiIiCJgUCYiIiIiioBBmYiIiIgoAgZlIiIiIqIIGJSJiIiIiCJgUCaihHL06FH07t0bH330Udjjb775Jh544AEAwLJlyzB06FBMmzYt7J9Vq1bhzjvvVN7v3bs3pkyZgmnTpmHevHm1rvXSSy9h5cqVqr8mSZLwxz/+EePHj8f777+v+vUasmHDBkyePDney2iW0O/Z888/j+XLl8d3QUR0StPHewFERDVptVo88cQTGDZsGLp27Rrxc4YNG4bXXnut1uNjxoxR3u7duzfeeecdpKenR3yODRs2oEePHtFZdD0KCgqwevVq/Pbbb9DpdKpf71QW+j2766674rwaIjrVMSgTUcIxm8249tprce+99+LDDz+E0WiM+jWWLFmC7du348knn4ROp8OqVatQVlaG3NxcXHjhhZg9ezYWLVoEh8OBwsJC9OnTB8899xxMJhPOOOMM3HTTTVizZg0KCwtx1VVX4ZprrkFRURHmz5+P0tJSAMCoUaNwww034IYbboDP58PMmTPx4osvwuv14vHHH0dZWRkkScK8efMwe/ZsbNiwAY8//jisViscDgeWLFmChx9+GIcPH4ZWq0X//v2xaNEiaLXVvwxcvXo1nnjiCXz++ecAALvdjjFjxmDlypX49ddf8dprr8Hj8aCkpATTp0/H3XffHXYfHnjgAfTs2RPXX399rfcLCgqwaNEi5OXlwev1YtKkSbjllltq3cv8/HwsXLgQx44dgxAC06dPxw033IB//OMfqKysxCOPPAIA+Omnn/Diiy/io48+wq+//oqnn34aTqcTGo0Gd9xxB0aPHo1ly5bhP//5D5xOJ2w2G9577716v2fBtZ5xxhm45ppr8MMPP6CyshL3338/vvrqK+zduxeZmZl49dVXYbVaceDAgYj3nogoIpHAKioqxKRJk0Rubm69n/ftt9+KqVOniilTpog//vGPoqysTAghxKZNm8TMmTPF1KlTxVVXXSWOHj0ai2UTUQvk5uaKwYMHC0mSxBVXXCEWL14shBDijTfeEPPnzxdCCPHxxx+LM888U0ydOlX5589//nOt5+rVq5coLi6u81pXXnml+O9//yuEEGL+/Pni6quvVj62ePFisXz5ciGEEB6PR0yePFl89dVXyvO+9957Qgghfv/9dzFgwADhcrnESy+9pKyjqqpK3H333cJutyuvSQghvF6vmDhxoti+fbsQQgi73S4uueQSsWXLFrF+/XrRp08f5e+qTz75RFx33XVCCCF8Pp94+OGHRU5OTthr8Pv9YvTo0WLbtm1CCCGWLFki7r33XuH3+8WVV14pDh06JIQQIj8/X/Tt21cUFxeL9evXi0mTJimv+4033lCeL/T9efPmiVWrVgkhhHC5XGLevHniyy+/rHUf586dK9566y3l9UyZMkV88cUX4siRI+Lss88WbrdbCCHEXXfdJZYuXSrKysrEuHHjlL/b8/PzxQUXXCCOHTsmPv74YzF8+HBRUVHRqO9ZcK29evUS77zzjhBCiNdee00MGTJE5OfnC0mSxIwZM8Rnn31W770nIookYSvKW7duxYIFC5CTk1Pv51VWVmLhwoX4+OOPkZWVheeffx4vvvgiFixYgPvvvx8vv/wy+vTpg//85z/461//ildeeSU2L4CIWkSr1eKpp57CjBkzcN5559X6eF2tFy0xdOhQ5e37778fa9asweuvv46cnBwUFhbC4XAoHw+2ePTv3x8ejwcOhwPnn38+brrpJuTl5eHcc8/Fvffei+TkZJSXlytfl5OTgyNHjuChhx5SHnO5XNi5cye6d++Otm3bon379sp6nn32WcybNw/nnnsurr76anTu3DlszRqNBrNnz8Ynn3yCM844A8uWLcP9998PjUaDV199FT/88AO++OILHDhwAEIIOJ3ORt0Lh8OBjRs3ory8HM8//7zy2O7duzFx4sSwz/v111/x1ltvAQCSk5Mxc+ZM/PTTT5g0aRL69OmD7777DiNGjMC6devw+OOPY9OmTSgqKsJtt90W9jr27NkDQG6ZsdlsjVpnqPHjxwMAOnXqhF69eiErKwsA0KFDB5SXl9d77wcPHtzk6xHRqS9hg/LSpUvx6KOP4n/+53+Ux5YvX4533nkHfr8f/fv3x6OPPgqv14uFCxcqfyH27t0bn3/+OTweD+666y706dNHeTwRNtEQUeO1a9cOCxcuxPz58zF9+nTVr2e1WpW3//SnP0GSJFxyySW48MILkZeXByGE8nGTyQRADngAIITAwIEDsWrVKqxbtw7r16/HnDlz8M9//hOZmZnK10mShJSUFHz66afKYydOnEBycjJ+++23sDV07NgR3377LTZs2ID169fj2muvxYIFCzBhwoSwdc+aNQvTp0/HnDlzUFFRgbPPPhsOhwMzZszAxRdfjGHDhmHWrFlYuXJl2GsIrj/0Ma/XCwDw+/0QQuDDDz+ExWIBAJSUlCivOyj4eTUf8/l8AIA5c+Zg+fLlKC4uxtixY5GUlARJktC9e/ewDZsFBQVIT0/H559/HnYPmsJgMER8O6i+e09EFEnCTr14/PHHMWzYMOX9ffv2YenSpfjwww/x6aefonXr1njzzTeRlpaGiy++GIBcGfjXv/6Fiy++GEajEdOmTQMg/6X90ksvKZ9HRCePSy65BBdccAHeeeedqD+3TqdTAl1Nq1evxm233YaJEydCo9Fg69atkCSp3ud7+umn8fLLL+Piiy/Gww8/jB49etT6rVjXrl1hMpmUsJaXl4fJkydj+/bttZ7vgw8+wIMPPojzzjsP999/P8477zzs27ev1udlZWVh0KBBeOSRR5R+28OHD6OyshJ33303LrroIvzyyy/weDzw+/1hX5uWlqZcu6SkBJs2bQIA2Gw2DB48GG+//TYAuff58ssvx6pVq8K+3mazYdCgQViyZAkAoKKiAsuXL8e5554LABg7dix27NiBpUuX4g9/+AMAYPDgwTh8+DA2btwIANi1axfGjx+PwsLCeu8vUP/3rCFNufdEREACV5Rr2rBhAw4fPqz8Rev1etGvXz/l4xUVFbj11lvRp08fzJgxQ3nc4/HggQcegM/nw8033xzzdRNRyy1YsACbN2+O+vOOHj0aTzzxhFJFDXXPPffgtttuQ2pqKiwWC4YPH44jR47U+3xXX301HnjgAUyePBlGoxG9e/fG5MmTwwKg0WjEyy+/jMcffxxvvPEGfD4f7rrrLgwdOhQbNmwIe77p06fjl19+wcSJE2GxWNCuXTtcddVVEa89Z84c3HXXXUp7We/evXHhhRfikksuQUpKCjp16oQePXrg8OHDYZsj582bh/vuuw/jx49Hhw4dcNZZZykfe/rpp/HYY49hypQp8Hg8mDx5MqZOnVrr2k8//TQWLVqEZcuWwePxYMqUKZg5c6byeidOnIi1a9di4MCBAID09HS88MILePLJJ+F2uyGEwJNPPqm0nNSnvu9ZQ+q790REkWhEzd+ZJZiLLroI7777LlatWoXc3FwsWLAAAFBVVaX8Gq2wsBDXX389zjnnHDz00EPKr0Krqqrwxz/+Ea1atcLTTz+tys55IiIiIjo1JWzrRU1nn302vv32WxQXF0MIgYULF+Kdd96BJEm45ZZbcMkll+Dhhx9WQjIgb8bp3Lkznn/+eYZkIiIiImqSk6b1ok+fPrj99ttx9dVXw+/3o2/fvrjpppvw3XffYefOnZAkCV9//TUAYMCAAZg7dy5WrVqFHj16KJuAMjMz8frrr8fxVRARERHRySLhWy+IiIiIiOLhpGm9ICIiIiKKpYRrvXC5XNi+fTsyMjKg0+nivRwiIiIiOkVJkoSioiIMGDAAZrO51scTLihv374dc+fOjfcyiIiIiOg0sWTJkrDzO4ISLihnZGQAkBecnZ0d59UQERER0akqPz8fc+fOVfJnTQkXlIPtFtnZ2ejQoUOcV0NEREREp7q62n25mY+IiIiIKAIGZSIiIiKiCBiUiYiIiIgiYFAmIiIiIoqAQZmIiIiIKAIGZSIiIiKiCBiUiYiIiIgiYFAmIiIiIoqAQZmIiIiIKAIGZSIiIiKiCBiUiYiIiIgiYFAmIiIiiqOdh4rxzAeb4feLeC+FamBQJiIiIoqjrXuL8MPmo6hweOK9FKqBQZmIiIgojtxeCQBQVuGO80qoJgZlIiIiojjy+PwAgNIKV5xXQjUxKBMRERHFkYcV5YTFoExEREQUR8GgXMqgnHAYlImIiIjiyOOVWy9YUU48DMpEREREceRWKsrsUU40DMpEREREccQe5cTFoExEREQUR97A1IuySgblRMOgTERERBRHbm7mS1gMykRERERxFGy9sFe6IfEY64TCoExEREQUR8Gg7BeAvYpV5UTCoExEREQURx6fH8lWAwBu6Es0qgbl7777DjNnzsSECRPw17/+Vc1LEREREZ2UPF4JWelWAOxTTjSqBeXc3Fw8+uijePnll/H5559j586d+PHHH9W6HBEREdFJyeOVkBkIyqwoJxa9Wk/87bffYuLEicjOzgYAPPvsszCZTGpdjoiIiOikI/kFfJJAZhqDciJSraJ8+PBhSJKE66+/HlOnTsUHH3yA1NRUtS5HREREdNLxBjbytbKZYNRreTpfglEtKEuShHXr1uGpp57C0qVL8fvvv+OTTz5R63JEREREJ53gDGWjQYdWKWYeOpJgVAvKbdq0wYgRI5Ceng6z2YwxY8Zg27Ztal2OiIiI6KTj8cqn8hkNOqTZTCizMygnEtWC8ujRo7F69WrY7XZIkoSff/4Z/fv3V+tyRERERCcdj0+uKJsMWrRKNrGinGBU28w3aNAg3HDDDbjiiivg9XoxcuRIzJo1S63LEREREZ10PKGtF8km7D5cEucVUSjVgjIAzJ49G7Nnz1bzEkREREQnrdCgnJZshr3KA0nyQ6fjmXCJgN8FIiIiojip7lGWWy+EAOxVnjivioIYlImIiIjixB1WUZbPm+DpfImDQZmIiIgoToKtF6ZAjzLAQ0cSiao9ykRERERUN49Pbr0w6LUQQo5lwSozxR8rykRERERxErqZT6ORHxNCxHFFFIpBmYiIiChOQlsvtIGkzJycOBiUiYiIiOIkUkXZz6ScMBiUiYiIiOIk2KNs1GuhCSRlv59BOVEwKBMRERHFiccrQafVQKfTQqsNtl4wKCcKBmUiIiKiOHF7JRgNOgBQepRZUE4cDMpEREREceLx+mEKBGVOvUg8DMpEREREceLxSjAY5DhWPfWCQTlRMCgTERERxYnHK8GoD1aU2XqRaBiUiYiIiOIktPVCG0hlrCgnDgZlIiIiojjxeCUYA60XHA+XeBiUiYiIiOLE46ueelF94EgcF0RhGJSJiIiIVLJxZz6WfLW7zo97IoyHY+tF4mBQJiIiIlLJd5ty8cXqg3V+3O31K60XwQNHeIR14mBQJiIiIlJJUakTLo9U58dDK8oapaIck6VRIzAoExEREamkqMwBn+SHT/JH/HjoeDgtDxxJOAzKRERERCrw+iSU2N0AUGdV2ePzR5h6EZv1UcMYlImIiIhUUFzuUt52e3wRP8fjlWodYc0e5cTBoExERESkgsJSh/J2pIqy3y/g9fmVHmWdllMvEg2DMhEREZEKikqdyttOd+2Ksscnh2eDvkbrBYNywmBQJiIiIlJBUVl1UHZHqCh7fXIzsolTLxIWgzIRERGRCkIryq4IPcoerxyeqw8ckR8XPJovYTAoExEREamgsNQBk1EOwZF6lN01gnJ160WMFkgNYlAmIiIiUkFRqRMdMm0AAFekHmWv3HoRHA8HyFVl9ignDgZlIiIioigTQqCozImOmckAIleUa7ZeAHJVmVMvEgeDMhEREVGU2as88HgldMySg3KkOcrBoGzSVwdlrVYDP3svEgaDMhEREVGUBTfyKa0XESvKwdaLmhXlGCyQGoVBmYiIiCjKisrkw0Yy060wGXUR5yhXb+Zjj3KiYlAmIiIiirJgRTmjlQVmo66OOcp19SjHZo3UMAZlIiIioigrKnPCZNQhJckIk1HfqDnKgFxR5ma+xMGgTERERBRlhaUOZLSyQKPRwGLU1TFHufZ4OI2Gm/kSCYMyERERUZQVlTqR0coCADAb9XXMUQ5MvajResEe5cTBoExEREQUZWWVbqSlmAEApjoqysGgbAgZD6fTskc5kTAoExEREUWZ1+tXeo/NRn3EzXwenx9aDaDXaZTHNJx6kVD0aj75VVddheLiYuj18mUWLVqEQYMGqXlJIiIiorjz+iQY9XI90mzU1bmZz2jQQaMJDcqsKCcS1YKyEAIHDx7EDz/8oARlIiIiotOB1+eHIRiUTZGnXrgDQTkUp14kFtVaLw4ePAiNRoMbb7wRU6dOxfvvv6/WpYiIiIgShhACXskPfVhFOXKPcrDqHKTRcjNfIlGt1Gu32zFixAgsXLgQLpcLV111Fbp27YqRI0eqdUkiIiKiuJP8AkJAqSgHN/MJIcLaLEL7mIM4Hi6xqBaUhwwZgiFDhgAArFYrZs+ejR9//JFBmYiIiE5pXp88H9mgq97M5/cL+CR/2ISLulsvYrdWqp9qrRebNm3CunXrlPeFEOxVJiIiolOeEpSVHmU5DDvd4e0XHq8UNkMZALSco5xQVAvKFRUVePLJJ+F2u1FZWYlPPvkEY8eOVetyRERERAnB6wvORw72KMuFwtANfdsPnMD+o2WwWQ1hX8upF4lFtRLv6NGjsXXrVkyfPh1+vx9XXHGF0opBREREdKqqVVE2ylXj4CzlL1YfxOufbkfb1lZcP3VA2NdqtZyjnEhU7YW4++67cffdd6t5CSIiIqKEUjsoy3HL6fbB4fLi9eW/Y1DPDDxw9XBYzZEqygzKiYIn8xERERFFUc2gbAqpKJfYXfAL4KLhnWqFZEDuUWZOThzcXUdEREQURdU9ynJAtpiqe5RL7HIKbp1ijvi1Gg04Hi6BsKJMREREFEV1VZRdHgkl5S4AQHpqXUE5fOrFsu/34/G3N6i5XKoHgzIRERFRFNXVo+xy+1Bil4NyWrIp4tdqteGtFwePleOXnQXweGuf7EfqY1AmIiIiiiKvFHnqhcsjodjugsWki9ifDMgHjoRWlIUQ8PsFcgsqVF41RcKgTERERBRF1RXlwMl8oT3K5S6k19GfDASmXoT0KEuB0JyTZ1druVQPBmUiIiKiKPJ6ww8cMeq10Giqp16kp1jq/NqaUy+CG/sOHWdQjgcGZSIiIqIoUirKOjlmaTQamI06OD0+lNrdDVSUa7deAEBOXrmKK6a6MCgTERERRVHNHmUAMBn1cAd6lOuaeAHUnnrhl58Kh47bldBc5fTyUJIYYVAmIiIiiqKaUy8AeUNfcbkLHq9Ub0VZV2PqRTA026s8KKtw40SZE9cs+ho/bTmmzuIpDA8cISIiIoqiYFDWhwVlPY4XVQKo+7ARoPaBI34hoNEAQgCH8uzYc7gULo+EghKHSqunUKwoExEREUVRzakXgFxRDobbtJTIM5SBwNSLsNYLgXZtkgDIM5W//eUwAMDh8kZ93VQbK8pEREREUeT1SdBpNdBpNcpjZqMeUqBSXF+Pcs2pF0IIpCSZ4PJIWLH2EIpKnQAAh9unzuIpDCvKRERERFHk9fnD+pOB6mOsASA9ufFTL/x++bS+ru1SUVTqRLLViDapZjhdDMqxwKBMREREFEW+CEHZEjh0JMmsVw4giaRW64UQ0Go06NI2BQAwZnhHpNhMcDAoxwSDMhEREVEUeeqpKNfXdgHIrRfBkXCA3KOs1QL9u7WGQa/F+HM6w2rWo4o9yjHBHmUiIiKiKPL6JOhDNvIBco8ygHpHwwGAVluj9UIIaDQaDO2TiSWLLoHFpIfVZMCJMmf0F061sKJMREREFEVen185lS/IHKgopzUQlGu2XgghoNVqoNFolPYNq1kPh5sV5VhgUCYiIiKKovo289U3QxkItF6EHjjil3uUQ1nMevYoxwiDMhEREVEUeaW6N/M11HohHy4S2nqBWkHZamJQjhUGZSIiIqIoijT1wtyEzXw1DxzR1khrSRYDfJIfXp8UnQVTnRiUiYiIiKLI6/PDWHMzX6CinFbPDGVA7lEOa70IbOYLZQ08F6vK6mNQJiIiIooieepFeMQa3DMDs0b3QK9OafV+rUYrV5GDgpv5QlnMBgAMyrHA8XBEREREURRpM5/NasQ1k/s3+LURWy9qVpTNcnzjLGX1saJMREREFEWRDhxprFpTLyJt5gsEZR5jrT4GZSIiIqIoilRRbqxaUy8ibOazmoKtF6woq41BmYiIiCiK5KkXuoY/MQKttkbrRaTNfIGKssPNirLaGJSJiIiIosjrk1pQUQ5vvRB+AV2tzXycehErDMpEREREURTpCOvGqn3gSO2KcpKZrRexwqBMREREFCVCiIgn8zWWVqMJGw/nF6g1Hs6g10Kv08DJ1gvVMSgTERERRYnkFxACMBiaGZS1NaZe+AVq5GRoNBpYTAa2XsQAgzIRERFRlHh9fgCAQde8zXwRp17UaL0A5A19nKOsPgZlIiIioihRgnILWi9Cg3Kkk/kAOShzjrL6GJSJiIiIosTrkwA0PyjXnHoRaTMfAFjNbL2IBQZlIiIioihpeUVZHgkXFGkzHwBYTHo43Gy9UBuDMhEREVGUtDQo16ooR9jMB8itF6woq49BmYiIiChKWh6U5XaLIPkI69pJOclsYI9yDKgelJ944gk88MADal+GiIiIKO6qe5Sjc4S1EHVPveCBI+pTNSivW7cOn3zyiZqXICIiIkoY1ePhWjL1Qg7IQgj4BSJu5rOY9fD4/Mr1SB2qBeWysjI8++yzuOWWW9S6BBEREVFCCQZXfQt6lAEEwrL8WMTxcCb5GGuezqcu1YLyI488gnvuuQcpKSlqXYKIiIgooXglOSgbm3syXyATy9VkOSlrIzyV1awHALZfqEyVoPzRRx+hbdu2GDFihBpPT0RERJSQqjfzNfdkPjkp+4W8kQ9AnT3KADj5QmV6NZ50xYoVKCoqwrRp01BeXg6Hw4G//e1veOihh9S4HBEREVFC8HpbeuCI/GdYRTlSUA60XrCirC5VgvLbb7+tvL1s2TL88ssvDMlERER0ymvpZj5doPfC768OynVt5gMAB3uUVcU5ykRERERREuxRbsmBI4A8S7m+zXxJlmBFmUFZTapUlEPNnDkTM2fOVPsyRERERHEXjZP5AHniRb2b+UxyhHOy9UJVrCgTERERRUlLx8OFTb2oZzOfhZv5YoJBmYiIiChKojr1Qqko1w7KJoMOWq2GPcoqY1AmIiIiihKvT4JWq1E25TVVpIpypM18Go0GVpMeDidbL9TEoExEREQUJV6fv9n9yQCg0UbYzBchKAPyLGVWlNXFoExEREQUJT6fH8YWBOVgKPb7qyvKdU2as5oNqGJFWVUMykRERERR4pVaWFGOMPUiUusFANisBlQyKKuqwe+k3+/HG2+8gfnz56OyshKvvfYaJEmKxdqIiIiITioerwR9MzfyAdU9yv7Qk/nq6HdOTTLBXuVu9rWoYQ0G5SeffBJ79+7Ftm3bAAA///wz/v73v6u+MCIiIqKTjdfnb/apfECNinI9m/kAICXJiPJKT7OvRQ1r8Du5bt06LF68GCaTCTabDW+99RbWrFkTi7URERERnVRaupkveLiICNnMp6srKNuMqHB4IAUCNUVfg99JvV4PbciRMEajEXq96gf6EREREZ10otWj7A89cKSe1gshgEoHq8pqaTDx9urVC0uWLIEkSTh48CD+/e9/o0+fPrFYGxEREdFJxdfS8XARN/NF/txUmxEAUF7pRqrN1OxrUt0a/E4+/PDD2LFjB4qLi3H55ZejqqoKDz30UCzWRkRERHRSaWnrhS7CeLj6KsoAYK9iRVktDVaUbTYb/va3v8ViLUREREQnNa9PQpLF0Oyv1wQydtjUi3p6lAGgnEFZNQ0G5b/+9a8RH1+wYEHUF0NERER0MmvxyXwhrRfKyXx1VJRTkuSgbK/kiDi1NPidbNWqlfJPUlIStmzZEot1EREREZ10Wjz1IpCJRehmvjrHw8mtF6woq6fBivLtt98e9v7NN9+Mm2++WbUFEREREZ2sPFGqKPv9Qhn7VtdmPoNeiySzHuWsKKumyd9Jq9WKwsJCNdZCREREdFKTp1605GS+0NaL+jfzAXJVmZv51NOkHmUhBHbs2IFu3bqpuigiIiKiRGev8kDy+5GWbFYe8/qkFlaU5T8bs5kPkDf02Xk6n2oaDMqtWrUKe3/q1KmYOnWqWushIiIiOim8/PFWHCusxAv3Xqi0TLT0COtg9dgvBIQ//LFIUpNMKCpzNPt6VL8m9ygTEREREVBR5UFOnh05eXZ0bZcKIUTUTuYTfkBqREU51WbE/qNlzb4e1a/OoDxkyBDlmxVKCAGNRoNff/1V1YURERERJbLgZruffzuGru1SIfkFhEBUpl6EHmGtqefpUpKMsFe5lXxG0VVnUP7iiy9iuQ4iIiKik4rPJ/dGrP7tOOZd0hfewPvRmaMsqjfz1dejnGSCTxJwun2wmpt/0AlFVmdQbt++vfL2zp074XA4IISAJEk4cuQI/vCHP8RkgURERESJyOf3Q6sB8oqrsP9oGbLSkwAA+hZVlKunXjQ0RxmQWy8AoLzSw6CsggZ7lBcsWIBVq1bB5XIhKysLR44cwdChQxmUiYiI6LTm8/kxoHsb7DxUjJ9/O45pF8hTwYwtGA8XPvVCfrvezXy24KEjbrRtk9Ts61JkDf7Is3btWqxatQrjxo3Dv/71L/z73/+G2Wxu6MuIiIiITmk+SSDVZsKQ3pn4fnMuPvnhAIDotF74/SHj4eqdoxw8xpoj4tTQ4HcyIyMDVqsV3bp1w969e3HWWWehtLQ0FmsjIiIiSlg+yQ+9ToNJI7vC7xf49Cc5KLdJtTT7OXXa2q0X9e3RU4JyFU/nU0ODrRcGgwEbN25E9+7d8dNPP+Hss89mUCYiIqLTnhyUtRjaJwtLFl0Cr0+Cw+VT2iGaI7T1ojGb+ZTWC1aUVdFgRfm+++7Dhx9+iFGjRmHXrl0455xzeOAIERERnfYkSUAfcriIQa9rUUgGwqdeKJv56mm9MBt1MOq1KOcx1qposKKcnJyMZ555BgDw0UcfwW63IyUlRfWFERERESUyr+Rv0YSLSMKmXojwxyLRaDRIsZlQXsnWCzU0+N297rrrMHfuXCxfvhxut5shmYiIiAiAJPmVnuJo0UQ4cKS+ijIgj4izs6KsigaD8vfff4+bbroJP/zwA8aMGYNFixZh9+7dsVgbERERUcLytfC46ki02pDWC9HwZj4ASLEauZlPJQ1+d7VaLUaNGoXnnnsO77zzDrZv344ZM2bEYm1ERERECUkIAZ8koNOq03rh90PZzNdQ1TrVZuJmPpU0+N31+Xz45ptvcMstt2DevHkYOHAgli9fHoOlERERESUmKdAWoder33qhaaCknGJjRVktDW7mO++889CzZ0/MmTMHL7zwAoxGYyzWRURERJSwfD4/AEAf5Ypy2NSLRmzmA4DWKRY43RIqnV7YLDzGOpoaDMoffvghunTpEoOlEBEREZ0cfEpFWZ0eZX/IgSMNbebLam0FABQUV8HWoVVU13O6a/C7y5BMREREFE6pKOuiXVGW/wzdzNfQYI2s9EBQLnFEdS3UiKBMREREROEkfzAoR7dHWRvSeqGczNdAUs5mUFYNgzIRERFRE3lVqyhXT71o7GY+m9WIJLOeQVkFdfYof/PNN/V+4bhx4xp88ueffx5ff/01NBoNZs+ejWuvvbbpKyQiIiJKMD5JDsq6KAdlZTxc6Ga+RhxqkpWexKCsgjqD8nvvvVfnF2k0mgaD8i+//IL169fjs88+g8/nw8SJEzFq1Ch069at+aslIiIiSgCSJKdYQ7SDcuDpROjJfA2dOAJ5Q9/RwoqoroWaGZQb46yzzsK7774LvV6PgoICSJIEq9XaouckIiIiSgReSZ0eZaX1QqDRm/kAeUPf5l0FEEI02KpBjdfgeLicnBy8//77cDgcgZ9u/Dh8+DA+/PDDBp/cYDDghRdewFtvvYUJEyYgKysrKosmIiIiiidJpdaL0KkXopHj4QB5Q5/H50dphRvpKeaorul01uB3995774XX68WWLVvQvn177N+/H7169Wr0Be68806sW7cOeXl5WLp0aYsWS0RERJQIfGq1XgSnXvgFJNG4zXwAkNU6CQBQUMw+5Whq8LtbVVWFv/zlLzjvvPNwwQUX4O2338aOHTsafOIDBw5g165dAACLxYJx48Zhz549LV8xERERUZwF5yjrVGy9EKJx1WQgdJZyVVTXc7prMCi3atUKANC5c2fs27cPKSkp8AdmB9bn6NGjWLBgATweDzweD1atWoWhQ4e2eMFERERE8eYLzlGO9sl8oQeO+EWjNvIBQCZnKauiwR7lzp074/HHH8eMGTPw8MMPw+FwwOPxNPjEo0aNwtatWzF9+nTodDqMGzcOkyZNisqiiYiIiOJJOZlPq9YR1sGg3LivMxl0SE8xMShHWYNBeeHChfjpp5/Qr18/zJkzB2vWrMFjjz3WqCe/8847ceedd7Z4kURERESJxBfYaBftinLYgSNCNLr1AuAsZTU0+N197bXXMH78eADAFVdcgX/+859YsWKF6gsjIiIiSlRKRTnqPcryn0II+Js46i0r3Yr8YvYoR1OdFeUXXngBdrsdK1asQGVlpfK41+vFd999hwULFsRkgURERESJRvKrc4R16Ml8TdnMB8hB+actR+GT/FFf1+mqzqA8aNAg/P7779BqtcqGPgDQ6XR48cUXY7E2IiIiooTk9QVaL6I+RzkwHk6gSZv5ADko+wVwosyJ7MC4OGqZOoPyqFGjMGrUKFxwwQUYOHAgfD4fhBAwGAyxXB8RERFRwvFJ6oyHqzX1ogk5vF2GDQCwZutxzLqoZ1TXdbpq8Pa3a9cON9xwAwYPHoyBAwfiqquuQkFBQSzWRkRERJSQgifzRfvAkZpHWDeloty3SzpGnNEW76zYiY0786O6rlB7DpdACmxmPNU1+N197LHHMHjwYKxduxZr167FsGHDsHDhwhgsjYiIiCgxBSvKUe9RDo6H88sV5aZs5tNqNfjT5WeiW/tUPPX+JhzOs0d1bQBw/EQl7nvhZ/yyIy/qz52IGvzu5uTk4Pbbb0dKSgrS0tJw55134siRI7FYGxEREVFCCh5hrVNh05xWI7deNHUzHwCYTXr8+bqzIQTw33U5UV/biTInAKCssuEzNU4FDX53fT4f3G638r7T6WzSTzdEREREp5rqinL0M5FGo5EPHBGNP3AkVOtUC9pl2FQZFVdeIQdkp8sX9edORHVu5vN4PDAajZg4cSKuueYazJw5EwCwbNkyZa4yERER0enIJ/mh02pUKR5qNJrqqRfNScqQJ2DkFlREeWVAWaVcPHW4vVF/7kRUZ1C+9NJL8cknn+C2225DdnY2fv75Z/j9fsycOROzZ8+O5RqJiIiIEopPElE/lS8o2HrR1M18obJbJ2HzrgKIJh5a0pDyQFB2uk/zirIQ1bsZZ82ahVmzZsVkQURERESJzif5oW9mtbchGq1GnnrRxM18obLSrfD4/CitcCM9xRy1tZVXsfUCAOB2u7Fz586wwByqf//+qi2KiIiIKJH5JL/qFeXmbOYLykq3AgAKih3RDcqsKMtyc3Nxxx13RAzKGo0Gq1atUnVhRERERInK51PvmGitRiOPh2vmZj6gOijnl1Shb9f0qK2trCLYo3yaB+UePXpg+fLlMVwKERER0clB8gtVRsMBIVMvWriZDwAKShzRXFp1RTmk9cLl9qHS6UWbVpaoXisRqPMdJiIiIjqF+Xx+GFQYDQeETL0QzQ/KRoMO6SkmFBSrFJRDKsrvfbULNy9ehd/2Fkb1WomgzqA8bNiwWK6DiIiI6KThlfyqVZS1WigV5ZZMrMhKT4pqRdnrk1AVqCSHtl4Ul7vg8UpY9OYGbNpVELXrJYI6v8MLFiyI5TqIiIiIThqSJFTrUQ5WlIUAdC0Jyq2tKCiJ3qEj5YHT+PQ6bVjrRZXDi45ZyeicnYzH396A4nJn1K4Zb2y9ICIiImoin+RX5VQ+IGSOsl+gJSOQs9KtOFHmVE4RbKlg20VWujWs9aLS6UFmmgXzJvaDTxL1VrElyY//fLcPrpNkMyCDMhEREVEjHC2sPulODsoxmHrRglnN2elW+AVQVBqdCm+woty2TRJ8kh9enwQAqHR6YbMYkWSWZ0RUOes+tW//0TK88+VObN59cvQzMygTERERNWD34RL88YnvkJNnB6BuUJYPHGl5UM5KTwKAqLVfBI+vzm4tT9RwBNovKh1e2KwGWM0GAFD6mCOpcsofs1e5o7ImtTEoExERETWg1O4O/OkCoHJQDk698Df/CGsg+iPigq0XbVvLAdzp9sHvF3C4vLBZDLBZ5KDscNVdUXa45Y/ZHZ6orEltDMpEREREDXB7pbA/fSpu5tNq5KkXQqBFQbl1Kwt0Wk1Ug7Jep0XrwLxkp9snh2UBuaIcCMr1tV5UV5QZlImIiIhOCW6PFPanT/JDp+YcZT9avJlPp9UgM80atVnKZZVutLIZYTXJvcgOl3zQCAAkmQ0w6rXQ6zT1BmVnoKJcwaBMREREdGpwe+VKqCsQlCXJD4OKFWUhBKQW9igDcvtFfpR6lMsrPUhNNsES2LTndPtQGWihsFkN0Gg0sJoNSu9yJKwoExEREcWBEAKf/nQAJ8qiP8dXqSgHArNXEtDr1T3CWkQhKLfNSMKxoioIIZTHcvLszRoZV17pRqrNBIspJCgHqsc2ixGAXFmuakSPcgV7lImIiIhip7TCjTc+3Y7lPx6I+nMrPcohFWVdC0NsXbTa6GzmA4COmcmocnpRViFvxCssceCuZ77Hmq3Hm/xc5ZVutLKZYDUFN+35lDYLm1V+LMmir7eiHDyohBVlIiIiohgKVik3747+Mcoer1yBDe1RVquirFUqymhxRblDpg0AkBuYAX3gWBn8Ak0+PU8IgbJKD1KSjOGtF8Ee5cBGPqvZUP9mPhd7lImIiIhirtIhh7CjhZVRm/QQ5PbIlVBl6oVPzfFwcjVZauFmPgDomJUMQL4nAJBzXJ4DXeGoO8xG4vJI8HgltLKZYDHqAAR7lIOtF8GKcgOtF4GKcpXLF7UTA9XEoExERESnhNC+11+jXFWu2Xrh86s3Hi5ac5QBoHWqGRaTDrkFckU5Jz8YlBtX0S0ud+JEmVOZoZxqM0Gn08Jk1MHh8qLS6YFWq1H6lq1mPRz1VJRDZyyfDH3K+ngvgIiIiCgaghMYTEYdNu8uxCXndo3acwcDsitQWZYryir1KCtzlFu+mU+j0aB9ZnKtinJlAxXlCocHS1fuxRerD8Fq1uPGaQMAAK2STQAAi0kPp9sHj1eDJLM88QIIVpTr7lF2uHyB1ye3X6Qlm1v0+tTGijIRERGdEoL9smf3z8a2/UXw+qL3q/3QA0eEkNsi1K0oB46wbmnvBeQ+5aMFFXC5fcgrlkfF1VfNFULg/hd+wqc/HcD5g9tBCIEXlv4GAEi1ydMtgkG50ulVNvIB8tQLp9sHyS8iPTUcLi/apMknBp4MG/oYlImIiOiUUOHwQqvV4LxB7eF0S9iVU6x8rMrpxQv/t0WpOjdV6IEjPkkOgeqdzBdovYjCZj5AnnxxotyFPUdKIQSg12nqrSh7fH4cK6rC5WN7409XDMXD156N4HS5VFt4RbnS6VX6kwF5Mx8AOOvoU3a4fMgOHK19MrReMCgTERHRKaHC4YHNYsCgnm2g12mweVeh8rHf9hXh21+OYMfB4nqeoW7BirLLIymb0FRrvdDKUy9aejJfUMcsefJFcCRcr05pqHDWHVJdbrl1IiVJrh7379Ya9105FGf2yUTrFLlVwmqWx8BVObzKxAsASApMxIjUfiFJfrg8ErJbJwE4OSrK7FEmIiKiU0KlQ65uWs0G9OqUhh2HqkPx0cBmtuZWMasPHJEgKUFZ3akX0djMBwAdMuXJF2t/Pw6TUYceHVvh0PHyOj/fGQjKZlN1TBw5sB1GDmynvG8x6VFc7oLb40NGmkV5PBiaHREqysHnzUpn6wURERFRTFU6PEi2ylXQbu1ScSTfDn+gV/ZIICjbq5o2Fi0odOqFNxCUdSpPvYjGZj4AaNsmCTqtBuWVHnTJTkFKkhFOt1RnD3cw0FpMdddTg60XVU4fbIF7Dsg9ygAizlIOjoZLSzbBaNA1eURdPDAoExER0SmhImRjWZd2KXC6JRSWyvOUc6NVUfb4IMWgR9kfxc18ep1WaXfo3DZFOW66so72C5dbfq3meoKy1WyA0+VDpdMT3qNsCbReRAjKwfnKVosBKVYD7FXuZrya2GJQJiIiolNCaEW5c9sUAEBOnh2SXyjj0ZodlEOmXgR7lA16dXqUNRq5muz3R6eiDFT3KXdpm4LkwA8TdW3oUyrKxvoryvYqN3ySCAvKSkU5Qo9ysKJsNemRkmRCRTOr+7GkalB+6aWXMGnSJEyaNAlPPvmkmpciIiKi08zabcfx4bd7lPcrHNUTGDpnVwflwhKH0mbQ3L5Yjzd06kWg9UKr/tSLaGzmA6pP6OvSLkVplajrhwZnYFZ08KjqSCwmPYIT4JIiTL2I1KMcfCzJYkBy0mleUV67di1Wr16NTz75BMuXL8eOHTvw7bffqnU5IiIiOoUJIfDzb8fCjj3+blMulv94AAAg+QUcLq8SAi0mPdq2TkLOcbvSdmEy6ppVUZb8Al6fHxqNXFEOhm69XsXNfFGuKA/plYkOmTZ0b5/acEU5UPk1B46qjiS0fzlsjnKw9SJiUK7ufU5JMp3e4+EyMjLwwAMPwGg0wmAwoHv37jh+/LhalyMiIqJT2KHjdjz53iZs2JGvPFZid6HK6YXT7YPD5YUQUEIgAHRum4ycPLuyka93pzRUNKOiHKwmJ1uNEKI68OmjFGJr0mrlA0dElHqUAeCMHm3wyvwxsJoNSntKXUE1ePpgfZv5rCHV5tDWC4NeB6NeiypnpNaLkIqy1XB6T73o2bMnBg8eDADIycnBihUrMGrUKLUuR0RERKewYMAtKnUqj5XYXQCAE2VOJfSFTmDo0jYVeScqsf9oGVqnmpGVbo0YDvNOVOG1T7aFVatDBTfyBecKBwOfehVlTVTHw9VU3XrRQI9yA1MvlOezGMM+ZrUY6mi9CO9RrnR66zzBL1Govplv3759uO666zB//nx06dJF7csRERHRKcjhloNXcbkclP1+gdIKuce1qMyptBGEtgF0aZcCvwA27ypAx8xkpCQZYa/yQojwcPbTb0fxxepD2JVTEvHawY18waAcnOigV7FH2S/k9ototV6Espr00GpQ5ymFTrcPWq0Ghnp+EKir9QKQDx2pa+qFVquByahDcpIBQtS9hkShalDevHkzrrnmGtx7772YMWOGmpciIiKiU1iwGllSLleRy6vcyozkotLqoJxsCa0oyxv6XB4JHbOTkWw1wif5lYpp0NECeSLG7/tPRLy22xN+Up0SlFXsURZCRHUzXyitVoMki7Ge1gsJFpMemnouHtp6EbqZL/i+I8LUC6fLB2vgeVMaaP9IFKoF5by8PNx22214+umnMWnSJLUuQ0RERKeBYPAqDrRblNqrJyaEt15Uh7bs1kkwGuQNaR2zkpGcFLnlILdQ7mHeVldQVirKJgBAZbD1QsUjrIVAVDfz1ZRsNdS5mc/l9sFSz0Y+ILyiHJx0Efp+cDNfcblTaZGpcnmVgB28l4k+Ik61oPzmm2/C7XZj8eLFmDZtGqZNm4b//d//VetyREREdAoL9ryeKJNbL4LhK/hY8Ff4ySE9yjqtBp2z5bFonbKSlYpw6IY+f2DGslYD7DlcqoTiUMEe5VRbsKIsh3b1TuaD0rurU6OkDPk+1VXNdbh99R42AlQH5SSzHroaYT7JbFCq7k+8uwnPLNksP6/Lp4Tq5CT5z0QfEVf/XWiBBQsWYMGCBWo9PREREZ2CvlxzCMP6ZiEr3Rr2uNJ6YXdBCIHiQAtGeooJJ8qcyGotf37NftkubVOwL7cMHTJtyqEj9pCAeKLMCbdHwtn9s7FhRz5255RgUM+MsOeoq0fZoOIR1lJgY6FGpYqyzWpAeR1TJ1xuX70b+YCQoGw11vqY1ayHw+WFxythX24pLCY9hBBwun21K8qna+sFERERUVOUV7rx6rJt+G5Tbq2POQJ9xV6fH/YqD0or5KDcs2OaspnPYtLVOlZ63DmdMWt0D6TaTBErysG2i3HndIZWq4nYp1xz6kUwKOtUar3QaTTwBSrKaky9AOSKcn2b+RoKysHAa6vRnwzIPcpVLh8OHi+HTxKocHhRXukJtF4EKsrWYEU5sYOyahVlIiIioqYoLHUAACqdtcOTI2SKQondhZJyF1KSjMhunYTf9hWhwuEJGw0X1KdzOvp0TgeAiPODcwMb+Xp3SkOPDqkR+5Rr9igrm/liUVFWJyfDZjXUOR7O5ZaQkVb7XoYy6OUfSuoKym6PhJ0Hq6eI5BZUwOHyoX2GHD0tJj30Ok3CB2VWlImIiCghFJbI/ceRNpk53D4EuxCKy10osbuQnmJGm1YWuD0S8k5UhU28iCRYxQytKB8trECy1YhUmwlndG+DfbmlcNWYilGzohzczFff+LSW0GgBSQr0KKvVemExwuGKPMfY6fHBbGy4lmox6WtNvACqq81b9hYqp/vlFlbA4fIiKVBR1mg0SEky1hnWEwWDMhERESWEghK5ohxpBq/D5UV26yQAcl9xMChnpFkAADl59lr9yTXpdFokmfVhPcq5BRXomGUDIJ9e55MEdtaYp+yp0aMcrG7rVJyjLPnlirKaUy/kUwZr32un2wezqf6pFwDQu3MaenZsVevxYBjecbAYQ3pnwmLSKxXl8LFyxoi/PUgkDMpERESUEKpbLyKf6tYuwwaNJryinNFKDspOt6/BoAwAyUnGsJFkuQWV6JglT8bo1SkNAHAk3x72NcHWi1SbKWx9as5R9gUqyvXNMm4JWz1zjBuzmQ8AHr3hHMwZ06vW48E+ZK/Pjz6d09Axy4aDx8rh9fnDRsnVN6IuUTAoExERUUIIBuW6KsopSUa0sslTLkor3EhLMaFNICgD4aPh6hI6Fq280o0Kh0cJyjaLARaTDoUhx2QDcuuFVgOYjTpotZqQk/lUmqMc0qOs3mY+ObDWDKp+v1AOHGmu0L7lXp3S0CEzGfuPlgMIP6jEVs+hJ4mCQZmIiIgSQmGg9SLSNAZH4FS31qlmHDxeDr9foHWKGa1sJuXgj0gby2pKTjIqrRdHCuSJFx0z5aCs0WiQkWZV1hHk9kowGXXQaDQwGXRKX69aFWWtVqNcQ6UsHnFjIwC4AqcQtiQoB8OwVqtBjw6t0DErWWlfCa0o26yGiL89SCQMykRERBR3Qog6Wy+EEHC4fbBaDGidasHhPLk1Ii3FDK1Wg/RUuaocaepFTSlWo7KZ72ggKHcI9CgDQGaaFUURKsomgxz+TCEn1qm10U6jCQnKKs5RBmqfUugKbFxs6MCR+gQ3+HXOTobZpEenQMUeCK8o1zeiLlEwKBMREVHcVTi8cLolJFsNcHkk+AKtB4AcVP1+oVSUgyEyPdUMAEqfcnJje5QD4Sy3sBJmo075egDISLMogV25vleCMRCQg1Mc9DqNav3DoU+r3ma+wASPGkHVGZj40dAR1vUJVo2DPd+hP4iEtV5YDXC6w7/XiYZBmYiIiOIu2O7QrX0qgPA+5eBhI1azHq1Tq0Ntekp4UG5MRTnZaoTD5YNP8mN3Tgm6tE0JC7yZaVZUOr1h0yDkirIcHIN/qjVDGQjvS1ZtM58lckVZCcot7FEef05njDu7MwAgKz1JGaUXtpnPErlPOpEwKBMREVHcBau4XdvJQTm0/SIYWi1mA1oHqsgAkJYsv92mCRXllMDnHMmvwL7cMgzvlx328czAuLnQ9otgjzJQ3XqhUzEoh1WUVQrKOp0WVrO+zopyS1ovtFoNbp8zWKko67QatM+Qq8rhFeW6J28kCgZlIiIiirtgUA5WlEMDnMMlh7cks14JyilJRqVKGQzKtgYOHAHk1gsAWLXxCADg7AE1g7I1bD1AeEU5eBCHIUYVZZVGNQOQg6q95ma+KFSUIwn2KSfV2MwHRJ5ykigYlImIiCjuCkocsJr1yE6XDxWJVFG2mg1K60Ww7QIAhvfLwpjhHZWDQ+oT7M39fvNRZLe2hm00A6AcYFIYVlH2KZVkoyFYUVZpHAXC2y3UqigDQGqSEeUV7rDHXG55M1+0g3L3Dq1gNupqzFFO/IpydO8CERERUTMUljiRmWZVqoyhfavBirI1pKIcGpQz06y4+7IzG3WdYEW5wuHB6GEdavUApyWboddpUVSjotw6Nbz1QtUeZa0m4tvRlp5iVk5DDAr2gzfmCOummHJ+V4w4o23Ysd919UknElaUiYiIKO4KSx3ITLMqo8WqXJGCsgFWsyGsBaOpUkI2/J3dP7vWx7VaDTJaWcIqyh6vP6T1Ihab+arfVmszHyAH5eJyV9hjyhxlc3SDskGvQ9s2SWGPBXuUE/kYa1aUiYiIKK6CM5QHdG+tVBnDK8rB1gs5tvzPvOHIbm1t1rWCFWWbxYB+XVtH/JyaI+JCWy+qp17EqPVCzYpyqhkVDg+8PgkGvfy6XFEYD9dYSZx6QURERFS/KqcXDpcPWelWGA06GPXa8B7lGhvMzuyTiXYZDfcjR2I26mA26jCsb1adVWH50JHIm/lMgZYEtU7lA2pOvVDtMsrUkFJ7dZ+y0+2DUa9VdapHkE6rQZJZzx5lIiIioroE+2SDEydsVkOtqRdGgy4q7Q4ajQaPXH8O2mUk1fk5melWlNjdSqU1dDyc0nqh4jgKbYw28wXbV0oqXMhMl++90+1r0Wi4prJZjQl9jDWDMhEREcVVUZncDxycOJFkMdToUfYiKYo9s2f0aFPvx5VZymXyBkOfJGofOKJqRTk2rRdpySYAQElIn3Ksg3Ky1cDWCyIiIqK6lFfKv/pvZZMrnDaLsdbUC2uUN5fVJ1jZLipxwuOVx6XVOnBExQAbs818wYqyvToouzwSrLGsKFuMtQ49SSQMykRERBRX5ZVyUEq1yRvtkiyGWnOULeaGT92LlupZyg64PYGgXHPqhYoV5ViNh0tNMkGr1YQFZafbp7zGWLBZDRwPR0RERFSX8io3LCadcpiHzVozKPui2nrRkDatLNBq5ENH3DUrygb1T+YLP3BEtctAq9UgLdlUKyhH+7CR+sg9yqwoExEREUVkr/QgJcmkvG+zGMKONXa4vGEnuqlNr9MiPcVco6Ish0el9ULV8XDVb6tZUQbkWcqhUy9ccepRFkLE7JpNwaBMREREcWWv8iAlqfogkCSLAQ6XF36/HJ4cMa5yAkDntinYl1tWu6IckwNHYjP1ApCDclwryhYjJL+AMzACMNEwKBMREVFclVe5kWoLrSgbIUT1QSOx3swHAP27tUZuQQWKAif0GQ1yZIpFUA5tvVBzMx8QKShLMW69SOxDRxiUiYiIKK7KK8MrysrpfE75V/JOlxdJMWy9AIAB3eQRclv2FgJA7fFwalaUQ55azekaAJCWYoa9ygOvzw9APsI6lpv5kq3V3+tExKBMREREcSOEgL2yRkU5JDy5PBL8AjGvKPfo2ApGvRabdweCcuBEPnPgT3V7lEMryqpdBoBcUQaA0goXfJIfXp8/5pv5ACTs6XwMykRERBQ3Lo8Ej8+P1Bo9ygBQ5fAq7RexHA8HAAa9Fr07p+NE4DCU6iOs5T/VnHqhjdGBI0DI6Xx2F1w1jgqPhdDfHiQiBmUiIiKKm+BhI8EZykB4eHK45PAWy/FwQf27tVberh4PF4vNfKFvq9x6EXI6nyMQlGM79UL+vifqoSMMykRERBQ39io5IKXU2MwHAJVOj1JRjuV4uKABoUG5RkVZ1daLGB04AlSfzlca54pyoh46wqBMREREcaME5dDNfCGTEIIV5ViPhwOA3p3TlM10odMupp7fDcP7Zqt2XU0Mx8MFT+crtrvgCsyMjuW9Nhl10Ou0CVtRjv2/dUREREQBSutFyIEjZqMOWq0GVS6v0g4Q7FuOJbNJjx4dWmH/0bKwVosbp5+h6nVDi8hqb+YLns5XanejKNCPHcupFxqNRj50JEF7lBmUiYiIKG7KK+VKYmiPskajgc0in9jmCAQoaxwqygBw9oBsVLliG+I0MdzMB8iTL3LyyrFlbyGyW1vRo0Mr1a8ZymY1JOzUCwZlIiIiiht7lRt6nbbWr/ttFgNOlDuV92M9Hi5o1uiemDm6Z0yvqY3hEdaAHJQ37MiHUa/FU3deENPNfIDck56oB44wKBMREVHclFd6kGoz1jqBzmY1YOPOAgBAp+zkmI+HC4pFUK3vmmr3KAPVG/r+OGsQurVPVf16NSVbjcoYvkTDoExERERxU17lDutPDpp6fnfsyy3DuQPbok/n9LgE1niJ5WY+AJhyXjf06piGi8/qpPq1IunSLgUenxSXazeEQZmIiIjixl7lQUpIf3LQqDM7YNSZHeKwovgLP5lP/aDcMSsZHbOSVb9OXa6c0Ccmr7M5OB6OiIiI4sZe6QkbDUc1e5Tjt45YSdSQDMQgKFdWVmLy5Mk4evSo2pciIiKik0x5lRupttqtF6ezWLdeUN1UDcpbt27F5ZdfjpycHDUvQ0RERCchr0+Cw+VDKivKYbQxHg9HdVM1KC9duhSPPvooMjMz1bwMERERnYQiHV9N4e0WDMrxpepmvscff1zNpyciIqKTmHLYCCvKYWK9mY/qdhq0iBMREVEislcFjq9mRTlMWOsFc3JcMSgTERFRXAQrypx6ES60iMzNfPHFoExERERxUR6oKDMoh9NwM1/CYFAmIiKiuLBXeqDVyEcYUzVOvUgcMTmZ77vvvovFZYiIiOgkcqLciRSbiWGwhtBuC27miy9WlImIiCgudh0qQa+OafFeRsIJ/cGBP0PEF4MyERERxVyJ3YXjJ6rQv1vreC8l4QRbLzQaVpTjjUGZiIiIYm7HgWIAwIDuDMo1BbMxJ17EH4MyERERxdzvB0/AYtKhe/vUeC8l4QSryOzdjj8GZSIiIoq5HQeL0bdLa+h0jCI1VbdeMCjHG//tJCIiopgqr3TjSH4F2y7qoAmkM/4MEX/8FhAREZ3mvD4J32/OhdfnV+0ae4+U4sa/fYsvVx/EjoOB/uRubVS73smMFeXEEZM5ykRERJSYJL/AM0t+xZptx6HXaXH+4PZRv0beiSosenM9qpxevPrJ78hMt8Jo0KFHx1ZRv9apIBiUuZkv/lhRJiIiOk0JIfD68t+xZttxaDTArpySqF+jvNKNR19fB78feP5PF2LsWZ1QWOJAn85pMOgZQyJRpl5wM1/csaJMRER0mvr854P4cs0hzLiwB/bnlmHXoeKoX+OL1YdQUFyFJ24/H52yU3DHHwajb5d0dG6bEvVrnSqCAZkV5fjjj3JERESnoSP5dvz7y504q182rpnUD327puPgcTtcbl9Ur7NpdwF6d05Hny7pAOS+27Fnd0avTjyRry7V4+HivBBiUCYiIjrdSJIfz324BWajHrf/YRC0Wg36dkmH3y+wN7c0atcprXBhf24ZhvbNjNpzng6ChWRu5os/BmUiIqLTzLIf9mNfbhlunT0QaclmAECfznKFN5p9yr/uLgQADOuTFbXnPB1oeeBIwmBQJiIiOs18u+EIBvfKwHmDqidc2KxGdMxKxq5D0QvKm3cXIj3FhG48fa9JeIR14mBQJiJSWYXDg8ff3oDVW4/FeylEcLp9yCuuQv9utQ/76Nc1HbsPl8LvFy2+jiT58eueQpzZO4stBE3EzXyJg0GZiEhFpXYXHnp5DdZvz8fqrcfjvRwiHM63AwC6RJg60bdLOqqcXuQWVkAIASGaH5h3Hy5FldOLYX3ZdtFUWm7mSxgcD0dEpBKHy4sH/rkaxXYX2mckIbegIt5LIsLhvPqDMgA8s2QzistdaJ9hwxO3n9esivDGnfnQajUY3CujZQs+DWl4Ml/C4M8qREQq+X3/CRw/UYX75w7FOQPa4nhRJXySekcEU+z5JD/2Hy2L9zKaJOe4HRaTHplp1lofa9smCd07pMLlltCtXSp25ZRg/fa8Jl9jw/Y8fPrTQZzZOxNJFkM0ln1a4YEjiYNBmYhIJbmFlQCAAd3boFN2MnySQN6JqjiviqLp2w2Hcc+zP55Uvy04lGdHl7YpEUOYRqPBc/dciH89dDEW3ngO2mck4YOv9zSpZ3nttuP4+zsb0bVdCu694sworvz0wSOsEweDMhGRSnILKpCeYkKSxYCOWckAgKOFJ0+gOl35/QJVTi9KK1wNHr6xbf8JAMCvewpjsbQWE0IgJxCUG6LTaXHZ2N7IybNj3e+NqyoXlzvx9JLN6NGxFR67+VzYrMaWLvm0xKkXiYNBmYhIJUcLK9AhUw7IwT+PnESVx9PVX9/egMsWrMBVC7/GDX/7ts52GSEEdgZGqW05SYLyiTIXqpzeRh8fff6QDuiQacMH3+xu1Il9y388AEny4765Q9ly0QLczJc4+C0gIlKBEAK5BZVKJdli0iMjzYLc/Mo4r4zqU1bhxuZdBThnQDYuGdEF5ZUe5AQ2v9VUUOJAid0Fm8WA3w8Uw+uTIn5ecbkTi95cj9IKl5pLr+X9r3bhwZdXh02uyMkrBxB5I18kOq0GV03siyP5Fbj72R/r7ce2V3nw1bocXDCkA7JbJ7Vo7ae7YFsMN/PFH4MyEZEKistdcLp9SlAGgI5ZySdVL+vp6Jed+fAL4PJxfTD7op4AgD2HIx/pHKwmz7iwBzxeSXm/ptVbj2PjzoJGty80RaXDgzXbjsPjDQ/pXp8fK9YcwvYDxdiyp0h5PKeeiRd1GXFGO/z15nPhdPtw/ws/Yeve6ufz+iQUlToBAF+sPgiXR1LuGzWfhifzJQwGZSIiFQQDcccsm/JYp6xkHC2sgBSFwxxIHet+z0NmuhVd26UgI82CVskm7D1SV1AuRpJZj0kju0Kv09TZfrFtn9zHrEZ7xgff7MHidzbi+r9+i49W7YXXJ7eJbNlbiAqHFzqtBst/3K98fk6eHZlplia3RQzqlYEX7xuN9BQzlny9W3n85f9sw3V//Qa3P/UdPvvpAM7un93otg6qm5Y9ygmDQZmISAW5gU17HTOrK8odMpPh8flRVOqI17KoHg6XF1v3FeGcAdnQaDTQaDTo3SkNew5HrhTvPFSCPl3SkWQxoE+X9LDKbZAk+bH9oByUt+0/AamF4wG37ClEhcMDQN50uHbbcfTulIZuHVLx7opd+L+VewAAP24+imSrAX+4uBe27C1SZifLG/mad5x0SpIR00f1wK6cEuw8VIycPDtWbTqCM/tkwmY1wisJXDa2d4teH8lYUU4cDMpERCo4WlCJJIsBrZJNymOdsrihL5H9uqcQXp8fIwa0VR7r3TkNx4qqlHAaVOHwILegAn27ygd0nNk7EwePl9fqQz5wrBwOlw8jB7aDw+XD3iNlzV7fsaJKPPKvdXjj0+0AgL25pSgud2HSeV3xlxtHYNSQDvj4u/04eKwc63fk47xB7TH5vG4wGnT4aNU+/HftIRwtrESXds2v+I49qxOSrUYs+34/3vlyJ6xmA+6bOxSLbzsP//n7JPTo2KrZz03VOPUicTAoExGpILewAh0zbWGbcYJtGEcZlBPSut/zkJJkRN+urZXHendOA4Ba7Re7cuQqc7/A5w7plQkAuHbRN7h8wQp8+K1c2d26T64yz53QBxoN8Nve5rdfrNp4BADw469HcaLMiTVbj0Ov0+Csftnytaf0g0GvxSP/WguPV8KoMzsgJcmIMcM74sctR/Hyx9vQtV0Kxp7VqdlrMJv0mHxeV2zYkY9Nuwow56KeSA6MgOPGs+jRKifzxXkhxKBMRM3jk/z44OvdKK90x3spCeloyMSLIJvViLRkEyvKCajS4cGmXQU4u382dCG/7u7RoRW0mtob+rbuLYJep0HPQAW1e4dU3DZ7EGaO7oFu7VPxv1/vxqHj5fh9/wl0zk5Gx6xk9OjQClv21m7PaAzJL7BqYy56dEiFAPDpTwewdttxDO5VffJd61QLrhjfG+WVHmSkWZTjqC8b2xszL+yBp+44H8/eParFEykmjewKo0GH1qlmTD6/W4ueiyILtlyw9SL+9PFeABGdnHYeKsb/frMHep0Wf7i4V7yXk1DsVR6UVbprBWVAnnxx4Gg5hBCswCUIyS/w1Pub4fFKmDCiS9jHrGYDOmWnYE+goiyEwNJVe/HZzwcx4oy2MBvl/41qNBrlaysdHtz091V4ddk27D9ajvHndAYADOmdif98tw9VTm+jNtO5vRJcbh9SbSZs2VOIErsLN804A2u3HcfnPx+E5Be4fFyfsK+ZfF43bN5diOH9spSQlZ5ixrVT+rfkFoVJtZnwwFXDkJxkhMmgi9rzUjX2KCcOVpSJqFmCY6Y27Ij+yKuTXfXEi9pB+dyB7ZCTZ8ePW47FellUh3e/3Ilf9xTi5hkD0atTWq2P9+6chr2HS3G8qBJPvrcJ7/93Ny48swPumzs04vPZrEbMu6QPdh4qgccrYWCPNgCAwb0y4PcL5TS/uvgkP/67Lgc3Pv4trn/8W/zw61Gs3HgEyVYjzuqXjZkX9oDkF9BpNTh7QHbY1+p1Wjx287mYen73Zt6NxhneLxt9Oqereo3TGadeJA4GZSJqlpzjclDee6QMxeXOOK8msQSPqe6Qaav1sQkjuqBXp1Z449PfYa/y1Po4xdbm3QVY9sN+TDy3S61qclCvTmmodHpx8+JVWL89H1de0gd/uuJMGOuppo47pwu6tE2BVgMM6C4H5T6d05FsNeKDr3fDWccpd16fHw+8tBov/2crslsnoVu7VDyzZDPWbjuO0UM7wKDXonuHVhhxRluMHNhO6Q+mU4tSUWZQjjsGZSJqlsP5drRpZQEAbNiR3+Svl/wCP205irKKU6/H+be9RUi2GpCZZq31MZ1Wg9vnDEaFw4u3P98Rh9VRkBAC//v1HmSmW3HDtDPq/LyhfTLRvUMqZl/UE28tGItLL+7dYNuMTqvB/8wbhnvnDoUt0GZh0Gtx39yhOJJvx3Mf/gp/hHnaH367B3uOlOKuSwfjidvPw99uHYlpF3SHyaDDuEALBwA8dM1ZuH/esGa+ckp0wX+9mJPjjz3KRNRkfr/AkfwKjD27MzbtKsCG7fmYeG7XJj3Hmq3H8NT7m2E26jD1gu6YNboHrOamHYKQiMor3Vi/PQ8TR3ats7+wa7tUzBjVHR9/vx/jz+mMPl34K2w1VTm9+OTH/Rg1pENYO8zvB05gz5FS3DprIAz6uutGrVMteO6eC5t83Y5ZybXab87sk4lrJvfHW5/vwN/f+QXtM2xITzVj5MB2KC534T/f7cNFwzri4rPkUKzXaXDDtAG4dnI/6HSsbZ0u5Dne7FFOBPyvjoiarKDEAZdHQufsFJwzoC227S9CldPbpOdY+csRtEk1Y3i/bCxduRfPfbhFpdXG1vebj8InCYw7q3O9n3fp2N5olWzC21/sgBCn9kl9lQ4P7nzme3y74XCTvq7C4cGG7Xktuj9Otw9/eWM9/u/bvbjrHz9g2ff7lZMRl67ci7RkE8YMb/64tOaYPqo7pl7QDTsPleCznw/i9eXbcd1j3+DRf61DWrIJN06vXd1mSD79aDQaBuUEwIoyETVZcCNfl7bJ6Jhlwyc/7McH3+xGWrIZbVLNGHVmh3p/NX2izInf9hXhDxf3wpUT+qJz22S8/9/d2La/CAN7ZKCswo1f9xTiwjM71PofRaXDg4PHy5GZZkVGK4uqASInz44n39uI66YMwLC+WQ1+vhAC32zIQe/OaQ0e42sx6XHF+D54+T9bsWFHPs4Z0BZen4Qte4uwblsePD4Jd192Zr2VzpPFpl0FOHTcjn/+ZyuyWlsxsEdGg1/j8viw8PV12HukDLMv6omrJ/Vr8nWdbh8ee3MD9hwpxe1zBmPTrny8/cUOfLn2EIb3zcLWfSdw7eT+9fYaq0Gj0eDGaWfgxkC7x/GiSqzceAS/7MjHjdPPUFo16PSm1WjYo5wAGJSJqMkO58tBuVN2ijJP9bOfDiofX7c9D3ddOgRWswF+v6gVdr/blAshgDHD5Ere9FE98M36w3h9+Xb8+fqz8chra3GsqAr2Kjemj+oBQG73+G7TEbz1+U7llDSTUYfLxvbGjFHdawVmn+SHvgUh2uOV8PT7m5BbUIlnlmzGc3+6EFnptXuOQ+3OKUVuQSXu+MPgRl1j3Fmd8OmPB/DvL3ZiX24Z/rs2BxUODywmPZxuH9JTzLh+6oBmv4am2n+0DK1TzEhLMUf1eTfuLECqzYiUJBMWv7MRT991Adq1qb3RsTBwtHebVAv+8cGv2JdbhsG9MvCf7/bBatZjzpiGxxAKIZCTZ8fKX45g1cYjcLh9uPeKoRh1ZgeMO7sT1v2eh/+uzcGKtYeQbDVgwoj6K/+x0C7Dhqsm9sNVE5v+wwCdurQabuZLBAzKRNRkOXl2ZLe2wmKS/wp59p5RcLh8SEs24at1h/HOip3YcXAltBoNyirdyEyzonenNAzvn43zB7XDqo1H0L9ba7RtIx98YDLocO2U/nji3U24/anvAQB9u6Tj3RW7cGbvTCRbjXh6yWZs238CfbukY9boHiiv8uCXHfl458udWP97Hi4b1xsDurdG3okqvPXZDuw5UoLH/zgSPTvWHvdVF4fLC3uVB1npVryzYicO51fglhln4N3/7sKT723E4tvOj1jhPZxvx46DxfhuYy4sJh3OH9y+UdfT6bS4ZnI/PP72L/ho1V6c3T8b48/pgkE9M/DmZ9ux/McDGNijDYb3y274yVrocL4d97/wMzLTLHjm7lGwWQw4km/Hf9fmYNqo7s0+pMIn+bF5TyFGDGiLP1zcC/c+/yPuf+Fn3Dp7EEYObKd83qqNR/DC0t/g9wskmfWocvlw/dQBmHp+Nzz74a94d8Uu7DxUginnd8PgnhnQajUQQiDvRBV25ZTgRLkTRaVO/La3CAUlDuh1Gowc2B5Tzu+K3oExZhqNBucObIdzB7ZDYakDfr84Jfri6dSk0WqgOfl/oXTSY1AmoiY7nGdH5+zq1oK0ZDPSAnuWZo7ugd6d0/DZzweQZDagVbIJx4uqsONQMX767Rje+WIHTpS7MGdMz7DnHDmwHQb2aIMDx8qx6KYRyEiz4Panvsfidzeh0uFBlcuH2+cMwtizOisV6rFndcLPvx3Dq8t+x1/eWA+DXguf5IfNYoDFZMDjb/+Cf9w9CiaDDp/9fBB6nQYXD++ElCQjtuwtwr4jpRgzvBMy0604cLQMf3ljPUor3Ei2GlDh8GLyyK6YdF43tEoxY/E7G/HwK2sw48LuOKtfNnQ6LYQQ+OSHA/j3lzsgBJCSZMSVl/RVfoBojLP7Z+Oha85Cl7Ypyg8OAHDdlP7YdagEz/7vFjx15/lon1G7Ahstkl/gxf/7DSajDgUlDjyzZDMuHdsLi95YjwqHFys3HsG1U/pj3Nmdm1yl35VTgiqnF8P7ZaFtmyQ8cfv5+McHm7H4nY0Y3i8LQ3tnwl7lwQff7MGgnm0wYkBb7M0tQ9d2qZh2QTdoNBrcfekQtM+w4cvVh/Dov9bBqNciI80Kr09CYWn1aMIkiwF9u6RjzpieOLt/W7RKNtW5rkgTSYgSCSvKiUEjVNxF8vnnn+OVV16B1+vFNddcg7lz5zb4NUePHsWYMWOwatUqdOjQQa2lEVEzebwS5jz4BeaM6YUrL+nb6K/z+wU27MjD/36zB6V2N/710MW1AqXL44PX51dmw67ZdhyL39mI9hk2PHj18Dr7fj1eCdsPFuPX3YUwm3SYPqoHikoduP/Fn9G2dRLKK90oq3RDCHlsl81qQHlldfvG+HM649sNh5FkMWLGhd2Rc9wOt1fCnZcOUU4e+2pdDpau2ouiUifSU0wY3i8bXp8f323KxchB7XDd5P7ISLNE9bS9Y0WVmP/SzwCAhTeMQI/AcclBkl/gh825+O/aHLTNSMLQPlnw+eR74fJIOGdAWwzvmwWPT0J5pdzSkZ5igkEf3pO7/Mf9ePOzHbhv7lBUubx45eNt0GqAzHQr7rp0CP5v5V78trcIep0WnbKT0bVdCrq1S4XRoMOvewpxOM+OKyf0xflDalfS3/xsO75YfQhLFk1Qqrc+yY//fLcPK9YcQmlgPOD5g9vjnsuH1FpbKK9PwtpteThwrByFJQ4ICAzskYGBPdogM93KU+LolHLpw19i5MB2uPPSIfFeyimtodypWlAuKCjA5ZdfjmXLlsFoNOKyyy7DP/7xD/To0aNFC1bLoePlWPj6elhMemSmWXD2gLa4aFhHmI065J2oQkGJA21aWdCmlaVJ1SKiU83+o2W459kf8T/zhjW6xSCUEAI+STR6k9ruwyXonJ3SrP/u1mw7jife3YheHdNw88wzYDUb8PX6wyguc+K8we3QOTsFb3+xA+u356NL2xQsvPEctE611Pl8kuTHhh35+GnLMfy6pwBOt4Q5Y3riygl9VdudfqyoEo+8thYVDg8mjOiKdm2SoNVqkHeiCht35uNwfgU6ZiWjvNKtHGCSbDXCoNeixO6K+JzJViNap5phNetR6fTieFElhvbJwsPXngUAeOOz7dhzuBQPXXMW0lPMEEJg/fZ87MopwaHj5cg5bkdZpRxw27SyIMmsx+H8CtwwbQCmXRB+Itwti1chM82CRTefW2sdQggUlTpRVOZEny7p0HGHP5HisgUrMHJgu0bveaDmaSh3qpb41q5di3POOQetWrUCAIwfPx5fffUVbr/9drUu2SIZaVaMHtoBecVVyC2oxKvLtuHdFTthNupQYg8/ECHZakCbwG57n88Pr0+Cx+eXn6eVBZnpVmSlWZGVboWVu5fpVCGA8io3tuwpBAB0aWCqQ100Gg0M+sYHopYckztyYDu8/edxSEs2K0H2uin9wz7n4WvPxv7cMrTPtDUYxnU6rdLj6g1UaYOHrqilfYYNT95xPp5eshmf/3wQPkn+u0an1aBTdjL+Z94wnDeoHfwCOHSsHAa9VpnduyunBNsPnoDNbECKzQSX24cSuwvFdhdKyl1wuHxon2HDwO5tcOnY6kM0bqxx+IZGo8GIM9pixBltlcdK7S443D60a5MEj8+PZ5ZsxhufbsfabccxqGcGOmUnw+Hy4VhRJSaNjDxjW6PRIDPdiswGNkkSnY60nKOcEFQLyoWFhcjIqB4BlJmZiW3btql1uRazWQy4ZrL8P1AhBPYcKcXX6w7D45MwoHsbdMiwodjuQlGpA0VlTpwoc8Lvl6tiRr0Oer3cr1hU5sSOg8X4qewoIhy6RHTSMxl1GNIrA+3aNG9zV6zVVyEOqtnS0BgGvU71kBzUOtWCv996HiS/QHG5/HdPzdF4Ok3t19G/W2v079ZalTWlpZgR3CZpMugw/6rh+Pi7fVj7+3F8+O0eBH9XqdNqcHZ/9TcjEp1q0lPMSK+nz55iQ7WgHKmjI5q9e2rSaDTo0zm9RZUsn+THiTInXB4piisjii+bxYDWqeaT5r/lU41Oq0nYTWg6rQZ/uLgX/nBxL1Q6PDhRLrd9JJkNyEiLzQ8URKeSp+684JSYo36yUy0oZ2VlYdOmTcr7hYWFyMzMVOtyCUev0zZ7nBIR0cnMZjXCFtiQSUTNw/1QiUG1H1XOPfdcrFu3DiUlJXA6nfjmm29wwQUXqHU5IiIiIqKoUrWifM899+Cqq66C1+vF7NmzMXDgQLUuR0REREQUVarW9adMmYIpU6aoeQkiIiIiIlWwS5yIiIiIKAIGZSIiIiKiCBiUiYiIiIgiYFAmIiIiIoqAQZmIiIiIKAIGZSIiIiKiCBiUiYiIiIgiYFAmIiIiIoog4Q4SlyQJAJCfnx/nlRARERHRqSyYN4P5s6aEC8pFRUUAgLlz58Z5JURERER0OigqKkLnzp1rPa4RQog4rKdOLpcL27dvR0ZGBnQ6XbyXQ0RERESnKEmSUFRUhAEDBsBsNtf6eMIFZSIiIiKiRMDNfEREREREETAoExERERFFwKBMRERERBQBgzIRERERUQQMykREREREETAoExERERFFwKBMRERERBTBSRuUX3rpJUyaNAmTJk3Ck08+CQBYu3YtpkyZgnHjxuHZZ59VPnflypWYNm0apk6diltvvRXl5eVhz/X888/jxRdfrPNau3btwqxZszB+/Hg8/PDD8Pl8Tfr6WEuEe7N582bMmjUL06ZNw9VXX41jx46p8EojS4TXv2nTJsycORNTpkzBLbfcUut54yER7kvQzp07MWDAgCi+uuZJhHuyfPlynHfeeZg2bRqmTZsWds14SYT7UlhYiJtuugnTp0/HZZddhqNHj6rwShsv3vekuLhY+Xdk2rRpuOiiizBkyBB1XmwTxPu+AMDRo0cxd+5cTJs2DfPmzYvp/2/qkwj3Ztu2bZg1axamTJmCm2++WTn9OF5ieU+C5s+fj2XLlinvHz9+HHPnzsWECRPwxz/+EVVVVfU/gTgJrVmzRlx66aXC7XYLj8cjrrrqKvH555+LUaNGiSNHjgiv1yuuu+468cMPP4iKigoxcuRIkZ+fL4QQ4rnnnhOPPfaYEEIIu90uHnzwQTFw4EDxwgsv1Hm9SZMmiS1btgghhHjwwQfFkiVLmvT1sZQo92b06NFi165dQgghPvroI3HLLbeo+KqrJcrrv/jii8W+ffuEEEI89dRT4plnnlHxVTcsUe6LEEI4HA5x6aWXil69eqn3ghshUe7JokWLxOeff67ui22CRLkvV199tfjggw+EEEJ88MEH4q677lLvRTcgUe5JkCRJ4sorrxSfffaZOi+4kRLlvtx3333K2++++6649957VXzVjZMI98bv94tRo0aJdevWCSGE+PLLL8XNN9+s7guvR6zvSX5+vrj55pvFwIEDxccff6w8ftNNN4kvvvhCCCHESy+9JJ588sl6131SVpQzMjLwwAMPwGg0wmAwoHv37sjJyUHnzp3RsWNH6PV6TJkyBV999RW8Xi8WLlyIrKwsAEDv3r2Rl5cHAFi1ahW6dOmCa6+9ts5rHTt2DC6XC4MHDwYAzJw5E1999VWjvz7WEuHeeDwe3HXXXejTp0+t51VbIrx+AFixYgV69OgBr9eLgoICpKSkqPvCG5Ao9wUAFi9ejGuuuUa119pYiXJPfv/9dyxfvhxTp07FfffdF/ffPiTCfSkpKcHu3btx2WWXAQBmzZqFu+++W9XXXZ9EuCehPv74Y1gsFkyZMkWdF9xIiXJf/H4/KisrAQBOpzPiMcSxlgj3prS0FC6XC+eccw4AYPTo0Vi9ejU8Ho+6L74OsbwnAPD5559jzJgxuOSSS5THvF4vNm7ciPHjxwOI/N9XTSdlUO7Zs6fyL0ROTg5WrFgBjUaDjIwM5XMyMzNRUFCAtLQ0XHzxxQAAl8uFf/3rX8r706dPx0033QSdTlfntQoLC8OeNyMjAwUFBY3++lhLhHtjNBoxbdo0APJfYC+99JLyvGpLhNcPAAaDAXv27MGoUaOwYcMGTJo0KdovtUkS5b6sWrUKLpcLEyZMiPZLbLJEuScZGRm444478Omnn6Jt27ZYtGhRtF9qkyTCfcnNzUW7du3wt7/9DVOnTsWdd94Jg8GgwqttnES4J0GSJOGVV17BvffeG82X2CyJcl/uuusu/Pvf/8b555+Pt956CzfeeGO0X2qTJcK9SUtLg9VqxerVqwEAX375JbxeL0pLS6P9chsllvcEAG644QbMmTMn7LHS0lLYbDbo9XoAtf/7iuSkDMpB+/btw3XXXYf58+ejU6dOtT6u0WiUtysqKnDjjTeiT58+mDFjRqOvIYSo93kTVSLcG4/Hg/vuuw8+nw8333xzE19ByyTC6+/duzfWrl2LW2+9Fffcc08TX4E64nlfioqK8Morr+DPf/5z8xavknj/u/LPf/4TgwYNgkajwQ033ICffvqpGa8i+uJ5X3w+H3bu3Ilzzz0Xn332GcaMGYMHHnigeS8kiuL97woA/Pzzz+jatSt69+7dxNWrJ973Zf78+Vi0aBF+/vln/OUvf8Htt98e8fPjIZ73RqPR4IUXXsBrr72G6dOno6KiAq1atYrrD51AbO5JXZqT6U7aoLx582Zcc801uPfeezFjxgxkZWXhxIkTyscLCwuRmZmpvH3FFVegT58+ePzxx+t93oKCAmWzxI033ljreYuKipTnTVSJcG+qqqpwww03wOfz4ZVXXonpf5jxfv1utxsrV65UHp86dSr27NkT5VfZdPG+Lz/88APKysqUTTcAMG3aNOVXpvEQ73tSUVGBf//738rjQgil0hFP8b4vGRkZSEpKwujRowEAkydPxrZt21R4pY0X73sStHLlSkycODHKr6754n1fSkpKcPDgQaXaOH78eBQVFcWtahoq3vcGAPR6Pd577z0sX74cM2bMgN/vR6tWraL/YhspVvekLunp6aisrIQkSQAal+ni/zdyM+Tl5eG2227Ds88+ixEjRgAABg0ahEOHDuHw4cPo0KEDvvjiC8yaNQuSJOGWW27BJZdcgltvvbXB587KysKnn34a9pjJZMLmzZsxdOhQLF++HBdccIEqrysaEuXe3H///ejcuTMWLVoU0wp8Irx+vV6Pv/zlL8jOzsaAAQPw3//+F2eeeaYqr7exEuG+zJkzJ+zXYL179671dbGUCPfEarXijTfewJAhQzBo0CC8//77GDt2rCqvt7ES4b506tQJWVlZ+PHHHzFq1Ch8//336N+/vyqvtzES4Z4E/fbbbwnRWgAkxn1JS0uDyWTCpk2bMGzYMGzevBlJSUlIT09X5TU3ViLcGwB46KGHsHDhQgwcOBBvvfUWJkyYAK02PjXSWN+TSAwGA4YNG4YVK1ZgypQpjcp0J2VQfvPNN+F2u7F48WLlscsuuwyLFy/GHXfcAbfbjVGjRmHChAlYuXIldu7cCUmS8PXXXwMABgwY0OBPJ6GefvppLFiwAFVVVejXrx+uuuqqqL+maEmEe7Nz506sWrUKPXr0wPTp0wHIfUevv/56VF9rJInw+nU6HZ599lk88sgjkCQJWVlZTXpONSTCfUk0iXBPdDodnnvuOSxcuBAulwtdunRRRibFSyLcF0AeI/Xoo4/iqaeegs1mC1tPrCXKPQGA3NxcZGdnR+/FtUAi3BeNRoOXXnoJjz32GFwuF5KSkhJiXGsi3BsAWLhwIR599FE4nU707t07rv8vivU9qcujjz6KBx54AK+88gratm2Lf/zjH/V+vkYkSiMPEREREVECOWl7lImIiIiI1MSgTEREREQUAYMyEREREVEEDMpERERERBEwKBMRERERRcCgTESkouuuuw4lJSW48cYbsX//flWvlZubizvuuEPVaxARnU5OyjnKREQnizVr1gBATOaIHz9+HIcOHVL9OkREpwvOUSYiUsmDDz6IZcuWoVevXti/fz+WLl0Kh8OBf/zjH8jMzMS+fftgsVhwxx134L333sOhQ4cwbtw4PPTQQwCA7777Dq+88gq8Xi/MZjPmz5+PIUOG4MCBA3j44Yfh8XgghMDs2bNx2WWXYcKECSgoKMDw4cPx5ptv4tVXX8XKlSvhdrvhdDoxf/58jB07Fi+++CKOHDmC3NxcFBYWYuDAgRg5ciSWL1+Oo0eP4v7778fkyZPx4osvYt++fThx4gSKi4uVo2RtNluc7ywRUYwIIiJSTa9evURxcbEYPXq02LZtm1i/fr3o27ev2LFjhxBCiOuvv15ceumlwu12i+LiYtG/f3+Rn58vDh06JCZPnixKSkqEEELs3btXjBw5UlRVVYkHH3xQvPbaa0IIIQoLC8Xdd98tJEkS69evF5MmTRJCCHH06FExb9484XQ6hRBCfPHFF2Ly5MlCCCFeeOEFMXr0aGG324XT6RTDhw8Xf//734UQQnz77bdi3LhxyuddcMEFoqioSEiSJP70pz+JxYsXx+7mERHFGVsviIhirEOHDujXrx8AoFOnTkhOTobRaER6ejqSkpJQXl6OjRs3orCwENdcc43ydRqNBkeOHMHYsWMxf/58bNu2DSNGjMCCBQug1YZvOWnfvj2eeOIJfP755zh8+DC2bt2Kqqoq5ePnnnsukpOTAchHzJ9//vnKesrKypTPmzBhAtq0aQMAmD17Nv72t79h/vz5atwWIqKEw818REQxZjQaw97X62vXLPx+P0aMGIFPP/1U+Wfp0qXo2bMnRo8eja+//hqXXHIJdu3ahSlTpuDIkSNhX79jxw5cdtllqKysxMiRI3HDDTc0eQ0AoNPpwtZUM5ATEZ3K+DceEZGKdDodfD5fk7/unHPOwZo1a3DgwAEAwI8//oipU6fC7Xbj3nvvxYoVKzBp0iQ8+uijsNlsyMvLg06ng9frBQBs3LgRAwYMwLXXXouzzjoLq1atgiRJTV7HqlWrUFFRAb/fj6VLl2L06NFNfg4iopMVWy+IiFQ0duxYXHHFFWFtD43Rs2dPLFq0CH/6058ghIBer8crr7wCq9WKW2+9FQ8//DD+7//+DzqdDhdffDHOOuss2O126HQ6zJ49G6+++iq++eYbTJw4EQaDASNGjEB5eTkqKyubtI42bdrgxhtvRGlpKYYPH45bbrmlSV9PRHQy49QLIiKK6MUXX0RpaSkeeeSReC+FiCgu2HpBRERERBQBK8pERERERBGwokxEREREFAGDMhERERFRBAzKREREREQRMCgTEREREUXAoExEREREFAGDMhERERFRBP8P+m0j92uOmFUAAAAASUVORK5CYII=\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": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "number of unique addresses: 6749\n" - ] - } - ], - "source": [ - "print(\"number of unique addresses:\", transfers[\"nft_address\"].nunique())" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# num_df = (transfers[[\"nft_address\", \"transaction_value\", \"timestamp\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 192, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "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", - "ax = sns.displot(from_series, stat=\"count\", bins=200, log_scale=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#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()\n", - "#summ all same number of transactions over all addresses\n", - "# num_df = num_df.value_counts(normalize=False, sort=True)\n", - "# to_series = num_df.rename(\"Number of Transactions to an address\")\n", - "ax = sns.displot(to_series, stat=\"probability\", bins=12, log_scale=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "to_address\n", - "0x0000000000000000000000000000000000000000 118598\n", - "0x0000000000000000000000000000000000000001 7304\n", - "0x0000000000000000000000000000000000000069 1\n", - "0x00000000000000000000000000000000000000ff 1\n", - "0x0000000000000000000000000000000000001388 1\n", - " ... \n", - "0xfff98e0Af7Dfa591f97a768dcd71C39fA6CC7C16 2\n", - "0xfffAAD6BA8F5Cb255111EE0bB8E06e2766cb8e49 86\n", - "0xfffFa8f60d2eC6a559ef3617576ED28Bc397D360 4\n", - "0xfffaA912b2740381eB753A03E9c13c661CeFC0ed 36\n", - "0xffff0C5C628171f26B06322Db50dA0A6D1C8DD5a 3\n", - "Name: to_address, Length: 420342, dtype: int64" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "to_series" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "278519" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from_series.size" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "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')\n", - "# df = df.fillna(0.00001)\n", - "# from_series.to_frame().join(to_series)\n", - "df=df[df[\"to_count\"]<10e3]\n", - "df=df[df[\"from_count\"]<10e3]" - ] - }, - { - "cell_type": "code", - "execution_count": 171, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax = sns.displot(df, stat=\"count\", bins=12, log_scale=True)#multiple='dodge'" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax = sns.displot(df, log_scale=True, kind=\"kde\")" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "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": 153, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 153, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax = sns.histplot(df_small, multiple=\"dodge\")\n", - "ax.fill(True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "plt.bar(df.index,df.to_count,4)" - ] - }, - { - "cell_type": "code", - "execution_count": 187, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n, bins, patches = plt.hist(df['to_count'], density=False, facecolor='g', alpha=0.75, log=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 182, - "metadata": {}, - "outputs": [], - "source": [ - "max_value = pd.to_numeric(transfers[\"transaction_value\"], errors='coerce')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 180, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "token_id\n", - "0 1.000000e+20\n", - "1 3.000000e+20\n", - "10 3.200000e+19\n", - "100 4.114000e+19\n", - "Name: transaction_value, dtype: float64" - ] - }, - "execution_count": 180, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "max_value[\"token_id\"]=transfers[\"token_id\"]\n", - "max_value.groupby(transfers[\"token_id\"]).max()\n", - "max_value.head(4)" - ] - }, - { - "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/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb new file mode 100644 index 00000000..1c522f56 --- /dev/null +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -0,0 +1,884 @@ +{ + "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": [ + "checkpoint = pd.read_sql_query(\"SELECT * FROM checkpoint\", conTXs)\n", + "mints = pd.read_sql_query(\"SELECT * FROM mints\", conTXs)\n", + "nfts = pd.read_sql_query(\"SELECT * FROM nfts\", conTXs)\n", + "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sql\n", + "0 CREATE TABLE nfts\\n (\\n address TEXT...\n", + "1 CREATE TABLE checkpoint\\n (\\n event_...\n", + "2 CREATE TABLE mints\\n (\\n event_id TE...\n", + "3 CREATE TABLE transfers\\n (\\n event_i...\n", + "4 CREATE TABLE current_owners(\\n nft_address TE...\n", + "5 CREATE TABLE current_market_values(\\n nft_add...\n", + "6 CREATE TABLE market_values_distribution(\\n ad...\n" + ] + } + ], + "source": [ + "stolbiki = pd.read_sql_query(\"SELECT sql FROM sqlite_master where type='table'\", conTXs) \n", + "print(stolbiki)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + "
event_idtransaction_hashblock_numbernft_addresstoken_idfrom_addressto_addresstransaction_valuetimestamp
0ce7b6ba0-218f-40c7-8d8c-4e3bfc822a410x804cee46e672b17b477658b99c25c8b75f31553278ad...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62057287012905433418913509099434869470284131894829...0x79A8b5Fcc051c843DFCB753eE38d113675E5367D0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f0.01609460206
1c81d8767-a523-410e-9f4a-21a25f8e906f0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62051225542446027558019364995253890488984869511709...0x2c338BAf69A57A17E69dB86933310e92f64ab69d0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f0.01609460206
2d9494633-61fd-4cd6-bd42-e736e09829560x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e...115650440x6Fa769EED284a94A73C15299e1D3719B29Ae2F52510600260x9503DE24f4210dA79c5e5BCCD198B2727387a5190x8B36486EA2E0b70A505D92d30c31CC3197ba57070.01609459570
3801c3aae-9b72-4a4b-b40b-1cf93308eeea0xe74d08ee2cbe4b6b873258462ec5523999433569df66...115650420xB2D6fb1Dc231F97F8cC89467B52F7C4F784840444265098311422702060752376543910232329671779809...0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e60x00000000000000000000000000000000000000000.01609459545
\n", + "
" + ], + "text/plain": [ + " event_id \\\n", + "0 ce7b6ba0-218f-40c7-8d8c-4e3bfc822a41 \n", + "1 c81d8767-a523-410e-9f4a-21a25f8e906f \n", + "2 d9494633-61fd-4cd6-bd42-e736e0982956 \n", + "3 801c3aae-9b72-4a4b-b40b-1cf93308eeea \n", + "\n", + " transaction_hash block_number \\\n", + "0 0x804cee46e672b17b477658b99c25c8b75f31553278ad... 11565099 \n", + "1 0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46... 11565099 \n", + "2 0x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e... 11565044 \n", + "3 0xe74d08ee2cbe4b6b873258462ec5523999433569df66... 11565042 \n", + "\n", + " nft_address \\\n", + "0 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "1 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", + "2 0x6Fa769EED284a94A73C15299e1D3719B29Ae2F52 \n", + "3 0xB2D6fb1Dc231F97F8cC89467B52F7C4F78484044 \n", + "\n", + " token_id \\\n", + "0 7287012905433418913509099434869470284131894829... \n", + "1 1225542446027558019364995253890488984869511709... \n", + "2 51060026 \n", + "3 4265098311422702060752376543910232329671779809... \n", + "\n", + " from_address \\\n", + "0 0x79A8b5Fcc051c843DFCB753eE38d113675E5367D \n", + "1 0x2c338BAf69A57A17E69dB86933310e92f64ab69d \n", + "2 0x9503DE24f4210dA79c5e5BCCD198B2727387a519 \n", + "3 0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e6 \n", + "\n", + " to_address transaction_value timestamp \n", + "0 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0.0 1609460206 \n", + "1 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0.0 1609460206 \n", + "2 0x8B36486EA2E0b70A505D92d30c31CC3197ba5707 0.0 1609459570 \n", + "3 0x0000000000000000000000000000000000000000 0.0 1609459545 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transfers.head(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", + "\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": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'NFT transfers value over time')" + ] + }, + "execution_count": 10, + "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": 11, + "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": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# num_df = (transfers[[\"nft_address\", \"transaction_value\", \"timestamp\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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", + "ax = sns.displot(from_series, stat=\"count\", bins=200, log_scale=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#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()\n", + "#summ all same number of transactions over all addresses\n", + "# num_df = num_df.value_counts(normalize=False, sort=True)\n", + "# to_series = num_df.rename(\"Number of Transactions to an address\")\n", + "ax = sns.displot(to_series, stat=\"probability\", bins=12, log_scale=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_address\n", + "0x0000000000000000000000000000000000000000 119978\n", + "0x0000000000000000000000000000000000000001 7307\n", + "0x0000000000000000000000000000000000000069 1\n", + "0x00000000000000000000000000000000000000ff 1\n", + "0x0000000000000000000000000000000000001388 1\n", + " ... \n", + "0xfff98e0Af7Dfa591f97a768dcd71C39fA6CC7C16 2\n", + "0xfffAAD6BA8F5Cb255111EE0bB8E06e2766cb8e49 89\n", + "0xfffFa8f60d2eC6a559ef3617576ED28Bc397D360 4\n", + "0xfffaA912b2740381eB753A03E9c13c661CeFC0ed 36\n", + "0xffff0C5C628171f26B06322Db50dA0A6D1C8DD5a 3\n", + "Name: to_address, Length: 422045, dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "to_series" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "279748" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from_series.size" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "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')\n", + "# df = df.fillna(0.00001)\n", + "# from_series.to_frame().join(to_series)\n", + "# df=df[df[\"to_count\"]<10e3]\n", + "# df=df[df[\"from_count\"]<10e3]" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "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": 20, + "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": 102, + "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": 132, + "metadata": {}, + "outputs": [], + "source": [ + "whales_tx=df[df[\"from_count\"]>60000]\n", + "whales_rx=df[df[\"to_count\"]>60000]" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "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": 133, + "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": 134, + "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": 134, + "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)\n", + "\n", + "[0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA](https://etherscan.io/address/0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA) not a contract!" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "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": 137, + "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": 137, + "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": 138, + "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": 138, + "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": 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 +} From c9bef0fa4bd822b9c62e4fa3c530cdc9c0fcb70d Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 15:12:23 +0200 Subject: [PATCH 41/87] cleanup --- datasets/nfts/notebooks/transfers_count.ipynb | 109 ++---------------- 1 file changed, 9 insertions(+), 100 deletions(-) diff --git a/datasets/nfts/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb index 1c522f56..02b84551 100644 --- a/datasets/nfts/notebooks/transfers_count.ipynb +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -278,121 +278,30 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 140, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "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", - "ax = sns.displot(from_series, stat=\"count\", bins=200, log_scale=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ "#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()\n", - "#summ all same number of transactions over all addresses\n", - "# num_df = num_df.value_counts(normalize=False, sort=True)\n", - "# to_series = num_df.rename(\"Number of Transactions to an address\")\n", - "ax = sns.displot(to_series, stat=\"probability\", bins=12, log_scale=True)" + "to_series = transfers[\"to_address\"].groupby(transfers[\"to_address\"]).size()" ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "to_address\n", - "0x0000000000000000000000000000000000000000 119978\n", - "0x0000000000000000000000000000000000000001 7307\n", - "0x0000000000000000000000000000000000000069 1\n", - "0x00000000000000000000000000000000000000ff 1\n", - "0x0000000000000000000000000000000000001388 1\n", - " ... \n", - "0xfff98e0Af7Dfa591f97a768dcd71C39fA6CC7C16 2\n", - "0xfffAAD6BA8F5Cb255111EE0bB8E06e2766cb8e49 89\n", - "0xfffFa8f60d2eC6a559ef3617576ED28Bc397D360 4\n", - "0xfffaA912b2740381eB753A03E9c13c661CeFC0ed 36\n", - "0xffff0C5C628171f26B06322Db50dA0A6D1C8DD5a 3\n", - "Name: to_address, Length: 422045, dtype: int64" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "to_series" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "279748" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from_series.size" - ] - }, - { - "cell_type": "code", - "execution_count": 42, + "execution_count": 141, "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')\n", - "# df = df.fillna(0.00001)\n", - "# from_series.to_frame().join(to_series)\n", - "# df=df[df[\"to_count\"]<10e3]\n", - "# df=df[df[\"from_count\"]<10e3]" + "df = df.join(from_series.rename('from_count'), how='outer')" ] }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 142, "metadata": {}, "outputs": [ { @@ -438,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 143, "metadata": {}, "outputs": [], "source": [ @@ -448,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 144, "metadata": {}, "outputs": [ { @@ -494,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": 132, + "execution_count": 145, "metadata": {}, "outputs": [], "source": [ From 9fc44de4b61f6eaa4355d4f88c7aa75899578146 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 15:13:21 +0200 Subject: [PATCH 42/87] cleanup --- datasets/nfts/notebooks/transfers_count.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datasets/nfts/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb index 02b84551..5af04542 100644 --- a/datasets/nfts/notebooks/transfers_count.ipynb +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -555,9 +555,9 @@ "source": [ "### Whales TX info:\n", "\n", - "[0x283Af0B28c62C092C9727F1Ee09c02CA627EB7F5](https://etherscan.io/address/0x283Af0B28c62C092C9727F1Ee09c02CA627EB7F5) / [creator](https://etherscan.io/address/0x4fe4e666be5752f1fdd210f4ab5de2cc26e3e0e8)\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!" + "[0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA](https://etherscan.io/address/0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA) not a contract! / info: `???`" ] }, { From 531b98f74d430b35ffa5f6b0f072a0f9be4518e5 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Thu, 7 Oct 2021 18:06:49 +0300 Subject: [PATCH 43/87] Add mints and transfers connections. --- datasets/nfts/nfts/cli.py | 4 ++- datasets/nfts/nfts/derive.py | 69 ++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+), 1 deletion(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index d5757c02..8187f969 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -19,6 +19,7 @@ from .derive import ( qurtile_generating, mint_holding_times, transfer_holding_times, + transfers_mints_connection_table, ) from .materialize import create_dataset @@ -33,6 +34,7 @@ derive_functions = { "current_values_distribution": current_values_distribution, "transfer_statistics_by_address": transfer_statistics_by_address, # "qurtile_generating": qurtile_generating, + "transfers_mints_connection_table": transfers_mints_connection_table, "mint_holding_times": mint_holding_times, "transfer_holding_times": transfer_holding_times, } @@ -55,7 +57,7 @@ def handle_filter_data(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.source)) as source_conn: - if args.target == args.source: + if args.target == args.source and args.source is not None: sqlite_path = f"{args.target}.dump" else: sqlite_path = args.target diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index e36e52d6..0f5c3de8 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -286,6 +286,75 @@ def qurtile_generating(conn: sqlite3.Connection): 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 transfers_mints as + select + transfers.event_id, + mints.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: current_values_distribution") + logger.error(e) + + def mint_holding_times(conn: sqlite3.Connection): drop_mints_holding_table = "DROP TABLE IF EXISTS mint_holding_times;" From 7c4b1625f3541023149095a7aff2641361ca6395 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 18:44:21 +0200 Subject: [PATCH 44/87] improvements --- .../notebooks/transfers_count-Copy1.ipynb | 650 ++++++++++++++++++ datasets/nfts/notebooks/transfers_count.ipynb | 335 ++++----- 2 files changed, 792 insertions(+), 193 deletions(-) create mode 100644 datasets/nfts/notebooks/transfers_count-Copy1.ipynb diff --git a/datasets/nfts/notebooks/transfers_count-Copy1.ipynb b/datasets/nfts/notebooks/transfers_count-Copy1.ipynb new file mode 100644 index 00000000..2923bdf9 --- /dev/null +++ b/datasets/nfts/notebooks/transfers_count-Copy1.ipynb @@ -0,0 +1,650 @@ +{ + "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": 146, + "metadata": {}, + "outputs": [], + "source": [ + "conTXs = sqlite3.connect('../../../../../../datasets/nfts.sqlite')" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [], + "source": [ + "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'NFT transfers value over time')" + ] + }, + "execution_count": 10, + "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": 11, + "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": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# num_df = (transfers[[\"nft_address\", \"transaction_value\", \"timestamp\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "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": 141, + "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": 142, + "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": 143, + "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": 144, + "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": 145, + "metadata": {}, + "outputs": [], + "source": [ + "whales_tx=df[df[\"from_count\"]>60000]\n", + "whales_rx=df[df[\"to_count\"]>60000]" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "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": 133, + "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": 134, + "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": 134, + "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": 136, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABXAAAAFjCAYAAACUgiOIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABVH0lEQVR4nO3dd3yN9///8WeWGaMqSWt+zGgRs609oqgRo2aNKC2tqlhFUtSe1WpJ1Wi/NUqtEqufUFRbo5QqpSja2JIQK4Ss9+8PP+cjkjhBT3KcPO63m9st1zjXeV3vc8n18nSd63IyxhgBAAAAAAAAAOyOc0YXAAAAAAAAAABIGQEuAAAAAAAAANgpAlwAAAAAAAAAsFMEuAAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwAUAAE8sX19ftWzZUvHx8Unm37hxQ97e3tq1a5dN3jcwMFABAQE22fa/4ebNm3rrrbdUvnx5derUKdnylStXytvbW6GhocmWTZ48WV27drVMe3t7p/jH19dXZ86cSXX53T8pOXLkiH755Zd/b4fT0f21e3t764cffsjAiuyHtb93tv57CQAA4KhcM7oAAACAx3HkyBHNmzdPb775ZkaXYjc2bdqkHTt26JtvvpGnp2eq640bN041a9ZUrly5Hri9KVOmqEaNGknmubi4KE+ePNq2bZtl3ogRI5QtWzYNGzbsgdt755131KNHD1WrVi0Ne2Nf7q9927ZtypMnTwZXBQAAAEfGFbgAAOCJVrBgQQUHB+vMmTMZXYrduH79uvLnz69y5cqlGuDmyJFDCQkJ+uijj6xuL3fu3PLw8EjyJ1++fHJxcUkyL0uWLMqWLVuSeY7u7n4DAAAAtkKACwAAnmhdu3ZVgQIFNGrUqAeuM3ny5CTz7v3qe2BgoCZOnKigoCBVrFhRvr6++vHHHxUSEqJ69eqpatWqGjFihIwxltfHxMRo0KBB8vHxka+vr5YvX55k+yEhIWrcuLEqVKig1q1ba+vWrZZlgYGBeu+999SuXTu9+OKL2rFjh/bs2aO2bdvKx8dHtWrV0pQpU5SQkJDi/hhj9PXXX6tx48YqX768WrZsqR9//FGSNGPGDI0ZM0bnzp2Tt7e3Vq5cmeI2smTJosDAQC1ZskT79u1Ldez+bV27dtXZs2c1duxYde3a1XIbhpkzZ+rFF19Uz549JUlr1qyRn5+fypUrp8qVK6t37966ePGiJGnXrl166aWXFBISIl9fX/n4+Khnz56W5fHx8Ro7dqxq1qwpHx8fvfbaazpw4IClhp9//lnt27eXj4+PKlSoIH9/f/3zzz+W5UeOHNHrr7+uSpUqqW7dupo9e3aKtUtJj6PY2FgFBwfL19dX5cuX12uvvab9+/cn2ffp06erd+/e8vHxUd26dZMcNw9zDAQGBuqDDz7QoEGDVKFCBTVs2FCrV69Oss7DHoP3u3jxogYNGqRq1aqpXLlyevnll7VixQrL8piYGA0bNkxVqlRR7dq19d///jfJ660t9/X11ZQpU1SvXj3Vq1dPV69eVWRkpPr166dKlSqpVq1aGjZsmK5fv255zdKlS9WwYUOVK1dOr7zyikJCQizLNm3apObNm6t8+fLy9fXVF198keLYAQAAPGkIcAEAwBPNzc1NY8aM0bZt27R+/fpH3s6iRYtUokQJrVmzRuXLl9egQYO0cuVKzZ49W6NHj9a3336rLVu2WNb/6aef9NRTT2nVqlXq0aOHRo4cqd9++03SnYBw/Pjx6tevn9auXasOHTooICAgSVC6bt06de7cWfPnz1fFihXVp08fVatWTd99950+/PBDLV++PNXwdc6cOfr0008VEBCgNWvW6OWXX1bv3r115MgR9ejRQwMHDtQzzzyjbdu2qWnTpqnuc8uWLVW9enV98MEHiouLe+SxexgzZszQM888o4EDB2rGjBmW+T/99JOWLVumIUOG6LffftP777+vN954Qxs2bNBnn32mw4cPa9asWZb1r1+/rqVLl2rGjBmaP3++Dh48aFn+9ddfa/Pmzfrss8+0fv16/ec//1FAQICMMTpz5ox69+6tV155RevXr9f8+fN19epVTZkyRZIUFRWlbt26ydPTU8uXL9eYMWM0Z84crVixItXa7xo3bpyWL1+ukSNHKiQkRKVKlVL37t0VERFhWWfu3LmqXbu21q9fr4YNG2r06NG6ePGiEhISHuoYkO7cy9jd3V0rV65U586dFRgYaLk/78Meg5UqVUq2/SFDhigqKkrz5s3T+vXr5evrq1GjRlmC8tGjR2vv3r2aO3eugoODtWDBgiSvt7ZckmVcZ8yYoTx58qhv376S7gS1n3/+uU6dOqUBAwZIkv7880+NGjVKgwYN0oYNG+Tv76/AwECFhYXp0qVL6t+/vzp06KDQ0FANGTJEn3zyiXbu3Jnq+AEAADwpuAcuAAB44lWtWlXt2rXThAkTVLt2bbm4uDz0NooVK2a5j+6rr76q0NBQBQUFWR7GNXPmTB0/flwNGjSQJBUvXlzDhg2Tk5OTSpQooV27dmnx4sWqXLmyZs+erTfeeMMSnhYpUkSHDh3SV199ZQnKihUrplatWkmSrly5oqtXryp//vwqWLCgChUqpC+//FJPP/10sjqNMfrqq6/09ttvq1mzZpKkvn37av/+/Zo7d64++ugj5cyZ03J7A2tGjx6t5s2b6//+7//01ltvpbhOv379ko3p+vXrVaBAgTSMbFJ58+aVi4uLcubMqbx58yo6OlqS5O/vr//85z+SpEOHDmns2LGW8SlYsKAaNGigY8eOWbaTkJCgwMBAlS1bVpLUokULy9WuZ86cUdasWVWgQAF5enoqKChIf/75pxITExUfH6+hQ4darqAtXLiwWrZsqcWLF0uS/vvf/8rNzU3jxo1TlixZVLJkSY0cOVKurq7Jar/XtWvXtGLFCn388ceqW7euJGnUqFHau3evFi1aZAkhX3rpJcuD5fr376+FCxfqyJEjKleuXJqPgbsKFiyokSNHytnZWSVKlNDu3bu1ZMkSVatW7aGPwZTUq1dP9evXV+HChSVJvXv31vz58xUWFqZs2bJp3bp1Cg4OVuXKlSVJY8aMUYcOHSRJ0dHRD1x+V5MmTVS+fHlJ0i+//KKjR49qwYIFlttSTJ06VXXq1NGxY8d09uxZOTk56dlnn1XBggXVqVMnFS1aVPny5dOZM2cUFxcnT09PFSxYUAULFlT+/PktxxQAAMCTjAAXAAA4hPfee09btmzRhx9+qMDAwId+/d2QSpKyZcuWbF7WrFkVGxtrmfbx8ZGTk5NlumzZspaviB87dkz79++3fPVekuLi4lSsWLEU3y9v3rzy9/fXxIkTNXfuXNWpU0dNmzaVj49PsjqjoqJ0+fJlVaxYMcn8KlWqKDQ09GF3W0WKFFGfPn00c+ZMNWnSJMV1hg8frpdeeinJvAc9HO1RFCpUyPJz2bJllTNnTn322Wc6ceKETpw4oWPHjqlKlSpJXlO0aFHLz+7u7pariF977TWFhoaqXr16qlChgurXr682bdrIxcVF//nPf5Q9e3bNnTtXx44d0z///KPDhw9b9uf48ePy9vZOcl/bFi1aWK0/LCxMCQkJSa5kdXZ2VqVKlZIEz/cGiu7u7pLu3PLhYY6BuypVqiRn5/99oc7Hx0dr166V9PDHYEo6deqk0NBQzZs3T2FhYfrzzz8l3QnP//77b8XFxen555+3rF+uXDlLPdaWp1TD8ePHFRMTk+xYu7u9unXrysfHR+3bt1fx4sVVr149tW7dWrlz59Zzzz2nRo0aKSAgQAULFlTdunXVokUL5c+f/4H7CAAA8CQgwAUAAA4hT548ev/99zVo0CA1bNjwgevGx8cnm+fqmrwtujegvd/9QVRiYqLc3Nwk3Qm4Bg0apPr166f6HndD4rvef/99derUST/88IO2bt2qXr16qU+fPnr33XeTrJc1a9YU60lMTFRiYmKq9T5Ijx49tG7dOo0cOVJlypRJttzDwyNJWGoL947Hjh079NZbb6lp06aqWrWq/P39tW7dOh09ejTJa+6O911371FcokQJbdmyRT///LN++uknLViwQF9//bWWL1+uK1eu6LXXXlONGjX0wgsvqG3bttq/f7+++eYbyzbvvddxWqX2ILP7P5f7a7637rQeA3fdf1V0QkKC5bh8lGPw/rrffPNNXbhwQc2aNVOHDh1UsmRJS8h/9+/GvWPl4uJiqcna8pRqiI+PV4ECBfTVV18lq+fpp59WtmzZ9M0332jfvn368ccftWXLFn399deaNWuWatasqRkzZujIkSOW8VuyZInGjx+vV199NdX9BAAAeBJwD1wAAOAwmjVrplq1amn06NFJ5mfJkkU3btywTJ8+ffqx3+v+MPH3339XyZIlJd0JEM+ePauiRYta/qxbty7Ve/RevHhRo0ePVv78+dW9e3fNnz9fvXr1SnF9d3d3eXp6Jnvw2L59+1S8ePFH2pe79xHeuXOnNm7c+Ejb+DctWLBATZo00eTJk9WpUydVrFhRJ0+eTHOwGhISou+++04NGjTQ6NGjtWHDBkVFRWnv3r1atmyZnnvuOQUHB6tbt2568cUXdfbsWcu2//Of/+ivv/5Kck/g4OBg9evX74HvWbRoUbm5uVnugyzdCS9///33NH0uD3MM3HX3iti7Dhw4YAngH/YYTGnbO3fu1Ny5c9W3b181atTIcrsLY4yKFSsmNze3JA+HO3r0qGXcrC1PSYkSJRQREaGcOXNaanZ1ddXEiRMVFRWlffv2acaMGapcubIGDBigtWvXqmzZstq4caNOnDihcePGqUyZMurdu7eWLl2qpk2b6rvvvkvT/gIAANgzrsAFAAAOZdSoUWrevHmSeeXKldPy5cvVsmVL5cyZU5MmTUr1ism0Onz4sKZMmaI2bdpoy5Yt2rZtm0JCQiRJb775pgYOHKjixYurZs2a2r59uz777DNNnTo1xW3lyZNHmzZt0q1bt9SrVy/FxMRo27ZtqX59vlevXpo+fboKFCig559/XuvWrdP27du1cOHCR96fSpUqqWPHjvrmm28e6d62DyNnzpw6ceKELl26lOJyT09P7d69W4cOHVKOHDkUEhKin376SRUqVEjT9m/cuKHp06frqaeeUokSJfTjjz/KGKPnnntOZ86c0Xfffac9e/bIy8tLmzdv1vLlyy33tG3RooVmzJih0aNHq0ePHjp9+rTmz5+voKCgZLXfe3/a7Nmzq0uXLpo0aZJy5MihQoUKaeHChTp79qzat29vteaHPQakOyHrtGnT1KpVK8sVx0uWLJH08Mfg/Tw8POTi4qL169fLz89PYWFhGjdunCQpNjZW7u7uateunSZOnKjcuXPL3d1do0ePtlx5a215SmrWrKlSpUppwIABGjp0qFxcXDR69GjduHFDBQsW1M2bNzV79mzlzZtXvr6+CgsL04kTJ9SuXTvlyZNH3377rbJnz6727dsrMjJSv//+u1q2bJmm/QUAALBnBLgAAMChFCpUSO+++64+/PBDy7wePXro77//Vo8ePfTUU08pICBAZ8+efaz3adGihU6ePKlWrVqpQIECmj59ukqXLi1JatiwoUaMGKEvv/xS48ePV8GCBTVmzBjLA6Xu5+bmpjlz5mjChAl69dVX5erqKl9fXw0fPjzF9bt06aKbN29qypQpunTpkkqXLq1Zs2apatWqj7VPgwYN0ubNmx9rG2nh7++vSZMmad++fQoODk62PCAgQO+//766dOmirFmzqlKlSho6dKiCg4N1+/Ztq9vv1KmTLl68qJEjR+rixYsqVqyYPv30UxUrVkxdu3bV0aNH9fbbb8vJyUnPP/+8Ro0apREjRujChQt65plnNHfuXE2YMEEtW7ZU/vz59c4771i+hn9v7XcD+7sGDhwoJycnBQUF6caNGypfvrwWLFiQpgdpPewxIEm1atXSyZMn1bJlSxUpUkSfffaZJfB92GPwfl5eXhozZoxmzpypmTNnWh4atnz5ch06dEh16tRRUFCQXFxc1LdvXzk7OysgIECHDx+2bMPa8vs5Ozvr888/1/jx4+Xv7y9nZ2dVr15dn3zyiVxcXFSmTBl9+OGHmjlzpj788EPly5dP3bt3V5s2bSRJM2fO1NSpU7VgwQLlzJlTzZo109tvv52m/QUAALBnTuZRbvIFAAAAIMMEBgbq5s2bmj59ekaXAgAAABvjHrgAAAAAAAAAYKcIcAEAAAAAAADATnELBQAAAAAAAACwU1yBCwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUwS4AAAAAAAAAGCnCHABAAAAAAAAwE4R4AIAAAAAAACAnSLABfCvO3PmjLy9vbV8+fIk87/88ksFBgZKklauXKkqVaqoZcuWSf5s3rxZAQEBlmlvb2/5+fmpZcuW6tq1a5re/8SJE+rVq5f8/Pzk5+enLl26aM+ePY+1T1u3btWnn36a4rKVK1eqXr16euONNx7rPezNvZ/X/Zo3b65du3alc0UAAACZT0b31rb06aefKiQk5F/ZVmhoaKr71KNHD0VFRf0r72MLb731llauXJlsflRUlLy9vTOgIgD2xjWjCwDgmJydnTV58mRVrVpVxYoVS3GdqlWravbs2cnmN2jQwPKzt7e35s+fr3z58qX5vQMCAtS/f381bNhQkvTrr7/qrbfe0ubNm5U3b96H25H/748//tDVq1dTXBYSEqIBAwaoZcuWj7RtAAAA4EEysre2pX79+qXL+2zfvj1d3gcAbIUAF4BNZMuWTd27d9egQYO0ZMkSZcmS5bG3eeLECQ0bNkyxsbEyxqht27bq3LlzsvUiIyN18+ZNy/QLL7ygTz75RC4uLpKk3377TVOnTlVMTIycnJzUt29f1a9fXytXrtT3338vZ2dnnTx5Um5ubpo8ebJiYmK0ZMkSJSQkKFeuXBowYIBl2xMmTNAff/yhM2fO6PLlyzpy5IiuXLmi06dPq169enr77bc1evRoHTlyRE5OTqpdu7YGDhwoV1dXlS9fXq+//rq2bt2q6OhoDR48WKGhofrrr7/k6empWbNmKUeOHEn27Z9//tGYMWN08+ZNRUREqEyZMvrkk0+UNWtWlS9fXr169dL27dsVEREhf39/vf7668nGZ8WKFVq6dKni4uJ09epV9ezZU506dVJcXJzGjRunHTt26Omnn9bTTz+tXLlySZKOHz+u999/XzExMSpevLhlfM+cOaPOnTurRIkSOnv2rBYuXKgzZ86kOL6RkZEaOnSoLl++LEmqW7eu+vfvn+p8AAAA3JFRvfXD9HqSNHv2bK1atUqurq4qWrSoJk2apFy5cmn58uX65ptvlJiYqLx582rEiBEqUaKEAgMDVapUKbm7u2vLli2WAPrEiROWPjksLEzjx4/XlStXlJCQoK5du6pt27aS7lzBu3btWuXNm1dFixZNcT+DgoIkSd26ddOcOXMUHR2tMWPG6MqVK3JyclKPHj3UqlWrZK/74YcfNHv2bMXGxioqKkqtWrVS//79tWvXLk2bNk2FCxfWsWPHFBsbqw8++EDVqlVL8vrExERNmDBB+/fv140bN2SM0bhx41SlShWFh4crMDBQERERKlCggC5dumR53caNGzVt2jRlz55d5cqVs8xfuXKlVqxYoZiYGLm7u2vhwoWpjuuePXs0adIkJSYmSrpzhW/jxo1TnQ/gCWAA4F92+vRpU7FiRZOQkGA6depkJk2aZIwx5osvvjBDhw41xhjz7bffmsqVK5sWLVpY/owYMSLZtkqXLm0uXbpkjDEmKCjIzJ492xhjTEREhOnfv79JSEhI9pq1a9eaqlWrmpo1a5qAgACzcOFCc/nyZWOMMVeuXDGNGjUyp0+fNsYYc+HCBVOnTh1z9uxZ8+2335oqVaqY8+fPG2OMGTNmjBkyZIgxxpjp06eb0aNHp7i/Xbp0Mf/973+NMcYMHTrUdOvWzbJsyJAhZuzYsSYxMdHcvn3b9OjRw7IPpUuXNvPnzzfGGDN79mxTqVIlc+HCBZOQkGBat25t1qxZk+y9Jk2aZEJCQowxxsTGxprmzZub0NBQy/YWLlxojDHmjz/+MOXKlTO3bt1K8vro6GjTvn17ExUVZYwxZt++faZixYrGGGPmzZtn/P39ze3bt82NGzdM69atLZ9Xy5YtzbJly4wxxuzZs8d4e3ubX375xZw+fdqULl3a/Prrr1bHNzg42PIZ37hxw/Tv399cu3Yt1fkAAADI2N76YXq9TZs2mUaNGpkrV64YY4yZMGGCmTlzptm1a5fp1KmTuXnzpjHGmJ9//tk0adLEGHOnd/7iiy/M9evXTZUqVUxERIQxxpgpU6aYjz/+2MTFxZmmTZuagwcPGmOMuXbtmmnSpInZt2+f+f77703Tpk3N9evXTVxcnOnVq5fp0qVLimN4d7/j4uJMgwYNzIYNGyz1165d2/z2229J1k9MTDRdunQx//zzj2W95557zly6dMn88ssv5rnnnjN//vmnMcaYL7/80nTu3DnZe/7222+mb9++ljGdPXu2eeutt4wxxrzzzjtm2rRpxhhjwsLCTMWKFc23335rIiMjTZUqVcyxY8eMMcbMmjXLlC5d2vIZv/DCC+b69evGGPPAcfX39zfr1q0zxhhz+PBhM2rUqAfOB2D/uAIXgM04Ozvrww8/VOvWrVWrVq1ky1P7mldqGjZsqKFDh+rAgQOqXr26hg8fLmfn5Lfybt68uRo2bKi9e/fq119/1bfffqvPP/9cS5cu1YkTJxQZGak+ffpY1ndyctLRo0clSWXLltUzzzwjSXr++ef1/fffP+xuq0qVKpaff/rpJ33zzTdycnJSlixZ1LFjR82fP1+9evWSJMv/eBcpUkSlS5eWl5eXJKlQoUIp3rJh8ODB2r59u+bOnauwsDBFREQkudr47lfkypYtq9jYWN28eVNZs2a1LM+ZM6dmzZqlH3/8UWFhYTpy5Ijl9Tt37lTz5s2VJUsWZcmSRX5+fjp69KguX76so0ePWq5MqFKlikqVKmXZpqurqypWrChJ+v3331Md39q1a6tXr146f/68atSooUGDBilXrlypzgcAAMD/ZFRvndZeb+fOnXrllVeUJ08eSf+78nXKlCk6efKkOnbsaHnN1atXdeXKFcu0u7u7GjdurDVr1uj111/XmjVrtHjxYoWFhenUqVN6//33LeveunVLf/75p06cOKGGDRvK3d1dktSmTRstXLjwgfscFham27dvq1GjRpIkLy8vNWrUSD///LMqVaqUZJ9mzZqlrVu3at26dTpx4oSMMYqJiZEkFShQQM8995ykO/9mWLVqVbL3qlSpkvLkyaMlS5bo9OnT2rVrl3LmzClJ2rFjh4YOHSpJKlq0qF566SVJ0t69e1W6dGmVLFlSktShQwd9/PHHlm16e3tb9nfr1q2pjmuTJk00ZswYbdmyRTVq1NDAgQMlKdX5AOwfAS4AmypQoIBGjRqloUOHpvjVpIdRv359bdiwQTt27NDOnTv12WefacmSJSpSpIhlnRMnTmjVqlV67733VKNGDdWoUUP9+vVT9+7dtWHDBhUrVkwlSpRI8hCI8PBw5cuXT2vXrlW2bNks852cnGSMeeg6773twd2vJ907HR8fb5l2c3NL8efUDBw4UAkJCWrSpInq1aun8+fPJ6nxbljr5OQkScnqv3Dhgjp06KD27durSpUqeuWVV/TDDz+k+F53bzmR0rZcXf93+siSJYtlOiEhIdXxdXNz0+bNm7Vz50798ssvateunT777DNVrlw51fkAAAD4n/TuraW093q//PKLpW+UpGvXrunatWtKTExUy5YtNXjwYEl3+uGIiAhL0HtXu3btLLcAKFmypAoXLqyjR48qd+7cWr16tWW9ixcvKleuXPrwww+T9Kd3e9cHub83l+70uPf255J08+ZNtW7dWi+//LKqVq2qNm3aaNOmTZb3S8u/GbZu3arx48ere/fuatCggYoXL641a9ak+Jq745va/Lvu/3dGauPasWNH1a9fX9u3b9fPP/+s4OBgrVmzJtX5XDwB2L/k/70GAP+yJk2aqE6dOpo/f/5jbWfQoEH67rvv1KxZM40cOVLu7u46f/58knXy58+vZcuWKTQ01DLvypUrunjxop5//nlVrFhRJ0+e1K+//ipJOnz4sBo3bqyIiIgHvreLi0uyxi4tatWqpUWLFskYo9jYWC1btkw1atR46O3ctW3bNvXp00dNmzaVk5OT9u/fr4SEhDS//uDBg8qXL5/eeecd1a5d2xLeJiQkqHbt2goJCdHt27d1+/Ztfffdd5KkvHnzqmzZspZG/dChQ/rrr79S3P6Dxnfq1KmaOXOmXn75ZQ0bNkwlS5ZUWFhYqvMBAACQXHr21vd7UK9Xo0YNff/994qOjpYkzZgxQ/PmzVPNmjW1fv16S7/9zTffqFu3biluW5I+++wztWvXTpJUrFgxZc2a1RLgnj9/Xs2bN9fBgwdVu3ZthYaGWkLie0Pe+93t5YsVKyY3Nzdt3LhR0p3wecOGDcn685MnTyo6Olr9+/eXr6+vdu/erdjY2BQD4NRs375d9evXV6dOnVS+fHlt2rTJ0rfXrl1bS5culSSdO3dOu3btknTnKurjx4/ryJEjku7c9zY1DxrXjh076vDhw3r11Vc1duxYXbt2TVevXk11PgD7xxW4ANLF8OHDtXfv3sfaxjvvvKNhw4Zp6dKlcnFx0csvv6wXX3wxyTp58uTR/Pnz9dFHH2nKlCnKnj27smTJojfeeEPVq1eXJE2fPl1TpkzR7du3ZYzRlClTVLBgwQe+d/Xq1dW3b1+5ublpxIgRaa55+PDhGjdunPz8/BQXF6fatWvr7bfffvid//8GDBigPn36KE+ePMqePbteeOEFnTp1Ks2vr1mzplasWKFXXnlF2bNnl4+Pj/Lly2f5+tWpU6fUvHnzZA+C+PjjjxUUFGS5KqN48eIpbj9fvnypjm+3bt0UGBhouU2Dt7e3mjdvrqtXr6Y4HwAAAClLr976fg/q9QoWLKjjx4/rtddekySVLFlSY8eOlbu7u3r27KkePXrIyclJ7u7uCg4OTnK17l3t2rWz/Me+dOfq35kzZ2r8+PH64osvFB8fr379+lluWXb06FG1adNGuXPnVpkyZSwPxb1fw4YN1alTJ82cOVMzZ87UuHHjNGPGDCUkJKhPnz7JHkDm7e2tevXqqUmTJsqdO7eKFCmikiVL6uTJk2l+gFzHjh313nvvyc/PTy4uLqpatao2btyoxMREjRw5UkFBQWrSpImeeeYZlSlTxjK+U6dO1XvvvSc3Nze98MILqW6/du3aqY7re++9pwkTJuiTTz6Rs7Oz3n33XRUqVCjV+QDsn5N5lO8HAwAAAAAAAABsjlsoAAAAAAAAAICdIsAFAAAAAAAAADtFgAsAAAAAAAAAdooAFwAAAAAAAADslGtGF/Aobt26pYMHD8rDw0MuLi4ZXQ4AAECmkJCQoMjISJUrV07ZsmXL6HJgI/TaAAAA6ctan/1EBrgHDx5U586dM7oMAACATGnRokWqWrVqRpcBG6HXBgAAyBip9dlPZIDr4eEh6c5OPfPMMxlcDQAAQOZw4cIFde7c2dKLwTHRawMAAKQva332Exng3v0q1zPPPKNChQplcDUAAACZC1+rd2z02gAAABkjtT6bh5gBAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUzYPcKOjo9W8eXOdOXMm2bLDhw+rTZs2aty4sYYNG6b4+HhblwMAAAA4BPpsAACAzMGmAe7+/fv12muvKSwsLMXlgwcP1ogRI7RhwwYZY7Rs2TJblgMAAAA4BPpsAACAzMOmAe6yZcs0cuRIeXp6Jlt29uxZ3bp1SxUrVpQkvfrqqwoNDbVlOQAAAIBDoM8GAADIPFxtufHx48enuiwiIkIeHh6WaQ8PD4WHh9uynMcTe1lKuJV0nks2KctTGVMPAODfkdLvd4nf8bBP9CP4/xypz46+GavY+MSMLiPdZXF1lnuOLBldBgAAacL5OmPZNMB9EGNMsnlOTk4ZUEkaJdyStndKOq/m4oypBQDw70np97vE73jYJ/oRpMGT1mfHxidq6td7M7qMdPdelyoZXQIAAGnG+Tpj2fwhZqnx8vLSxYsXLdORkZEpfgUMAAAAQNrRZwMAADiWDAtwCxYsqKxZs2rv3jvpfUhIiOrUqZNR5QAAAAAOgT4bAADAsaR7gNuzZ0/98ccfkqSpU6dq4sSJatKkiWJiYuTv75/e5QAAAAAOgT4bAADAMaXLPXC3bNli+Xnu3LmWn8uUKaMVK1akRwkAAACAw6HPBgAAcHwZdgsFAAAAAAAAAMCDEeACAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUwS4AAAAAAAAAGCnCHABAAAAAAAAwE4R4AIAAAAAAACAnSLABQAAAAAAAAA7RYALAAAAAAAAAHaKABcAAAAAAAAA7BQBLgAAAAAAAADYKQJcAAAAAAAAALBTBLgAAAAAAAAAYKcIcAEAAAAAAADAThHgAgAAAAAAAICdIsAFAAAAAAAAADtFgAsAAAAAAAAAdooAFwAAAAAAAADsFAEuAAAAAAAAANgpAlwAAAAAAAAAsFMEuAAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUwS4AAAAAAAAAGCnCHABAAAAAAAAwE4R4AIAAAAAAACAnSLABQAAAAAAAAA7RYALAAAAAAAAAHaKABcAAAAAAAAA7BQBLgAAAAAAAADYKQJcAAAAAAAAALBTBLgAAAAAAAAAYKcIcAEAAAAAAADAThHgAgAAAAAAAICdIsAFAAAAAAAAADtl0wB37dq1atq0qRo2bKhFixYlW37o0CG1adNGLVq00FtvvaVr167ZshwAAADAIdBnAwAAZB42C3DDw8M1bdo0LV68WKtXr9bSpUt1/PjxJOuMHz9eAQEBWrNmjYoVK6Yvv/zSVuUAAAAADoE+GwAAIHOxWYC7Y8cOVatWTXnz5lWOHDnUuHFjhYaGJlknMTFRN27ckCTFxMQoW7ZstioHAAAAcAj02QAAAJmLzQLciIgIeXh4WKY9PT0VHh6eZJ3AwEANGzZMtWrV0o4dO9SxY0dblQMAAAA4BPpsAACAzMVmAa4xJtk8Jycny8+3bt3SsGHDNH/+fG3btk2dOnXS0KFDbVUOAAAA4BDoswEAADIXmwW4Xl5eunjxomU6IiJCnp6elum//vpLWbNmlY+PjySpQ4cO2r17t63KAQAAABwCfTYAAEDmYrMAt0aNGtq5c6eioqIUExOjjRs3qk6dOpblRYsW1YULF/T3339LkjZv3qzy5cvbqhwAAADAIdBnAwAAZC6uttqwl5eXBgwYIH9/f8XFxalt27by8fFRz549FRAQoPLly2vixInq37+/jDF6+umnNWHCBFuVAwAAADgE+mwAAIDMxWYBriT5+fnJz88vyby5c+dafq5bt67q1q1ryxIAAAAAh0OfDQAAkHnY7BYKAAAAAAAAAIDHQ4ALAAAAAAAAAHaKABcAAAAAAAAA7BQBLgAAAAAAAADYKQJcAAAAAAAAALBTBLgAAAAAAAAAYKcIcAEAAAAAAADAThHgAgAAAAAAAICdIsAFAAAAAAAAADtFgAsAAAAAAAAAdipNAW50dLQk6ffff1dISIji4uJsWhQAAACQWdBrAwAA4EFcra3w6aef6tSpUxo0aJDeeecdlSxZUr/++qvGjx+fHvUBAAAADoteGwAAANZYvQL3xx9/1Lhx47Rx40Y1a9ZMCxYs0JEjR9KjNgAAAMCh0WsDAADAmjTdQiF79uzasWOHqlWrJkmKjY21aVEAAABAZkGvDQAAgAexGuA+9dRTGjVqlA4ePKgaNWpo6tSp8vT0TI/aAAAAAIdGrw0AAABrrAa4kydPlqenp2bPnq3s2bPLyclJkydPTo/aAAAAAIdGrw0AAABrrAa4+fPn16uvvqqoqCglJCSoU6dOyp8/f3rUBgAAADg0em0AAABYYzXA3bp1qzp27KjRo0fr0qVLatq0qTZt2pQetQEAAAAOjV4bAAAA1lgNcIODg7Vs2TLlzp1bnp6eWrx4saZPn54etQEAAAAOjV4bAAAA1lgNcBMTE5M8SOG5556Tk5OTTYsCAAAAMgN6bQAAAFhjNcDNnj27zp07Z2kk9+zZo6xZs9q8MAAAAMDR0WsDAADAGldrK7z33nvq0aOHIiMj1aFDB4WFhWnGjBnpURsAAADg0Oi1AQAAYI3VALdSpUpatmyZ9u3bp8TERFWoUEH58uVLj9oAAAAAh0avDQAAAGus3kIhJiZGf//9t+rWratTp07pww8/1Llz59KjNgAAAMCh0WsDAADAGqsBblBQkDZv3qw//vhDCxYsUIECBTRixIj0qA0AAABwaPTaAAAAsMZqgHv69GkNGjRIW7ZsUevWrdW3b19duXIlHUoDAAAAHBu9NgAAAKyxGuDGxcVJkrZt26Zq1aopISFBN2/etHlhAAAAgKOj1wYAAIA1Vh9iVrlyZTVt2lQuLi6qXLmyunXrpho1aqRHbQAAAIBDo9cGAACANVYD3BEjRmjfvn3y9vaWs7Oz3njjDdWpUyc9agMAAAAcGr02AAAArLF6C4XY2Fi5uroqV65cmj9/vjZs2KALFy6kR20AAACAQ6PXBgAAgDVWA9y7T8Y9cOAAT8YFAAAA/kX02gAAALDGaoB798m4P/zwA0/GBQAAAP5F9NoAAACwxmqAy5NxAQAAANug1wYAAIA1Vh9ixpNxAQAAANug1wYAAIA1VgNcnowLAAAA2Aa9NgAAAKyxegsFFxcXXbx4UV988YViYmIUHR0tZ2erLwMAAABgBb02AAAArLHaHc6ZM0fffPONQkNDdevWLQUHB+uzzz5Lj9oAAAAAh0avDQAAAGusBrjr16/X3LlzlT17dj311FNatmyZ1q1blx61AQAAAA6NXhsAAADWWA1wXV1dlSVLFst07ty55epq9da5AAAAAKyg1wYAAIA1VrvDZ599Vlu3bpWTk5NiY2P15ZdfqmDBgulRGwAAAODQ6LUBAABgjdUAd8SIERoyZIiOHj2qihUrqkKFCvroo4/SozYAAADAodFrAwAAwBqrAe4ff/yh+fPnKyYmRgkJCXJ3d0+PugAAAACHR68NAAAAa6zeA3fatGmSpOzZs9NQAgAAAP8iem0AAABYY/UK3NKlS+vzzz9X1apVlSNHDsv8smXLWt342rVr9fnnnysuLk6vv/66OnfunGT533//rZEjR+rq1avy8PDQxx9/rDx58jzCbgAAAABPnkfttemzAQAAMg+rAe7+/fu1f/9+LV++3DLPyclJmzdvfuDrwsPDNW3aNK1cuVJZsmRRx44d9dJLL6lkyZKSJGOMevfurWHDhqlOnTqaOnWq5syZo8GDBz/mLgEAAABPhkfptemzAQAAMherAe6WLVseacM7duxQtWrVlDdvXklS48aNFRoaqnfffVeSdOjQIeXIkUN16tSRJL399tu6du3aI70XAAAA8CR6lF6bPhsAACBzSTXADQ4OfuAL7zaIqYmIiJCHh4dl2tPTUwcOHLBMnzp1Svnz59fQoUP1559/qnTp0hoxYkRa6wYAAACeWI/Ta9NnAwAAZC6pPsTs8uXLunz5svbu3asVK1boypUrio6O1urVq3XkyBGrGzbGJJvn5ORk+Tk+Pl67d+9Wly5dtHbtWhUuXFiTJk16xN0AAAAAnhyP02vTZwMAAGQuqV6Be/d/6f39/bVy5Urly5dPktS7d2+98847Vjfs5eWlPXv2WKYjIiLk6elpmfbw8FDRokVVvnx5SVLz5s0VEBDwaHsBAAAAPEEep9emzwYAAMhcUr0C967IyEhLQylJuXPn1qVLl6xuuEaNGtq5c6eioqIUExOjjRs3Wu7DJUmVKlVSVFSU5QqDLVu2WH3aLgAAAOBIHqXXps8GAADIXKw+xMzb21tBQUFq2bKljDFasWKFKlSoYHXDXl5eGjBggPz9/RUXF6e2bdvKx8dHPXv2VEBAgMqXL6/PPvtMw4cPV0xMjJ555hlNmTLlX9kpAAAA4EnwKL02fTYAAEDmYjXAHTdunKZPn67x48fLyclJtWvXVt++fdO0cT8/P/n5+SWZN3fuXMvPFSpU0IoVKx6yZAAAAMAxPGqvTZ8NAACQeVgNcN3d3fX++++nRy0AAABApkKvDQAAAGtSDXB9fX2TPM32fps3b7ZJQQAAAICjo9cGAABAWqUa4E6fPl2StHjxYrm5ualDhw5ycXHRypUrFRcXl24FAgAAAI6GXhsAAABplWqAW65cOUnSsWPHtHz5csv8oKAgtW3b1vaVAQAAAA6KXhsAAABp5WxthWvXrikqKsoyHR4erujoaJsWBQAAAGQG9NoAAACwxupDzLp16yY/Pz/VqlVLxhht375dgwcPTo/aAAAAAIdGrw0AAABrrAa4nTp1UuXKlbVz5045OTnpzTffVOnSpdOjNgAAAMCh0WsDAADAGqu3UJCkxMRElS9fXmXLllVUVJSWLVtm67oAAACATIFeGwAAAA9i9QrcYcOGacuWLbp165a8vLx06tQpValSRe3bt0+P+gAAAACHRa8NAAAAa6xegbtz505t3rxZjRo10pw5czRv3jxly5YtPWoDAAAAHBq9NgAAAKyxGuB6eHgoR44cKl68uP766y+9+OKLunz5cnrUBgAAADg0em0AAABYYzXAdXNz06+//qoSJUrop59+0vXr12kqAQAAgH8BvTYAAACssRrgvvfee1qyZInq1q2rw4cPq1q1amrRokV61AYAAAA4NHptAAAAWGP1IWYVK1ZUxYoVJUnLly/XtWvXlDt3blvXBQAAADg8em0AAABYY/UK3PvRUAIAAAC2Qa8NAACA+z10gAsAAAAAAAAASB+pBrjff/+9JCk2NjbdigEAAAAyA3ptAAAApFWqAe706dMlSR06dEi3YgAAAIDMgF4bAAAAaZXqQ8xy5sypxo0bKzw8XH5+fsmWr1271qaFAQAAAI6KXhsAAABplWqA+8UXX+jw4cMaNmyYRowYkZ41AQAAAA6NXhsAAABplWqA6+7urhdeeEGzZ8+Wp6enDh06pPj4ePn4+Mjd3T09awQAAAAcCr02AAAA0irVAPeu69evq2vXrsqfP78SEhIUHh6uWbNmqXLlyulRHwAAAOCw6LUBAABgjdUAd/LkyZo6daqqVasmSdq5c6cmTZqkZcuW2bw4AAAAwJHRawMAAMAaZ2srREdHWxpKSapevbpiYmJsWhQAAACQGdBrAwAAwBqrAa6zs7POnj1rmT5z5oxcXFxsWhQAAACQGdBrAwAAwBqrt1Do06ePOnTooOrVq0uStm/frpEjR9q8MAAAAMDR0WsDAADAGqsB7ssvv6zixYvrl19+kTFGb7/9tkqUKJEetQEAAAAOjV4bAAAA1lgNcCWpePHiKl68uK1rAQAAADIdem0AAAA8iNV74AIAAAAAAAAAMgYBLgAAAAAAAADYKasB7pAhQ9KjDgAAACDTodcGAACANVYD3CNHjsgYkx61AAAAAJkKvTYAAACssfoQMw8PDzVr1kwVKlRQzpw5LfOHDx9u08IAAAAAR0evDQAAAGusBriVKlVSpUqV0qMWAAAAIFOh1wYAAIA1VgPcd999V7du3dLJkydVqlQpxcbGKlu2bOlRGwAAAODQ6LUBAABgjdV74O7fv18vv/yy3nrrLUVERKhu3br67bff0qM2AAAAwKHRawMAAMAaqwHu5MmTNW/ePOXNm1fPPPOMpkyZovHjx6dHbQAAAIBDo9cGAACANVYD3Fu3bqlkyZKW6bp16yohIcGmRQEAAACZAb02AAAArLEa4Lq6uurq1atycnKSJP399982LwoAAADIDOi1AQAAYI3Vh5j17t1bXbp0UWRkpAYOHKjt27drzJgx6VEbAAAA4NDotQEAAGCN1QC3fv36Kl68uLZv367ExES98847Sb7mBQAAAODR0GsDAADAGqu3UJCk+Ph4JSYmytXVVW5ubrauCQAAAMg06LUBAADwIFYD3G+//VZdu3bVH3/8ob1796pz587asGFDmja+du1aNW3aVA0bNtSiRYtSXW/r1q3y9fVNe9UAAACAA3jUXps+GwAAIPOweguFefPmKSQkRJ6enpKkc+fO6a233lLjxo0f+Lrw8HBNmzZNK1euVJYsWdSxY0e99NJLyb4SdvHiRU2ePPkxdgEAAAB4Mj1Kr02fDQAAkLlYvQLXzc3N0lBKUoECBdL01a4dO3aoWrVqyps3r3LkyKHGjRsrNDQ02XrDhw/Xu++++5BlAwAAAE++R+m16bMBAAAyl1SvwD106JAkydvbW2PGjFGHDh3k4uKilStXqnLlylY3HBERIQ8PD8u0p6enDhw4kGSdBQsW6Pnnn1eFChUetX4AAADgifM4vTZ9NgAAQOaSaoDbt2/fJNNbt261/Ozk5KThw4c/cMPGmGTznJycLD//9ddf2rhxo+bNm6cLFy6ktV4AAADgifc4vTZ9NgAAQOaSaoC7ZcuWx9qwl5eX9uzZY5mOiIhI8vWw0NBQRUZGqk2bNoqLi1NERIQ6deqkxYsXP9b7AgAAAPbucXpt+mwAAIDMxepDzCIjI7Vq1SpduXIlyfwhQ4Y88HU1atTQjBkzFBUVpezZs2vjxo0aO3asZXlAQIACAgIkSWfOnJG/vz9NJQAAADKVR+m16bMBAAAyF6sPMevdu7cOHDggY0ySP9Z4eXlpwIAB8vf3V6tWrdS8eXP5+PioZ8+e+uOPP/6V4gEAAIAn2aP02vTZAAAAmYvVK3Dj4uIUHBz8SBv38/OTn59fknlz585Ntl6hQoUe+5YNAAAAwJPmUXtt+mwAAIDMw+oVuGXLltVff/2VHrUAAAAAmQq9NgAAAKyxegVu5cqV1apVK3l4eMjV9X+rb9682aaFAQAAAI6OXhsAAADWWA1wg4ODNXXqVBUpUiQ96gEAAAAyDXptAAAAWGM1wM2TJ4+aNm2aHrUAAAAAmQq9NgAAAKyxGuDWq1dPkydPVqNGjZQlSxbL/LJly9q0MAAAAMDR0WsDAADAGqsB7tq1ayVJGzZssMxzcnLivlwAAADAY6LXBgAAgDVWA9wtW7akRx0AAABApkOvDQAAAGusBrhfffVVivO7d+/+rxcDAAAAZCb02gAAALDGaoD7119/WX6OjY3V3r179dJLL9m0KAAAACAzoNcGAACANVYD3IkTJyaZjoqK0pAhQ2xWEAAAAJBZ0GsDAADAGueHfUG+fPl09uxZW9QCAAAAZGr02gAAALjfQ90D1xijgwcP6umnn7ZpUQAAAEBmQK8NAAAAax7qHriS9Oyzz/K1LgAAAOBfQK8NAAAAax76HrgAAAAA/h302gAAALAm1QA3KCgo1Rc5OTlpwoQJNikIAAAAcHT02gAAAEirVAPcUqVKJZt3+fJlzZ8/XwULFrRpUQAAAIAjo9cGAABAWqUa4Pbo0SPJ9I4dOzR06FD5+flp+PDhNi8MAAAAcFT02gAAAEgrq/fAjY+P10cffaRVq1Zp1KhReuWVV9KjLgAAAMDh0WsDAADAmgcGuCdPntSAAQOUI0cOrVq1Ss8++2x61QUAAAA4NHptAAAApIVzagtWrFihdu3aqWHDhvr6669pKAEAAIB/Cb02AAAA0irVK3CHDx8uZ2dnzZkzR3PnzrXMN8bIyclJv/32W7oUCAAAADgaem0AAACkVaoB7ubNm9OzDgAAACDToNcGAABAWqUa4BYsWDA96wAAAAAyDXptAAAApFWq98AFAAAAAAAAAGQsAlwAAAAAAAAAsFMEuAAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUwS4AAAAAAAAAGCnCHABAAAAAAAAwE4R4AIAAAAAAACAnSLABQAAAAAAAAA7RYALAAAAAAAAAHaKABcAAAAAAAAA7BQBLgAAAAAAAADYKQJcAAAAAAAAALBTBLgAAAAAAAAAYKcIcAEAAAAAAADATtk0wF27dq2aNm2qhg0batGiRcmWb9q0SS1btlSLFi30zjvv6OrVq7YsBwAAAHAI9NkAAACZh80C3PDwcE2bNk2LFy/W6tWrtXTpUh0/ftyyPDo6WqNGjdKcOXO0Zs0aeXt7a8aMGbYqBwAAAHAI9NkAAACZi80C3B07dqhatWrKmzevcuTIocaNGys0NNSyPC4uTqNGjZKXl5ckydvbW+fPn7dVOQAAAIBDoM8GAADIXGwW4EZERMjDw8My7enpqfDwcMv0U089pZdfflmSdOvWLc2ZM8cyDQAAACBl9NkAAACZi80CXGNMsnlOTk7J5l2/fl09e/ZUmTJl1Lp1a1uVAwAAADgE+mwAAIDMxWYBrpeXly5evGiZjoiIkKenZ5J1IiIi1KlTJ5UpU0bjx4+3VSkAAACAw6DPBgAAyFxsFuDWqFFDO3fuVFRUlGJiYrRx40bVqVPHsjwhIUFvv/22mjRpomHDhqV41QAAAACApOizAQAAMhdXW23Yy8tLAwYMkL+/v+Li4tS2bVv5+PioZ8+eCggI0IULF/Tnn38qISFBGzZskCSVK1eOKwQAAACAB6DPBgAAyFxsFuBKkp+fn/z8/JLMmzt3riSpfPnyOnLkiC3fHgAAAHBI9NkAAACZh81uoQAAAAAAAAAAeDwEuAAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUwS4AAAAAAAAAGCnCHABAAAAAAAAwE4R4AIAAAAAAACAnSLABQAAAAAAAAA7RYALAAAAAAAAAHaKABcAAAAAAAAA7BQBLgAAAAAAAADYKQJcAAAAAAAAALBTBLgAAAAAAAAAYKcIcAEAAAAAAADAThHgAgAAAAAAAICdIsAFAAAAAAAAADtFgAsAAAAAAAAAdooAFwAAAAAAAADsFAEuAAAAAAAAANgpAlwAAAAAAAAAsFMEuAAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwUwS4AAAAAAAAAGCnCHABAAAAAAAAwE4R4AIAAAAAAACAnSLABQAAAAAAAAA7RYALAAAAAAAAAHaKABcAAAAAAAAA7BQBLgAAAAAAAADYKQJcAAAAAAAAALBTBLgAAAAAAAAAYKcIcAEAAAAAAADATtk0wF27dq2aNm2qhg0batGiRcmWHz58WG3atFHjxo01bNgwxcfH27IcAAAAwCHQZwMAAGQeNgtww8PDNW3aNC1evFirV6/W0qVLdfz48STrDB48WCNGjNCGDRtkjNGyZctsVQ4AAADgEOizAQAAMhdXW214x44dqlatmvLmzStJaty4sUJDQ/Xuu+9Kks6ePatbt26pYsWKkqRXX31V06dPV6dOnaxuOyEhQZJ04cIFm9SeolsR0qX7rlw4e17KlpB+NQAA/n0p/X6X+B0P+5TB/cjd3utuL4aMYcs+W0r/Xvtq9G3duHYxXd7Lnpw/d1Y3r2XN6DIAAEgTzte2Za3PtlmAGxERIQ8PD8u0p6enDhw4kOpyDw8PhYeHp2nbkZGRkqTOnTv/S9U+qtcy+P0BALbD73g8KdL/WI2MjFTRokXT/X1xhy37bMmeem3HFvpVRlcAAACsSe/zdWp9ts0CXGNMsnlOTk5pXv4g5cqV06JFi+Th4SEXF5dHLxIAAABplpCQoMjISJUrVy6jS8nUbNlnS/TaAAAA6c1an22zANfLy0t79uyxTEdERMjT0zPJ8osX/3fpdWRkZJLlD5ItWzZVrVr13ysWAAAAacKVtxnPln22RK8NAACQER7UZ9vsIWY1atTQzp07FRUVpZiYGG3cuFF16tSxLC9YsKCyZs2qvXv3SpJCQkKSLAcAAACQHH02AABA5uJkUvqO1b9k7dq1mj17tuLi4tS2bVv17NlTPXv2VEBAgMqXL68jR45o+PDhunHjhp5//nlNnDhRWbJksVU5AAAAgEOgzwYAAMg8bBrgAgAAAAAAAAAenc1uoQAAAAAAAAAAeDwEuAAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwLUDwcHBatasmZo1a6YpU6YkWbZo0SJ17drVMn3u3Dl17txZr7zyinr37q0bN25Ikq5du6ZevXqpSZMm6ty5syIjIyVJsbGxGjx4sJo0aaLWrVvrxIkT6bdjGSilMd23b5/at2+vZs2aaeDAgYqNjZUkHT58WG3atFHjxo01bNgwxcfHS3r4sXZ0KY3ptm3b1KJFCzVv3lxDhgyxjCnHadp9+umnatq0qZo1a6avvvpKkrRjxw75+fmpUaNGmjZtmmVdjtW0SWlMly5dqubNm8vPz09BQUH8/X9IKY3pXZynHk1KY8p5CrBf0dHRat68uc6cOSOJc7Wjuv9zlqShQ4dq5cqVlmnOc0+2+z9jekTHc/9nvHjxYjVr1kxNmzbV5MmTZYyRxGf8JEvpd7WUCf5dYpChtm/fbjp06GBu375tYmNjjb+/v9m4caMxxphjx46Z2rVrmy5duljW79Wrl1m3bp0xxpjg4GAzZcoUY4wxo0ePNrNnzzbGGLNq1SrTr18/Y4wxX3zxhRkxYoQxxpjdu3ebtm3bpteuZZiUxnTlypWmZs2a5vDhw8YYYwYMGGAWLVpkjDGmWbNmZt++fcYYY4KCgizzH3asHVlqx2mdOnXM8ePHjTHG9O3b1yxbtswYw3GaVrt27TIdO3Y0cXFxJiYmxtSvX98cPnzY1K1b15w6dcrExcWZHj16mK1btxpjOFbTIqUxPXHihGnYsKG5fv26SUxMNEOGDDFfffWVMYYxTYvUxtQYzlOPKrW/+5ynAPv0+++/m+bNm5uyZcua06dPm5iYGM7VDuj+z/nChQvmrbfeMj4+Pubbb7+1rMd57sl1/2f8999/0yM6mPs/41OnTpmGDRuaGzdumPj4eNOhQwfz888/G2P4jJ9U93/Gd2WGf5cQ4Gawv/76y/JLw5g7B9K8efPM7du3zWuvvWZWrFhhOQBjY2NNpUqVTFxcnDHGmHPnzhlfX19jjDH169c3586dM8YYExcXZypVqmRiY2NNly5dzK+//mrZfoMGDczZs2fTae8yRkpjOmPGDNOnTx/LvEuXLpmIiAhz5swZ06BBA8v8X3/91XTt2vWRxtqRpXac1qxZ0/z+++8mPj7e9OrVy6xevZrj9CHdPXbOnDlj6tSpY3bt2mX8/f0ty1etWmUCAwM5Vh/C/WN65swZs337dsvyL774wowfP54xfQj3j+n58+c5Tz2m+8d05cqVnKcAO/X++++bX3/91dSvX9+cPn2ac7WDuv9znjt3rlm2bJkZOnSoJcDlPPdku/8zpkd0PPd/xsb8r+eKiooyzZo1M/v37+czfoKl9Blnln+XcAuFDFaqVClVrFhRkhQWFqbvvvtOdevW1UcffaQ2bdqoUKFClnUvX74sd3d3ubq6SpI8PDwUHh4uSYqIiJCHh4ckydXVVe7u7oqKikoy/+5rLly4kE57lzFSGtMsWbIoR44c6tOnj/z8/DRjxgzlzp07xfEJDw9/pLF2ZKkdp6NGjVLXrl1Vu3ZtXb58Wa+88grH6UNyc3PT9OnT1axZM1WvXj3ZWHh6eio8PJxj9SHcP6YFChRQjRo1JElRUVFatGiRGjRowJg+hPvH1MvLi/PUY7p/TCMjIzlPAXZq/Pjxqlq1qmWac7Vjuv9zfvPNN9WuXbsk63Cee7Ld/xkXLFiQHtHB3P8ZS3d6rmXLlunll1+Wh4eHypQpw2f8BEvpM84s/y4hwLUTx44dU48ePTR06FCdPXtW58+fV5s2bZKsY/7/vVru5eTklOo2nZ1T/nhTm+9o7h3ThIQEbdu2TYGBgQoJCVFMTIzmzJmT6pj+W2PtaO4d05w5c2rq1Klat26dtm3bpgoVKmjixIkcp48gICBAO3fu1Pnz5xUWFpZs+YOOSY7VlN07psuWLZMkhYeHq1u3bmrTpo1eeuklxvQh3TumS5cu5Tz1L7h3TGNjYzlPAU+Ih/17yd9Xx8F5zjHRIzq+9u3ba9euXcqfP7+Cg4P5jB3I9u3bM82/S+ynkkxs7969ev311zVo0CC1bt1a69at07Fjx9SyZUsNHz5cBw8eVP/+/ZUvXz5FR0crISFBkhQZGSlPT09Jd/7n/+LFi5Kk+Ph4RUdHK2/evPL09Exyc+17X+PI7h/T/Pnzq0KFCipcuLBcXFzUpEkTHThwQF5eXpZxk/43Po8y1o7u/jHds2ePSpcurSJFisjZ2Vnt27fX7t27OU4fwokTJ3T48GFJUvbs2dWoUSPt2rUryTEZEREhT09PjtU0SmlMjx49qhMnTui1115T69at1adPH0liTNMopTHdv38/56nHkNKYzpkzh/MU8IS4/+8l5+rMg/Oc46FHdGznz5/X3r17Jd250rJZs2Y6evQon7EDyUz5GQFuBjt//rz69OmjqVOnqlmzZpKkiRMn6r///a9Wr16tcePGqVy5cvrkk0/k5uamqlWr6rvvvpMkhYSEqE6dOpKkunXrKiQkRJL03XffqWrVqnJzc1PdunW1evVqSdKePXuUNWtWFShQIP13NB2lNKa1atXSoUOHdP78eUnSDz/8oLJly6pgwYLKmjWr5Zf63TF9lLF2ZCmNaenSpXXgwAHLL77NmzerfPnyHKcP4cyZMxo+fLhiY2MVGxurzZs3q2PHjvrnn3908uRJJSQkaN26dapTpw7HahqlNKY+Pj5644031K9fP/Xo0cOyLmOaNimNaa1atThPPYaUxnTMmDGcp4AnRIUKFThXZ1Kc5xxLdHQ0PaKDu379ugYPHqxr167JGKMNGzaoSpUqfMYOJDPlZ04mpeuKkW7GjRunb7/9VkWKFLHM69ixo1577TVJ0q5duxQcHKyFCxdKks6ePavAwEBdunRJzz77rD7++GPlyZNHV65cUWBgoE6fPq1cuXJp6tSpKlSokG7fvq0PPvhABw8eVJYsWTRu3DiVLVs2Q/Y1vaQ2ps8++6ymTZum27dv67nnntOECROUPXt2HTlyRMOHD9eNGzf0/PPPa+LEicqSJctDj7UjS21Ms2XLprlz58rFxUVFixbVmDFjlC9fPo7ThzB9+nSFhobKxcVFjRo1Ut++fbVz505NnDhRt2/fVt26dRUUFCQnJyeO1TS6f0zv7nuJEiUs6/j6+qpfv36MaRqldJzexXnq0aQ0plu3buU8BdgxX19fLViwQIUKFeJc7cDu/ZwlKTAwUC+++KJeffVVSZznHMHdz3jTpk30iA7q3r/HS5Ys0YIFC+Ti4qKqVavq/fffl5ubG5/xE+7+39WS4/+7hAAXAAAAAAAAAOwUt1AAAAAAAAAAADtFgAsAAAAAAAAAdooAFwAAAAAAAADsFAEuAAAAAAAAANgpAlwAAAAAAAAAsFMEuABs4syZM/L29tby5cuTzP/yyy8VGBj4r72Pr6+v/vjjj39tew8SHR2tjh07qlmzZtqwYUOSZVu3btWnn36aLnU8rNOnT6tv376SpPDwcHXs2DGDK0rZvXUCAAAgbei77UdG9N09e/bU8ePHbf4+ADKWa0YXAMBxOTs7a/LkyapataqKFSuW0eU8tsOHD+vSpUv6/vvvky37448/dPXq1Qyoyrpz587pn3/+kSR5eXlpyZIlGVxRyu6tEwAAAGlH320fMqLvnjt3rs3fA0DGI8AFYDPZsmVT9+7dNWjQIC1ZskRZsmRJsjwwMFClSpXSG2+8kWza19dXzZs319atW3XlyhX17dtXv/32mw4dOiRXV1d9/vnn8vLykiQtXrxYR44cUWxsrLp37662bdtKkrZs2aLPP/9ccXFxypYtm4YOHapKlSppxowZ+v333xURESFvb29NnTo1SV2bNm1ScHCwEhIS5O7urqCgILm7u+v9999XeHi4WrZsqaVLlypbtmySpP3792vJkiVKSEhQrly5VLRoUa1YsUIxMTFyd3fX7NmzNWrUKIWFhenq1avKmTOnpk6dquLFi6tr166qWLGifvvtN50/f15VqlTR5MmTlZiYqLFjx+q3336Tm5ubChUqpIkTJypnzpyaNWuWNm3apNu3bysmJkZDhw5Vw4YNFR8frw8//FBbt26Vi4uLKlWqpJEjR2r48OEKDw/XG2+8odGjR8vPz0/79u1TXFycJk2apJ07d8rFxUU+Pj6WffX19VXr1q21c+dOnT9/Xk2aNNGQIUN048YNBQUF6eTJk3J2dlbZsmU1ZswYOTsn/ULHsWPHNGbMGF25ckVOTk7q0aOHWrVqpV27dmns2LFat26dJFmmV69enaTOL7/88t8/IAEAABwUfXfm7bt9fX316aef6ubNm5o2bZoKFy6sY8eOKTY2Vh988IGqVatmk2MOQPriFgoAbKp3797Knj27pk2b9tCvvX37ttasWaPAwEB98MEH6tatm9asWaNnn31Wq1atsqyXNWtWrVq1Sv/3f/+njz76SMeOHVNYWJimTZumOXPmKCQkRGPHjlXfvn118+ZNSdLZs2e1atWqZE3kiRMnNHLkSM2YMUNr165VQECA3nnnHXl6emrcuHEqUqSIVq9ebWkiJalChQrq2LGjmjZtqgEDBkiSjh8/roULF2rhwoX66aeflDt3bi1btkwbNmxQuXLltGjRIsvrT506pYULF2rNmjX65ZdftHv3bv3+++/avXu31qxZo5UrV6pw4cI6evSozp49qx07dujrr7/W2rVrNWDAAE2fPl3SnYb60KFDWr16tdatW6cbN27ou+++s9R9fyj6+eefKyIiQqtXr9bq1auVmJioKVOmWJbfvHlTixcv1pIlS/T111/r9OnT+v7773Xjxg2tXr1aK1askHTnq2L3io+PV+/evdW1a1etXbtWc+fO1ccff6x9+/al+lm7uLikWicAAACso+/OfH33/Q4cOKAePXooJCREbdu2VXBwcJqPAQD2jStwAdiUs7OzPvzwQ7Vu3Vq1atV6qNc2atRIklS4cGHlz59fZcqUkSQVKVIkydem7t5bysvLS7Vq1bL8z3ZERIRef/11y3pOTk46deqUJKlixYpydU3+K/CXX35RtWrVVLhwYUlS9erVlS9fPh08eFBOTk5prt3b21vu7u6SpFdeeUWFCxfWwoULdfLkSe3evVuVKlWyrFu/fn05OzvL3d1dRYsW1dWrV1W9enW5uLioXbt2qlWrlho3biwfHx9J0uTJk7V27VqdPHlS+/fv140bNyRJO3bsUMuWLS1N7ieffCLpzlWuKfnpp580YMAAubm5SZK6du2qPn36WJY3aNDAMq5PP/20rl69qipVqmjatGnq2rWratSooW7duqlo0aJJthsWFqbbt29bPj8vLy81atRIP//8s1566aU0jyEAAADSjr478/Xd9ytQoICee+45SdLzzz+fJHwH8GTjClwANlegQAGNGjVKQ4cO1eXLly3znZycZIyxTMfFxSV53b1f/brb7KTk3q8RGWPk6uqqxMREVa9e3fK/3KtXr9ayZctUqlQpSVKOHDlS3Na99dw7Lz4+3speJnXv9hcvXqxhw4YpW7Zs8vPzU/PmzZO8z71XFdwdk9y5c2v16tUaOnSoXFxc1L9/f82bN0+HDh1Sx44dFR0drZo1a+rNN9+0vPb+xvjixYuKiIhItcbExMRk0/d+BlmzZk1WV+HChfX999+rV69eio6OVvfu3RUaGvrA7Ur/G0NrnzkAAAAeHX135uq775fS/gFwDAS4ANJFkyZNVKdOHc2fP98y76mnntLBgwclSVFRUdqzZ88jbfvu/yyfO3dOO3bsUPXq1VWtWjVt375dJ06ckCT9+OOPatGihW7fvv3Abd193d2vJ929F1WFChUe+DoXF5dUm81t27apdevWateunYoVK6YtW7YoISHhgdv74Ycf9Prrr6tSpUrq27evWrVqpSNHjujXX39VuXLl1L17d7344ovavHmzZVvVq1fXunXrFBsbq8TERI0aNUrr16+Xi4tLikFp7dq1tWTJEsXFxSkxMVGLFi1SzZo1H1jX4sWLFRQUpFq1amnw4MGqVauWjh07lmSdYsWKyc3NTRs3bpR05wm8GzZsUI0aNZQvXz6dO3dOly5dkjFGmzZtSjKGBLoAAACPh7478/TdADIPbqEAIN0MHz5ce/futUx37dpV7733nho3bqxChQrpxRdffKTt3r59W61bt1ZcXJyGDx9uefLumDFjNHDgQMvVAZ9//nmqVwDcVbJkSY0cOVLvvvuuEhISlC1bNs2aNUu5cuV64OuqV6+uvn37ys3NTWXLlk2yrEePHvrggw+0cuVKubi4qGzZsvrrr78euL06derop59+UvPmzZUjRw7lyZNHY8eOVbZs2bRx40Y1bdpUbm5uql69uq5evaro6Gh17NhRZ8+e1auvvipjjF588UV17dpVN27ckIuLi9q2bZvknmi9e/fW5MmT1apVK8XHx8vHx0cjRox4YF2tWrXS7t271bRpU2XPnl0FChSQv79/knXc3Nw0c+ZMjRs3TjNmzFBCQoL69OljeYBCx44d1aZNG3l4eKhevXqW15UqVcpS5/Llyx/qq3MAAAD4H/ruzNF3A8g8nAzX1AMAAAAAAACAXeIWCgAAAAAAAABgpwhwAQAAAAAAAMBOEeACAAAAAAAAgJ0iwAUAAAAAAAAAO0WACwAAAAAAAAB2igAXAAAAAAAAAOwUAS4AAAAAAAAA2CkCXAAAAAAAAACwU/8Phvu5YXSyXiEAAAAASUVORK5CYII=\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": 137, + "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": 137, + "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": 138, + "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": 138, + "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": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'transfers' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtransfers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'transfers' is not defined" + ] + } + ], + "source": [ + "transfers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "transf" + ] + } + ], + "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/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb index 5af04542..3b9f4917 100644 --- a/datasets/nfts/notebooks/transfers_count.ipynb +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -29,195 +29,29 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "checkpoint = pd.read_sql_query(\"SELECT * FROM checkpoint\", conTXs)\n", - "mints = pd.read_sql_query(\"SELECT * FROM mints\", conTXs)\n", - "nfts = pd.read_sql_query(\"SELECT * FROM nfts\", conTXs)\n", "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " sql\n", - "0 CREATE TABLE nfts\\n (\\n address TEXT...\n", - "1 CREATE TABLE checkpoint\\n (\\n event_...\n", - "2 CREATE TABLE mints\\n (\\n event_id TE...\n", - "3 CREATE TABLE transfers\\n (\\n event_i...\n", - "4 CREATE TABLE current_owners(\\n nft_address TE...\n", - "5 CREATE TABLE current_market_values(\\n nft_add...\n", - "6 CREATE TABLE market_values_distribution(\\n ad...\n" - ] - } - ], + "outputs": [], "source": [ - "stolbiki = pd.read_sql_query(\"SELECT sql FROM sqlite_master where type='table'\", conTXs) \n", - "print(stolbiki)" + "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": 6, "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", - "
event_idtransaction_hashblock_numbernft_addresstoken_idfrom_addressto_addresstransaction_valuetimestamp
0ce7b6ba0-218f-40c7-8d8c-4e3bfc822a410x804cee46e672b17b477658b99c25c8b75f31553278ad...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62057287012905433418913509099434869470284131894829...0x79A8b5Fcc051c843DFCB753eE38d113675E5367D0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f0.01609460206
1c81d8767-a523-410e-9f4a-21a25f8e906f0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46...115650990x629A673A8242c2AC4B7B8C5D8735fbeac21A62051225542446027558019364995253890488984869511709...0x2c338BAf69A57A17E69dB86933310e92f64ab69d0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f0.01609460206
2d9494633-61fd-4cd6-bd42-e736e09829560x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e...115650440x6Fa769EED284a94A73C15299e1D3719B29Ae2F52510600260x9503DE24f4210dA79c5e5BCCD198B2727387a5190x8B36486EA2E0b70A505D92d30c31CC3197ba57070.01609459570
3801c3aae-9b72-4a4b-b40b-1cf93308eeea0xe74d08ee2cbe4b6b873258462ec5523999433569df66...115650420xB2D6fb1Dc231F97F8cC89467B52F7C4F784840444265098311422702060752376543910232329671779809...0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e60x00000000000000000000000000000000000000000.01609459545
\n", - "
" - ], - "text/plain": [ - " event_id \\\n", - "0 ce7b6ba0-218f-40c7-8d8c-4e3bfc822a41 \n", - "1 c81d8767-a523-410e-9f4a-21a25f8e906f \n", - "2 d9494633-61fd-4cd6-bd42-e736e0982956 \n", - "3 801c3aae-9b72-4a4b-b40b-1cf93308eeea \n", - "\n", - " transaction_hash block_number \\\n", - "0 0x804cee46e672b17b477658b99c25c8b75f31553278ad... 11565099 \n", - "1 0x9b124e219f875fa0bb52d90ba937c5d8373ddc8a2c46... 11565099 \n", - "2 0x64a82fe7402d2efd82085a10b6a99d6fcedcac21804e... 11565044 \n", - "3 0xe74d08ee2cbe4b6b873258462ec5523999433569df66... 11565042 \n", - "\n", - " nft_address \\\n", - "0 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", - "1 0x629A673A8242c2AC4B7B8C5D8735fbeac21A6205 \n", - "2 0x6Fa769EED284a94A73C15299e1D3719B29Ae2F52 \n", - "3 0xB2D6fb1Dc231F97F8cC89467B52F7C4F78484044 \n", - "\n", - " token_id \\\n", - "0 7287012905433418913509099434869470284131894829... \n", - "1 1225542446027558019364995253890488984869511709... \n", - "2 51060026 \n", - "3 4265098311422702060752376543910232329671779809... \n", - "\n", - " from_address \\\n", - "0 0x79A8b5Fcc051c843DFCB753eE38d113675E5367D \n", - "1 0x2c338BAf69A57A17E69dB86933310e92f64ab69d \n", - "2 0x9503DE24f4210dA79c5e5BCCD198B2727387a519 \n", - "3 0x0BF988a6cc20af0CDD6f583aD2Fcf057895888e6 \n", - "\n", - " to_address transaction_value timestamp \n", - "0 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0.0 1609460206 \n", - "1 0x433f7e8DeFBbCB5459DDD8C6597493e41550F37f 0.0 1609460206 \n", - "2 0x8B36486EA2E0b70A505D92d30c31CC3197ba5707 0.0 1609459570 \n", - "3 0x0000000000000000000000000000000000000000 0.0 1609459545 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "transfers.head(4)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "num_df = (transfers[[\"transaction_value\", \"timestamp\"]].apply(pd.to_numeric, errors='coerce'))\n", - "\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": 10, - "metadata": {}, "outputs": [ { "data": { @@ -225,7 +59,7 @@ "Text(0.5, 1.0, 'NFT transfers value over time')" ] }, - "execution_count": 10, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, @@ -252,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -269,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -278,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -290,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -301,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -347,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -357,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -403,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -413,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 133, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -468,7 +302,7 @@ "0xcDA72070E455bb31C7690a170224Ce43623d0B6f 76645.0 36116.0" ] }, - "execution_count": 133, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -491,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 134, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -540,7 +374,7 @@ "0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA NaN 106620.0" ] }, - "execution_count": 134, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -562,7 +396,7 @@ }, { "cell_type": "code", - "execution_count": 136, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -613,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 137, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -668,7 +502,7 @@ "0xcDA72070E455bb31C7690a170224Ce43623d0B6f 76645.0 36116.0" ] }, - "execution_count": 137, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -692,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 138, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -741,7 +575,7 @@ "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C 14124.0 23128.0" ] }, - "execution_count": 138, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -761,6 +595,121 @@ "[0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C](https://etherscan.io/address/0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C) / not a contract! / info: `CryptoKitties: Sales Auction `\n" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "#transfers not transactions\n", + "transactions_per_nft = transfers[\"nft_address\"].groupby(transfers[\"nft_address\"]).size()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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": 24, + "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": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_value_per_nft = transfers[\"nft_address\"].groupby(transfers[\"transaction_value\"]).sum()\n", + "total_value_per_nft.head(4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "most_popular_nfts = transactions_per_nft.sort_values(ascending=False).head(8)\n", + "most_valuable_nfts = total_value_per_nft.sort_values(ascending=False).head(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "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\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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'])['transaction_value'].agg(transaction_value=\"sum\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# plt.figure(figsize=(24, 12))\n", + "# new_df.unstack()\n", + "# ax = sns.lineplot(data=new_df, x='timestamp', y='transaction_value', hue='nft_address',)" + ] + }, { "cell_type": "code", "execution_count": null, From cd7ecac891b240992024779d4f8159d3c209b77d Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 18:45:04 +0200 Subject: [PATCH 45/87] remove unneeded yet file --- .../notebooks/transfers_count-Copy1.ipynb | 650 ------------------ 1 file changed, 650 deletions(-) delete mode 100644 datasets/nfts/notebooks/transfers_count-Copy1.ipynb diff --git a/datasets/nfts/notebooks/transfers_count-Copy1.ipynb b/datasets/nfts/notebooks/transfers_count-Copy1.ipynb deleted file mode 100644 index 2923bdf9..00000000 --- a/datasets/nfts/notebooks/transfers_count-Copy1.ipynb +++ /dev/null @@ -1,650 +0,0 @@ -{ - "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": 146, - "metadata": {}, - "outputs": [], - "source": [ - "conTXs = sqlite3.connect('../../../../../../datasets/nfts.sqlite')" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [], - "source": [ - "transfers = pd.read_sql_query(\"SELECT * FROM transfers\", conTXs)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "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": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'NFT transfers value over time')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsoAAAGECAYAAAAvLAbBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABgRUlEQVR4nO3dd3hUVf4G8Hf6pEx6SEJJ6EQ6UgREEEHpVVhdESuia1ndRX+gsoq4uOq661pRV11dV9fVFVGUtRBEKdJRhNBLCqTXyfS5c35/TGaSkEnDzNw7+H6ex0eYmdx77r2Ib775nnNUQggBIiIiIiJqQC33AIiIiIiIlIhBmYiIiIgoAAZlIiIiIqIAGJSJiIiIiAJgUCYiIiIiCoBBmYiIiIgoAAZlIlKU/Px89OnTBx9++GGD19944w0sW7YMALBmzRoMHToUs2bNavBPVlYWfvvb3/p/36dPH8yYMQOzZs3CwoULG53rxRdfxIYNG4J+TZIk4Te/+Q0mTZqEf/3rX0E/X0t27NiB6dOnyz2M81L/mT333HNYu3atvAMioguaVu4BEBGdS61W46mnnsKwYcPQrVu3gJ8ZNmwYXn311UavT5gwwf/rPn364O2330ZCQkLAY+zYsQM9e/Zsn0E3o6ioCFu2bMEPP/wAjUYT9PNdyOo/s3vvvVfm0RDRhY5BmYgUx2g04uabb8aSJUvw/vvvQ6/Xt/s53n33XRw4cABPP/00NBoNsrKyUFlZiby8PFx++eWYN28eVq5cCavViuLiYmRmZuJvf/sbDAYDBgwYgMWLF2Pr1q0oLi7GDTfcgJtuugklJSVYunQpKioqAADjxo3DokWLsGjRIrjdbsydOxcvvPACXC4XVq1ahcrKSkiShIULF2LevHnYsWMHVq1ahcjISFitVrz77rt4+OGHkZOTA7VajX79+mHlypVQq+t+GLhlyxY89dRTWLduHQCguroaEyZMwIYNG7B37168+uqrcDqdKC8vx+zZs3Hfffc1uA/Lli1Dr169cOuttzb6fVFREVauXImCggK4XC5MmzYNd9xxR6N7WVhYiBUrVuDMmTMQQmD27NlYtGgR/vrXv6KmpgaPPPIIAOC7777DCy+8gA8//BB79+7FM888A5vNBpVKhXvuuQfjx4/HmjVr8N///hc2mw3R0dF45513mn1mvrEOGDAAN910EzZt2oSamho88MAD+OKLL3D06FF06NABr7zyCiIjI3HixImA956IKCChYGazWUybNk3k5eU1+7mvv/5azJw5U8yYMUP85je/EZWVlUIIIXbv3i3mzp0rZs6cKW644QaRn58fimET0c+Ql5cnBg8eLCRJEtddd5148sknhRBCvP7662Lp0qVCCCE++ugjcfHFF4uZM2f6//nDH/7Q6Fi9e/cWZWVlTZ7r+uuvF//73/+EEEIsXbpU3Hjjjf73nnzySbF27VohhBBOp1NMnz5dfPHFF/7jvvPOO0IIIX766SfRv39/YbfbxYsvvugfh8ViEffdd5+orq72X5MQQrhcLjF16lRx4MABIYQQ1dXVYsqUKWLfvn1i+/btIjMz0/931ccffyxuueUWIYQQbrdbPPzww+L06dMNrsHj8Yjx48eL/fv3CyGEePfdd8WSJUuEx+MR119/vTh16pQQQojCwkJx0UUXibKyMrF9+3Yxbdo0/3W//vrr/uPV//3ChQtFVlaWEEIIu90uFi5cKD7//PNG93HBggXizTff9F/PjBkzxGeffSZyc3PFJZdcIhwOhxBCiHvvvVd88MEHorKyUlx11VX+v9sLCwvF2LFjxZkzZ8RHH30khg8fLsxmc6uemW+svXv3Fm+//bYQQohXX31VDBkyRBQWFgpJksScOXPEp59+2uy9JyIKRLEV5R9//BHLly/H6dOnm/1cTU0NVqxYgY8++ggpKSl47rnn8MILL2D58uV44IEH8PLLLyMzMxP//e9/8cc//hGrV68OzQUQ0c+iVqvx5z//GXPmzMGYMWMavd9U68XPMXToUP+vH3jgAWzduhV///vfcfr0aRQXF8Nqtfrf97V49OvXD06nE1arFZdddhkWL16MgoICjB49GkuWLIHJZEJVVZX/606fPo3c3Fw89NBD/tfsdjuys7PRo0cPpKWloVOnTv7xPPvss1i4cCFGjx6NG2+8ERkZGQ3GrFKpMG/ePHz88ccYMGAA1qxZgwceeAAqlQqvvPIKNm3ahM8++wwnTpyAEAI2m61V98JqtWLXrl2oqqrCc88953/t8OHDmDp1aoPP7d27F2+++SYAwGQyYe7cufjuu+8wbdo0ZGZmYuPGjRg1ahS+//57rFq1Crt370ZJSQnuuuuuBtdx5MgRAN6Wmejo6FaNs75JkyYBANLT09G7d2+kpKQAADp37oyqqqpm7/3gwYPbfD4iuvApNih/8MEHePTRR/F///d//tfWrl2Lt99+Gx6PB/369cOjjz4Kl8uFFStW+P9C7NOnD9atWwen04l7770XmZmZ/teVMImGiFqvY8eOWLFiBZYuXYrZs2cH/XyRkZH+X//+97+HJEmYMmUKLr/8chQUFEAI4X/fYDAA8AY8ABBCYODAgcjKysL333+P7du3Y/78+XjppZfQoUMH/9dJkoSYmBh88skn/tdKS0thMpnwww8/NBhDly5d8PXXX2PHjh3Yvn07br75ZixfvhyTJ09uMO6rr74as2fPxvz582E2m3HJJZfAarVizpw5mDhxIoYNG4arr74aGzZsaHANvvHXf83lcgEAPB4PhBB4//33ERERAQAoLy/3X7eP73PnvuZ2uwEA8+fPx9q1a1FWVoYrr7wSUVFRkCQJPXr0aDBhs6ioCAkJCVi3bl2De9AWOp0u4K99mrv3RESBKHbVi1WrVmHYsGH+3x87dgwffPAB3n//fXzyySdITEzEG2+8gfj4eEycOBGAtzLw2muvYeLEidDr9Zg1axYA71/aL774ov9zRBQ+pkyZgrFjx+Ltt99u92NrNBp/oDvXli1bcNddd2Hq1KlQqVT48ccfIUlSs8d75pln8PLLL2PixIl4+OGH0bNnz0Y/FevWrRsMBoM/rBUUFGD69Ok4cOBAo+O99957ePDBBzFmzBg88MADGDNmDI4dO9bocykpKRg0aBAeeeQRf79tTk4OampqcN999+GKK67Azp074XQ64fF4GnxtfHy8/9zl5eXYvXs3ACA6OhqDBw/GP/7xDwDe3udf//rXyMrKavD10dHRGDRoEN59910AgNlsxtq1azF69GgAwJVXXomDBw/igw8+wK9+9SsAwODBg5GTk4Ndu3YBAA4dOoRJkyahuLi42fsLNP/MWtKWe09EBCi4onyuHTt2ICcnx/8XrcvlQt++ff3vm81m3HnnncjMzMScOXP8rzudTixbtgxutxu33357yMdNRD/f8uXLsWfPnnY/7vjx4/HUU0/5q6j1/e53v8Ndd92F2NhYREREYPjw4cjNzW32eDfeeCOWLVuG6dOnQ6/Xo0+fPpg+fXqDAKjX6/Hyyy9j1apVeP311+F2u3Hvvfdi6NCh2LFjR4PjzZ49Gzt37sTUqVMRERGBjh074oYbbgh47vnz5+Pee+/1t5f16dMHl19+OaZMmYKYmBikp6ejZ8+eyMnJaTA5cuHChbj//vsxadIkdO7cGSNGjPC/98wzz+Dxxx/HjBkz4HQ6MX36dMycObPRuZ955hmsXLkSa9asgdPpxIwZMzB37lz/9U6dOhXbtm3DwIEDAQAJCQl4/vnn8fTTT8PhcEAIgaefftrfctKc5p5ZS5q790REgajEuT8zU5grrrgC//znP5GVlYW8vDwsX74cAGCxWPw/RisuLsatt96KkSNH4qGHHvL/KNRiseA3v/kN4uLi8MwzzwRl5jwRERERXZgU23pxrksuuQRff/01ysrKIITAihUr8Pbbb0OSJNxxxx2YMmUKHn74YX9IBryTcTIyMvDcc88xJBMRERFRm4RN60VmZibuvvtu3HjjjfB4PLjooouwePFibNy4EdnZ2ZAkCV9++SUAoH///liwYAGysrLQs2dP/ySgDh064O9//7uMV0FERERE4ULxrRdERERERHIIm9YLIiIiIqJQUlzrhd1ux4EDB5CcnAyNRiP3cIiIiIjoAiVJEkpKStC/f38YjcZG7ysuKB84cAALFiyQexhERERE9Avx7rvvNti/w0dxQTk5ORmAd8Cpqakyj4aIiIiILlSFhYVYsGCBP3+eS3FB2ddukZqais6dO8s8GiIiIiK60DXV7svJfEREREREATAoExEREREFwKBMRERERBQAgzIRERERUQAMykREREREATAoExEREREFwKBMRERERBQAgzIRERERUQAMykREREREATAoExEREREFwKBMRERERBQAgzIRERGRAljtLjz2+naUVNjkHgrVYlAmIiIiUoD84hrsPlSEQ6fL5B4K1WJQJiIiIlIAp0sCAFhsLplHQj4MykREREQK4HR7AAA1DMqKwaBMREREpAAuVpQVh0GZiIiISAF8FWWL3S3zSMiHQZmIiIhIAdijrDwMykREREQK4K8oMygrBoMyERERkQKwR1l5GJSJiIiIFICrXigPgzIRERGRAvgrynYGZaVgUCYiIiJSAPYoK09Qg/Inn3yCadOmYdq0aXjqqaeCeSoiIiKisOZ0eyvKLrfHvwIGyStoQdlms2HVqlV455138Mknn2D37t3Ytm1bsE5HREREFNZcLo//16wqK0PQgrIkSfB4PLDZbHC73XC73TAYDME6HREREVFY81WUAU7oUwptsA4cHR2Ne++9F1OmTIHRaMSIESNw8cUXB+t0RERERGGtQUWZE/oUIWgV5cOHD+Ojjz7CN998gy1btkCtVuONN94I1umIiIiIwlr9ijJbL5QhaEF5y5YtGDVqFBITE6HX6zF37lzs3LkzWKcjIiIiCmtOtwcRBu8P+xmUlSFoQTkzMxPbtm2D1WqFEAIbN27EgAEDgnU6IiIiorDmcnkQb/LO52JQVoag9SiPGTMG2dnZmDt3LnQ6HQYMGIDFixcH63REREREYc3plhAfY8TZUgsn8ylE0IIyACxevJjhmIiIiKgVXC4PYqMM0GrUrCgrBHfmIyIiIlIAp1uCXqdGdIQOFrtb7uEQGJSJiIiIFMHp9kCv0yAqQsuKskIwKBMREREpgMslQadVIypCx6CsEAzKRERERArgrygbGZSVgkGZiIiISAFcLgn62ooyV71QBgZlIiIiIpkJIeB0e6DTarytF9zCWhEYlImIiIhk5pY8AFC36gUryorAoExEREQkM6fLG5R9FWWX2wOnS5J5VMSgTERERCQzp9sbivU6b48ywG2slYBBmYiIiEhmrtqKsl6rRpTRG5Q5oU9+DMpEREREMvNVlH2tFwA4oU8BGJSJiIiIZOZyN5zMB7D1QgkYlImIiIhk5pu416CizKAsOwZlIiIiIpk561WUGZSVg0GZiIiISGZ1k/nqKsqczCc/BmUiIiIimdVN5lNDr1VDq1GzoqwADMpEREREMvNXlHUaqFQqRBq1sNrdMo+KGJSJiIiIZFa/ogx4A7PvNZIPgzIRERGRzHyrXhh0GgDejUd8VWaSD4MyERERkcx8q17ofEGZFWVFYFAmIiIikpmvoqyvbb3QadX+8EzyYVAmIiIikplvZ776PcpsvZAfgzIRERGRzJwuCTqtGiqVCoC3sszWC/kxKBMRERHJzOX2+NsuAFaUlYJBmYiIiEhmTrfHP5EP8PUos6IsNwZlIiIiIpk5XVKjijIn88mPQZmIiIhIZi63Bzptw4qyy8WKstwYlImIiIhk5nRJ0OvOqSgzKMuOQZmIiIhIZt7JfHUVZT3XUVYEBmUiIiIimTndEnT1Kso6rQYutwdCCBlHRQzKRERERDJzuc6pKNeGZheryrJiUCYiIiKSmdMt+XflA+Cf2Mf2C3kxKBMRERHJzOnyQK8LUFHmhD5ZMSgTERERycx1TkXZt6YyK8ryYlAmIiIikpnT3bCi7G+9YEVZVgzKRERERDJzBdiZD+BkPrkxKBMRERHJzOn2NGy90PlaL1hRlhODMhEREZGMhBDeDUfqT+arbb1wuVhRlhODMhEREZGMfO0VDZaHY0VZERiUiYiIiGTkW9kiUEWZk/nkxaBMREREJCPfWsn6BhuO1FaU2XohKwZlIiIiIhk5/a0X9Tcc8a16wYqynBiUiYiIiGTka6/wrXQBcMMRpWBQJiIiIpKRK0BFWafz9SgzKMuJQZmIiIhIRr6VLQJVlNl6IS8GZSIiIiIZ+dZK1tevKHMynyIwKBMRERHJyFdR1tWrKKtUKui0alaUZcagTERERCQjZ4CKsvf3ak7mkxmDMhEREZGMfFXj+jvzAd4l4rjhiLwYlImIiIhk5K8o6xpWlHU6jX9FDJIHgzIRERGRjHwVZf25FWWtmhVlmTEoExEREcnIUVtR1unO7VFmRVluDMpEREREMmqqR1mnU8PBirKsGJSJiIiIZGR3SlCrArVesKIsNwZlIiIiIhnZHW4Y9FqoVKoGr+t07FGWG4MyERERkYzsTgkRBk2j1/VaNSvKMmNQJiIiIpKR3eGGUa9t9Lpey3WU5cagTERERCQju1MKGJR1Ou7MJzcGZSIiIiIZ2Z1uGAO2Xmj8K2KQPBiUiYiIiGRka6L1wjuZjxVlOTEoExEREcnI7pRYUVYoBmUiIiIiGdmdTUzm02nglgQkj5BhVAQEOShv3LgRc+fOxeTJk/HHP/4xmKciIiIiCkt2hwSjPvDycABYVZZR0IJyXl4eHn30Ubz88stYt24dsrOz8e233wbrdERERERhye50I8IQuEcZANdSllHjp9JOvv76a0ydOhWpqakAgGeffRYGgyFYpyMiIiIKO5LkgcvtgTFAUNZrvVVmrqUsn6BVlHNyciBJEm699VbMnDkT7733HmJjY4N1OiIiIqKwY3d6Q3DA1ovaijJXvpBP0IKyJEn4/vvv8ec//xkffPABfvrpJ3z88cfBOh0RERFR2LE73QAQeHk4X0WZPcqyCVpQTkpKwqhRo5CQkACj0YgJEyZg//79wTodERERUdhptqLsm8zHirJsghaUx48fjy1btqC6uhqSJGHz5s3o169fsE5HREREFHZsjtqKcsDJfKwoyy1ok/kGDRqERYsW4brrroPL5cKll16Kq6++OlinIyIiIgo79tqgHBFoHWVWlGUXtKAMAPPmzcO8efOCeQoiIiKisOVrvTAE2pmPFWXZcWc+IiIiIpn4JvMFqijraivKTq6jLBsGZSIiIiKZ2B21FeWAy8N5X3NxHWXZMCgTERERycRfUQ40mY8VZdkxKBMRERHJpLlVL3w787GiLB8GZSIiIiKZOJwSVKq6FS7q8+/Mx4qybBiUiYiIiGRic7ph1GuhUqkavcdVL+THoExEREQkE4dTCrgrHwBo1CqoVVxHWU4MykREREQysTncAfuTAUClUkGn08DBHmXZMCgTERERycTukAKuoeyj16rhYo+ybBiUiYiIiGRid7oDrqHso9Nq4GRFWTYMykRERERBcjS3Alm7cpt83+50B1xD2UevY0VZTgzKREREREHy8abjeP2TA02+b3dKMBpaqChz1QvZMCgTERERBUl+cQ2sDjeEEAHftzu8y8M1Ra9Tw8lVL2TDoExEREQUBJJH4GxJDTweAbszcFXY5mh6eTjAuzufixVl2TAoExEREQVBSYXVv6ue1e4K+BmHs/mKsk7LirKcGJSJiIiIgiC/uMb/a4utcVCWJA+cbk+T6ygD3t35WFGWD4MyERERURDkF5v9v7ba3Y3e97VjRDQ7mU/tr0pT6DEoExEREQVB/Ypy4KDsfc3QTOuFQaeBo4n+Zgo+BmUiIiKiIMgvroEpUgcAsAToUfZXlJuZzBcdoUON1RmcAVKLGJSJiIiIgiC/2Ixe6fEAAk/msztarijHRBtgsbu56YhMGJSJiIiI2lm1xYmqGif61AZli+38epRjo/W1x3MEYZTUEgZlIiIionZ2prY/uWeXOKhVgSvKttqKcnOrXsRGGQB4gzeFHoMyERERUTvzrXiRnmJChFEXsEfZN0mvuXWUY2orylU1rCjLgUGZiIiIqJ3lF9dAp1UjOT4SkUZtwFUv/BXlZibzxUb5gjIrynJgUCYiIiJqZ/nFNeiUHA2NWoUooy7ghiMOpy8oN9N6Ee1tvahij7IsGJSJiIiI2tmZkhp0TI4CAEQatf7qcX02X+tFM5P5TJF6qFVANSvKsmBQJiIiImpnFrsLpkhv20RkEz3KdocbKpV3U5GmqNUqmKL0qOJkPlkwKBMRERG1M6dLgqG29zjKqIO1ieXhjHoNVCpVs8eKiTJwMp9MGJSJiIiI2pnDKfkrxZER2iZ25nM325/sExut5/JwMmFQJiIiImpHkuSB5BHQ6+pVlO0uCCEafM7ukJpdQ9knlhVl2bQYlD0eD15//XUsXboUNTU1ePXVVyFJUijGRkRERBR2HC5vTvJXlI1auCUB5znbUHsryk33J/vEROu5PJxMWgzKTz/9NI4ePYr9+/cDADZv3ow//elPQR8YERERUTjyBWW9PyjrAADWekvElVfbcaakpnWtF1EG1NickDyixc9S+2oxKH///fd48sknYTAYEB0djTfffBNbt24NxdiIiIiIwo7T5a0cG/ytF94w7OtTXr/tFO54cgMKy6y46pKMFo8XG62HEICZfcoh1+K3MVqtFmp1XZ7W6/XQalv+7oeIiIjol8i3kUjdZL7airLdDbPVidUf7Uf/Hom451eD0TEpusXjxUbVbToSZzIEadQUSIuJt3fv3nj33XchSRJOnjyJt956C5mZmaEYGxEREVHY8VWU9TpvoTHK13phd6GwzAIAmHlZj1aFZMDbowxw0xE5tNh68fDDD+PgwYMoKyvDr3/9a1gsFjz00EOhGBsRERFR2PFP5tPXTeYDAIvdjcJSKwAgNTGy1cfjNtbyabGiHB0djSeeeCIUYyEiIiIKe+dO5ouqN5mvsnaZt9TEqFYfLzbKW1GuMjMoh1qLQfmPf/xjwNeXL1/e7oMhIiIiCnfOc5eHq+1RttjdKCyzIi7agIhWrJ/sY/IFZU7mC7kWWy/i4uL8/0RFRWHfvn2hGBcRERFRWHI4G1aUfaHY16Oc0oa2CwDQatSIjtBx0xEZtPjtzN13393g97fffjtuv/32oA2IiIiIKJw5z+lR1qhViDBoYKkNyn27Jbb5mLHRelaUZdDmLawjIyNRXFwcjLEQERERhb1zd+YDvJuOVFucKK20tbmiDHgn9FXXOOFyS3j5ox+RU1jdbuOlprWpR1kIgYMHD6J79+5BHRQRERFRuHKeM5kP8AblnIJqeASQmtD6iXw+sdEGnCmpwZfbc/C/bafRIT4SGakx7TZmCqzFoBwXF9fg9zNnzsTMmTODNR4iIiKisHZujzLg3Z3vWF4lgLYtDecTE6XHT8ft+GDDUQDcpS9U2tyjTERERERNc7gkaDVqaNQq/2uRETpIHgEASEs6v4pyjc27BbZWo4LZyqAcCk0G5SFDhkClUjV6XQgBlUqFvXv3BnVgREREROHI6fb4J/L5+NZS1mnViDcZ23xM31rKQzM7oLTSxqAcIk0G5c8++yyU4yAiIiK6IDicEgy6husl+HbnS0mIhFrduBDZkk4doqHVqHH9lIvwxqcHYLa62mWs1Lwmg3KnTp38v87OzobVaoUQApIkITc3F7/61a9CMkAiIiKicOJ0SQ36k4G6inJbduSr7+I+HfDuysmINOpgitTjTEnNzx4ntazFHuXly5cjKysLdrsdKSkpyM3NxdChQxmUiYiIiAJwuKQGS8MBdRXl85nIBwAqlQqRtWHbFKnnZL4QaXEd5W3btiErKwtXXXUVXnvtNbz11lswGtveW0NERET0S+AIUFGO/JkV5fpMkTqYrU4IIX72sah5LQbl5ORkREZGonv37jh69ChGjBiBioqKUIyNiIiIKOw4nFLjyXwR3opyWjsE5ZgoPdySgL12GToKnhaDsk6nw65du9CjRw989913MJvNDMpERERETQjUo5yeEoMIgxbdOsb+7ONHR3pXwGD7RfC1GJTvv/9+vP/++xg3bhwOHTqEkSNHcsMRIiIioiY4A/Qo9+wShw+emIbk+IiffXxTbVCu5hJxQdfiZD6TyYS//OUvAIAPP/wQ1dXViInhlolEREREgQSazNeeYqJYUQ6VFivKt9xyCxYsWIC1a9fC4XAwJBMRERE1I1DrRXsyRXonBtZwLeWgazEof/PNN1i8eDE2bdqECRMmYOXKlTh8+HAoxkZEREQUdgJN5mtPbL0InRaDslqtxrhx4/C3v/0Nb7/9Ng4cOIA5c+aEYmxEREREYcfh8kCvbTFinTf/ZD4G5aBr8Sm63W589dVXuOOOO7Bw4UIMHDgQa9euDcHQiIiIiMKL5BFwSx4Y9C1OAztvOq0aEQYtg3IItPgUx4wZg169emH+/Pl4/vnnodfrQzEuIiIiorDjdHnXNjbogldRBgBTFHfnC4UWg/L777+Prl27hmAoREREROHNF5SDOZkP8O3Ox8l8wdbitzsMyURERESt43D6KsrBDsqsKIdCcH8uQERERPQL4ghRRTkmUs8e5RAIelB+6qmnsGzZsmCfhoiIiEh2vqAczOXhgNoeZQbloGuyR/mrr75q9guvuuqqFg/+/fff4+OPP8bll1/e5oERERERhZtQ9ShHR+pQY3NB8gho1KqgnuuXrMmg/M477zT5RSqVqsWgXFlZiWeffRZ33HEHNyghIiKiX4RQ9SjHROohBGC1u/wbkFD7O6+g3BqPPPIIfve736GgoOBnHYeIiIgoXNQtDxf81gsAMFucDMpB1OLycKdPn8a//vUvWK1WCCHg8XiQk5OD999/v8mv+fDDD5GWloZRo0ZhzZo17TpgIiIiIqVyujwAAH2w11Gut411x6Ce6Zetxae4ZMkSuFwu7Nu3D506dcLx48fRu3fvZr9m/fr12Lp1K2bNmoXnn38eGzduxBNPPNFugyYiIiJSIofLDQBB3ZkP8K6jDIBLxAVZi0/RYrHgsccew6pVqzB27FjccMMNuPnmm5v9mn/84x/+X69ZswY7d+7EQw899PNHS0RERKRgjlBVlH2tF9x0JKhafIpxcXEAgIyMDBw7dgwxMTHweDzBHhcRERFR2AnlZD4AXCIuyFqsKGdkZGDVqlWYM2cOHn74YVitVjidrX8oc+fOxdy5c3/WIImIiIjCgdMdmqAcadRBrWLrRbC1WFFesWIFhg0bhr59+2L+/PnYvn07Hn/88VCMjYiIiCisOJwSNGoVNJrgtl6o1SpERXDTkWBr8Sm++uqrmDRpEgDguuuuw0svvYT169cHfWBERERE4cbpkoK+K59PTJSOPcpB1mTrxfPPP4/q6mqsX78eNTU1/tddLhc2btyI5cuXh2SAREREROHC4ZKCviufT0yUAZVmR0jO9UvVZFAeNGgQfvrpJ6jVav+EPgDQaDR44YUXQjE2IiIiorDicElB70/2SYw14uSZqpCc65eqyaA8btw4jBs3DmPHjsXAgQPhdrshhIBOpwvl+IiIiIjChjOEFeWkuAjsOlQEIQRUKlVIzvlL02KPcseOHbFo0SIMHjwYAwcOxA033ICioqJQjI2IiIgorDicEgxBXkPZJzHWCIdTgsXGPuVgafFJPv744xg8eDC2bduGbdu2YdiwYVixYkUIhkZEREQUXpwuT9B35fNJjI0AAJRV2UNyvl+iFoPy6dOncffddyMmJgbx8fH47W9/i9zc3FCMjYiIiCisOFxu6LWhqSgn1Qbl0ipbSM73S9Tik3S73XA46mZU2mw29sEQERERBeCtKIduMh/AinIwNfmzAafTCb1ej6lTp+Kmm27y7663Zs0a/7rKRERERFQnlMvDxccYoVIBZZWsKAdLk0H5mmuuwccff4y77roLqamp2Lx5MzweD+bOnYt58+aFcoxEREREYcE7mS80QVmnVSM22oBSVpSDpsmgLITw//rqq6/G1VdfHZIBEREREYWDCrMdHo/wT6oDanfmC1FQBoCkWCPK2KMcNE0GZYfDgezs7AaBub5+/foFbVBERERESvfKmv04nl+F15ZNgEbjnfYVytYLwLvyRVG5NWTn+6VpMijn5eXhnnvuCRiUVSoVsrKygjowIiIiIiUzW1woLrdi2/4CXDakEzweAZc7dJP5AO+EvuxTZSE73y9Nk0G5Z8+eWLt2bQiHQkRERBQ+XG4JAPDxt8cxZnBHOF3e34e6omy2ukK6dfYvSWgW+iMiIiK6wDjdHqjVKhzLq8TBk2Vw1AblkPYox/mWiGOfcjA0GZSHDRsWynEQERERhRWX24OL+3RATJQeH2w4ihNnqgCEuKIcU7s7XyVXvgiGJlsvli9fHspxEBEREYUVt9uDKKMOMy/rjn99cRj7jpYAAKIiQrOFNQAk1laUuTtfcITuSRIRERFdQJxuCXqdGr+a2Bv9eySh0uyA0y1heN/UkI3BtzQdd+cLDgZlIiIiovPgcnug1aqhUqnQr3uiLGOIMGgRZdRyd74g4WQ+IiIiovPgckvQa+VfaSIhNgJl1awoBwODMhEREdF5cLk90Gnlj1JJsUaUsqIcFPI/XSIiIqIw4/EIuCWhiKCcGBvBHuUgkf/pEhEREYUZl+QBAEUE5eT4CFSY7f4NT6j9yP90iYiIiMKMy+0LyvL3KHdJMUEIIL+4Ru6hXHAYlImIiIjayOXfrlr+KJWRagIA5BRWyzySC4/8T5eIiIgozPgryhr5o1TH5GhoNSrkFDAotzf5ny4RERFRmFFSj7JWo0bnDibkFJrlHsoFR/6nS0RERBRmfBPndDr5e5QBID3VhFy2XrQ7BmUiIiKiNqqbzKeMKJWRGoPiChusdpfcQ7mgKOPpEhEREYURX1DWKyYoeyf05Rax/aI9KePpEhEREYURl7u29UIBy8MBQEZaDAAgp4BBuT0xKBMRERG1kdJaLzrER8Kg17BPuZ0p4+kSERERhRGnwoKyWq1CeooJuVz5ol0p4+kSERERhRGlVZQB74Q+bjrSvpTzdImIiIjChH9nPoX0KANARpoJFWYHqmoccg/lgsGgTERERNRGStpwxKdr7YS+9dtOQwgh82guDMp5ukRERERhQomtFwN6JuOywZ3w3peH8fonB+DxtH9Ydrk9eG3tTyivtrf7sZVIOU+XiIiIKEwobWc+ANCoVbh/wVDMGtsDn24+ibXfnmj3c5w8U4l1m09i7+Gidj+2EjEoExEREbWR21dR1igrSqnVKiya1R9dUqKRfaqs3Y9fWumtJNfYfhk7ACrr6RIRERGFAafbA61GBbVaJfdQAgrWChgllTYAgNnKoExEREREAbjcHkX1J58rIy0GhWVW2B3udj1uaW1QrrE62/W4SqXcJ0xERESkUC63BK1GOf3J58pINQEAcovadwOSuqDMijIRERERBeBye6DXKTdGZaR6l4pr7y2tS/2tF6woExEREVEASm+9SEmMgl6rRk47b2nt61GuP5lv2/6zeOZfe1BWZWvXcymBcp8wERERkUI53RJ0CtqV71watQpdUk3IKWi/irJb8qDCXLvqRb3Wi60/nsW3+/JxzzObsDO7sN3OpwQMykRERERtpPSKMuBb+aL9KsrlVXYIAeh1GtTY6lovKmsc6JQcheS4CKx6cweKyq3tdk65KfsJExERESlQeARlE8qr7e3WT+xru8hINaHG5vLv/FdV40B6agwWze4PjwAKyyxNHqO00oZfPfQZjudVtsuYgk3ZT5iIiIhIAXILqzHvwc/8IdDl9kCv4NYLAEj3T+hrn6qybyJft46xEAKw2r3tF5U1DsRGGxATpQcAVFuaDub5xWbYHBIO55S3y5iCjUGZiIiIqAVnSmrgcEo4W+oLylIYVJS9Qbn+xiMOl4THXt+OU2er2nw8X1DumuY9bo3NBckjUG1xIjZaXxeUaxxNHsNs8Ybrgmaqzkqi7CdMREREpAC22o07fP92upTfepEUZ0SkUdtgQt/xvErsPlSE/cdL23y80kobIo1apCREAvAuEWe2OCEEEBdtgCmy5YpydW0bSGFpePQxa+UeABEREZHSWe21Qbm23SAcepRVKlWjCX2+6nJVM1XfppRU2pAUF4GoCB0A78oXeq33OHEmA7QaNaIidM0GZV+/NCvKRERERCEkeQT+8t4eHMuraPdj+yrJvsDskpQflAGgW8cYnDxT5Z94d7q2utxcmG1KWZU3KJsi64JypdkblGOjDQCAmCh980G59r2iMot/TEqm/CdMRERE1AqllTZs2pOPD7OOtfuxz229cLkk6HXKnswHAL3T42FzuHGmpAYA/G0Y51NRLq20IzkuAtG1LRZmmxOVtceJqw3KsS0EZV/rhdNdtyazkjEoExER0QXBF7x2Hiw8ryDYHJv9nIqy2wOdRvkxqleXOADA0dwKCCHqBeW2VZRdbgmVNQ4kxUUgul7rhe8+11WUDc0H5XrvFZYpv09Z+U+YiIiIqBV8bQCSR+Dbvfntemyrr/XCUa/1Igwqyp06mBBh0OJobgVKKm2w1Ab9akvL30jYnW5k7crF9z+dRWml95uQpNgI6HUaGPQamK3eirJGrfKH55goPaqaObbZ4kRaYhQAoKBU+X3KnMxHREREF4SK2qCcFBeBrF15mDm2R7sd2996Ya9rvQiHHmWNWoVeXeJwNK/SX03u1jEGJRW2Zr/u318dwaffnUCNzTt5cXjfFABAclwEACA6QocaqwtqtQqx0Xqo1SoAdT3KQgioVKpGxzVbnejROQ5F5ZZmNyZRCuU/YSIiIqJW8FWUZ43tgZNnq3DyTN1awQ6XhH9/eRj22sDbVv7JfA4XJMkDj0BYBGXA235x+myVfze8AT2TUGNzwS15An7e5fbgvS8Po0uKCX+8YzQmDk/HruwiAEBSvDcomyL1qLE5UWl2+NsuAG9Qdrk9sDulgMc2W5yINxmQFB8ZFitfhMcTJiIiImpBhdkOU6QeVwzrAq1Gjazduf73dmUX4r2vjuCHYyXndez6PcpOtzdg6sMlKKfHwy0JbNqbj+T4CHSsbX0wN9FLbKmtIo8b0gmDeiXjt9cMxvVTMtE1LQYdaoNyVIQO5toe5XODMhB4VQ1J8sBidyMmUo+0xEhWlImIiIhCpdLsQHyMdyvlwb2Tsfdwsf+9IzneJeMqqs9vpQVrvVUvXLVBWRsmQbl3l3gAwNlSCzJSYxBTG2ybmnRnqV0r2rdeskqlwjUT++CF+8dDV7tttylSB4vNhcoaB+JMdUE51n/sxn3KZqv3uKYoPVITo1AQBpuOhMcTJiIiImpBpdnhX6asX/dE5BfX+FdlOJrrDcrl1ee3Gkb9HmWX29tWoNcqfzIf4N2hL742zHZNi0FstLfq29SkO19F2bcMXCCmSD3MVieqauruOVBXUQ60qoYvPMdE6ZGWGAWz1ek/l1IFNSi/+OKLmDZtGqZNm4ann346mKciIiKiXxjJIxr02VaY7Yg3GQEAfbslAACyT5XDLXn8/bnnu3Zv/R5lX0U5XHqUVSoVeqd7q8oZaTGIjfIG26aWiKuprfxGGXVNHjMqQodKswN2p9Tq1gt/RTlSj9Sk2pUvFN5+EbQnvG3bNmzZsgUff/wx1q5di4MHD+Lrr78O1umIiIjoAuer5Pq8/Xk2lr642f/7SnNdG0CvLnHQadXIPlWG0wXV/r7isqq2B2UhxDkV5fAKykDdespd02IQU1tRrm5irem6inLTQdkUqYdUu7NeXHRd5bm5oOx7zVRbUQaAIoWvpRy05eGSk5OxbNky6PXeG9ajRw+cPXs2WKcjIiKiC1hxhRW3/2kD/nTnGGR29VaLj+ZW4HheJVxuCW5JwO6U/C0GOq0GvdPjkX2qDGm11csuKdHnVVF2uj3weASMeg3sTskfmnVh0noBAJNGdoXRoEVGqsm/dXRVEz3KNTbv674e5UDqh+j6FeVIow5qtaqJHmXvcWMi9f6v/8VWlHv16oXBgwcDAE6fPo3169dj3LhxwTodERERXcAKSixwSwJHanuNAaCozAKP8O7w5lsarv7Esr7dEnAivwr7j5UiLtqAzIyEgJP5Tp2twpNv74LdGXjpON+KF4mx3hUffJXRcKoox5kMmDW2B1QqFTQaNUyRuiZ3L/StndxcUDZF1FWR699ztVqFmMjA21ib61WUI406xETpFb/yRdCf8LFjx3DLLbdg6dKl6Nq1a7BPR0RERBcgc22V07ebm9Mloaw29OYX1/grxb4eZQDo2y0Rkkfg+wMF6J0ej4QYIyrNDn/LgM93+85g6/6z2H2oKOC5rQ5vcEyM9R7bFzD1uvAJyueKiTI0WVG22FzQadUwNLPzYFMVZQCIiW4iKFud0GrUMOq9x02KjTivVphQCuoT3rNnD2666SYsWbIEc+bMCeapiIiI6ALmq0b6gnJxhRWiNu+eLakJWFHO7JoAlQrweAT6ZMQjPsYIj2jcm+tbEWPLD4FbRH0V5YRzgrJOEz6tF+eKjdajuqnJfDZXs9VkoIWgHFUXlGusTn+FutriREyUzr9jX2KcEWVVze8QKLegBeWCggLcddddeOaZZzBt2rRgnYaIiIh+AaqtDYNyYb1JYGdKavzbV8fXC8rRETp0TYsBAPRJj0dCjPe9snrtF5JH4FheJdQqYNehIn//cX2+1xJjfEE5/FovzhUbbWh2ebjoFoKyqXbpuAiDtlHl2RuUvcf+4z924ul/7gLgDcqmekvOJf6SK8pvvPEGHA4HnnzyScyaNQuzZs3Cv//972CdjoiIiMKcJHmw9MXNAVsgzBZvVbKowgq35EFRbW9rWlIUztRWlFWqulUXfPp1T4RarUKv9DjE1wbd+n3K+cVm2BxuTBieDqdLwu7sxuf2B+XaHmVfwNSFdevFz6wo175fv4Jfd2wDqi3eNZazT5Uh+3Q5JMkDs9WJmKi6zyfFGlFtccLpCrzdtRIEbdWL5cuXY/ny5cE6PBEREV1gzpZakH2qHAdOlGLYRSkN3vOtmODxCBRXWFFYboVeq0b/7onYmV2ILikmxEYZoNE0DK/XXtkHowd0RKRRh4Ta/uX6m44cq227mD2uB3YfKsKW/Wdw2ZBODY7hC8p1rRcXRkW52uqExyOgVqsavGexuWCKanqzEcC7uoVKhQabjfjEROlhtjix53AxhAAcTgk5hWaYrU50STH5P+fr+S6vtiO1drk4pQnfJ0xEREQXlLwiMwCgMsBqDNUWJ3x5rqDUgsIyC1ISo9C5QzSqapzIL64JWN2MjTZgQM8kAEB8betF/SXijuRWIsqoRecOJowe2BG7sxu3X9RVlI21Y6mdzBdGy8OdKzZKD49H+PuH62tN64VarUJ0hM6/y199MVF6eATw3b586Gu/mTiSWwGzxdWg9SKhtkKv5PYLBmUiIiJSBF9QDrRjnNnqRHqqt9/YG5StSE2MRKfkaADeCXmBgnJ9Oq0Gpkg9yuu1XhzNrUCvLvFQq1UYM6gjnG4P9h4ubvB1dT3KEQ3GF84V5Zho3+58jb8paU3rBQCM7J+GizNTGr3ua3/Zd7QEowd1REyUHkdzKmpbL+qCclLtNx6llcqd0Be+T5iIiIguKLnNVJTNFu+P7SMMGpwttaCo3ILUxCh06uANyi63p8WgDAAJMQaU11Yw7U43ThdUo3eGd3vnPhkJUKtVOHm2qsHXWGtXvfBVpH0V5XAOyrFN7KAnhGhVRRkAfnvNEEwZ1TXAsb33yeMRGJqZgt7p8fjhaDEkj2g0mQ9gRZmIiIioRbmFvopy4F3dTJE6pCVG40hOOWwOCakJkUhJiPL32NZfQ7kp8TFGf+vFyTNV8HgEetdu76zTqpGWGOmvbPvYHG4Y9RpoNWpEGDSwOaTaz4dx60UTFWW7U4LkEa0Kyk3xVY1VKmBI72T0To9HaW0Yrh+UI41aRBg0KKtmRZmIiIioSZLkwZmSGgBApdkBIeo2BZFqe2lNUXqkJUXhWF4lACA1MQo6rRqpCZEAAk8sO1dCjNE/me9orvc4vdPj/e937mBCfnHjoBxh8K5/4Ps3AGg1DSfBhRNfb/G5m45YWrErX0t8Qbl3ejxiow3onR7X6D0AUKlUSIiJQFklK8pERERETSoqt8Ll9qBLigkut6fBhDqLzQUhgJhIb1D2ZeiURG9A7ljbp+xrjWhOvMmASrMdQggcPFmK5PgI/7JxANAlxYSzJRa4JY//NZu9flD2Bki9Vu3fOCMc+QLruZuv+IJydETzq140J9ZkgF6nwSX9UgE0/EakfkUZ8E6QVPKmIwzKREREJDtff/LA2hUq6vcp+5aG81WUfVJqK8mda/uUW1VRjjXCLQnkFpqxK7sIlw7s2OD9LikmSB7h39gEAKwONyKM3qAcWfvvcO5PBrxtI5FGbaOKco2/onz+KwgbdBq89MB4zL28JwBvOO5Y+9xMUQ0r1UlxEf62DCUK76dMREREFwRfX3D/HokAgCpzXYDzbV9tiqwLyvEmA4x6b5jzBeWEmJZ7lH2f+c+Go5A8ApPPmYzWJcV7rPrtF4FaL8K5P9knNsqAKnP7V5QBb1tM/TWtfRMm6284AngryhXVdng8AkoUtA1HiIiIiFort8iMpFgj0mo3nqhfUfZtX22K1CEpzrtSQv0NKsYN6QytRo30VBNa4pvwt+XHMxjYM8m/vJxP5w7eY+QV1WDUAO9rNofbv4ayv6Icxrvy+STHR6DknKXZamzee/1zepQDufzizjBbnI0mCSbGRkDyCFTVOBq0wCgFgzIRERHJLq/IjPTUGP8Sbw1aLyx1rRfxJiP0Oo2/PxkAjAYtJgxPb9V5fBVlIYApo7s2ej/CoEVSXATy6leU7W5EdPC1XniDnk4T/kE5JSGy0XbhNe0wmS+QoZkpGBpgzWXfNyClVTZFBuXwf8pEREQU1jwegbyiGnRJMfl/NF/VoEfZG95iIvVQq1W475oh/v7XtvJN+IuLNuCSfmkBP9OlQzTyi5pvvdDrwr/1IjUxChVmB+zO+hMnvb+OMoamluoLykpdS5lBmYiIiGRVXGGF0yWhS4oJOq0a0RG6Br2zZqt3+2pfNfeyIZ3QrWPseZ3LqNeia1oMZo3r0eSEvC4pJuQX1/j7Zq31grKv9UIb5pP5ACC1tipfVG71v1ZjcyLCoG3QXxxMSb5NRxS6Ox9bL4iIiEhWvol8vol0sdGGRq0X0bXV5Pbw/JLLm32/c4oJdqeE0iobEmOMcLokf0j3T+a7AFovfH3eRWVWZNRuD26xuRAd2b5tF82JjTZAo1ahrJoVZSIiIqJGSmurib7l3uJMhkaT+c5df/fnUKlUza6B3KV2FY38ohrYnN5d+PwVZX/rRfhHKN/9LiyrWwqvxupClDF0QVmtViEh1sjWCyIiIqJASqvsUKtViKtdkSI2Wt+wR9nibLCjW7B1Sald+aLYDJvd27Pr71H2Tea7AJaHi4nSI8KgQWG91guL3dXuE/lakhhj9H+zpDQMykRERCSr0kobEkzeH8ED3ol2lfXXUW7ninJLYqMNMEXqkVdkhs3hnUgYabiwNhwBvJX1lISoRhXlc5dwC7YO8ZGoqZ2wqTTsUSYiIiJZlVfZkVg7qQvwBmWz1QlJ8kCjUcNscaJ7p/ObvHe++mTEY9/REkwc4V12zrczX92GI+EflAHvhL6z9XYhlKOivHDqRQ1+gqAkF8ZTJiIiorBVWmVDYlzdGrqxtWspV9eun1xtdYW0ogwAowakobjcioMnygCg0aoXF05QjkJhmRVCeFf4CPVkPt8Y+mQkhPScrXVhPGUiIiIKW2VVNv8yYYC39QHwbjricElwuqSQ9igDwCX9UqFWAVm78wDUD8reEKm/AHqUASA1IRJOl4RKswOSR8BqdyM6hJP5lI5BmYiIiGRjtbtgc0j+jScAb+sFAFSaHXW78oW4ohwbbUC/7kn+pevO3XDkQqkop9QuEVdYZoXVHpxd+cLZhfGUiYiIKCz5Vjto0KNsqtudz2yt27461EYNqNu579zl4S6UoOzbdKSw3OKfUBfq1gsluzCeMhEREYUl3/q59SvKda0XTn+fckyIK8oAMLJ/vaBc25ts0GuQFBeBtKSokI8nGDrER0Kl8laULbbaijJbL/y46gURERHJpqzKW1FOiqurKEcZtdBqVKg022G2egO0HFXO5PgI9E6Pw4n8KuhrK8gqlQpvPHwlmtmvJKzodRokxhhRWGbBwVPeiYtyVO+VikGZiIiIZFNaW1FOiKmrKKtUKsRGG1BV40RFtXfZsFBP5vOZe3kv7DpU2GAnv/baSlspUhKjsPNgITbuzsPg3snonR4v95AUg0GZiIiIZFNWZUdMlB56XcNVJGKjDdi0Nw8bduVCp1XLFpQvHdQRlw7qKMu5QyU1MRIHT5Zh2EUpePDG4dBq2Jnrw6BMREREsimtbLg0nM8Vw7rgh6MlGNAjEcMuSrkgtoxWqonD02GK1OOGqRfxPp+DQZmIiIhkU15lR0K9iXw+s8b2wKyxPWQY0S9P/x5J6N8jSe5hKBJr60RERCSb0ipbg4l8RErCoExERESycLokVFucSApQUSZSAgZlIiIikkV5deM1lImUhEGZiIiIZBFoVz4iJWFQJiIiIlkE2pWPSEkYlImIiEgWgXblI1ISBmUiIiKSRXGFDREGDSKNod+emqg1GJSJiIgo5IQQ2Hu4GH0yEuQeClGTGJSJiIgo5E4XVKOgzILRAy/s7aEpvDEoExERUcht218AlQoY2T9V7qEQNYlBmYiIiEJu209n0bdbIuJNXPGClItBmYiIiODxiKAe3+WW8PWOHJRX25FfbEZuoRmXsu2CFE4r9wCIiIhIPkIIfLzpOP791RGs+s2l6J0e3+7nqLY48cRbO3HwZBlMkTpkdvVO4Bs9MK3dz0XUnlhRJiIi+oVyuSU89599+Mdn2bA7JXy370y7n6O4wor7n/8OR3MrcOvM/khNjMKu7CL0yYjnjnykeKwoExER/QJJkgdP/XM3dhwsxHVX9cHh3ArsPFiIW2f2g0qlarfzfJh1DGVVdqy641Jc1C0BM8Z0w1c7ctC9U2y7nYMoWFhRJiIi+oURQmD1mv3YcbAQt88ZgF9PysTIfqkoKLMgr8jcbuexO934bl8+Lh2Yhou6edstNBo1pozuxvWTKSwwKBMREf3C/HfjMXy5PQfzJ/TC9DHdAQDD+3qXadtxsLDdzrP9pwJY7W5cOSKj3Y5JFEoMykREIXDqbBUsNpfcwyCCEALrNp/ExZkdsHDKRf7Xk+Ii0LNzLHZlF7Xbub7emYvUxEj0657YbsckCiUGZSKiIHK4JLyyZj9++5dNeOd/h+QeDhEKyiyoMDswsl9qo17kEX1TcTinHJVmx88+T2GZBfuPl2LC8HSo1e3X80wUSpzMR0QUJBabC0tf3IycQjNMkTpknyqTe0hEyD7p/XPYN0CVd0S/VLz31RE8+vfvUW1xonNyNFbcNhIaTdvrav/bdhoqFXDFsC4/e8xEcmFFmYgoSPYeKUZOoRn/t3AYpl7aDTkF1bA73HIPi9pRYZkFr39yAC63R+6htFr2qXKYInXo0sHU6L3unWIxsGcSPB6Brmkx+OFYCdZsOt6m49udbrzwwQ9Ys+k4Lh3YER3iI9tr6EQhx4oyEVGQHM2tgE6rxqgBaTDqNfAI4Hh+Jfr3SJJ7aNQKQnh3qmtuqbR1W07i0+9Oom+3BIwOk13mDp4sQ99uiQHbIVQqFVb95lIA3ut/8p+78N6XRzCiXyoyUmNaPLbDJWHpC1twqqAK8yf0wnWTMtt9/EShxIoyEVGQHM2tQI9OsdBq1P7dzo7kVMg8KmrJM//agzn/tw4z7/8Ut/8pC24pcLVYCIEdB7wrRHyzJy+UQ2wVl1tqNIG0otqOs6UW9O3W8tJsKpUKv5k7CJFGLZ79916UV9tb/Jr/fH0EJ89W4cEbh+OGqX2hPY+WDSIl4Z9gIqIgcEseHM+vQu8Mb0COjTYgLTEKR3IZlJUsv9iMb/flY3DvZIwf2hkFZRYcPl0e8LOnC6pRVG5FUqwRuw8VodriDPi54/mVuO4P65FTUB3MoTfyt3/vw91/3girvS4sZ5/yXkug/uRA4kwG3D1/ME6frcZtT2zAP9dnw+GSAn72dEE11nxzHFcM64JRA8Kjuk7UEgZlIqIgyC00w+mS0Ke2kgwAvdPjcZRBWdH+t+00tBoVfnvNYNwxdyA0ahV2Hwq8XNqOg4VQqYB7fjUEbklgy4+Bt3/esDMXZqsLX+3MaffxbtydhxtWfIHn/7MPPx0v9beL5BebsfnHMyitsuM/Xx/1f/7gqTLodRr06BTX6nOMGpCG1UsnYGT/VHyYdQz/WHewwfkfenkr/rk+G8//Zx8ijTrcMqNfu10fkdwYlImIgsBXOe5dPyhnxKGsyo7SSptcw6Jm2B1uZO3KxeiBHRFvMiLSqEPfbonYc7g44Od3HChAn/R4DOmTjIxUE77Z3bj9QpI82PrjWQDAd/vOQGqijaO1dh8qQlWNd+k2j0fgP18fgRDAlh/P4KHVW/HfjccAAGu+OQ6dRo2R/VPx6eYTyC/27rZ38GQZMjPiodO27X//aUlReOD6YZg+phvWbzuFY3kVyCmsxksf/oC8YjPWfHMcx/IqsWhWf8RGG37WNRIpCSfzEREFwdGcCsRE6ZGSUDfjP7N2y94juRVIiouQa2jUhE1782GxuzHt0m7+14Zd1AH/+CwbpZW2Bs+spMKG4/lVuHFaX6hUKowf2gVvfZ6NdZtPIiZKj4G9khBvMuLAiTJU1jhw+cWdsWlvPn48VoqLMzuc1/iyT5Xhsde3Y1CvJDx++2jsPVKMs6UW3L9gKC7pn4rn3t+Hd/53CHHRBnyzJw+TRnbFNVf2xh1PZuHZf+9FXLQRp85W4ZqJfc77Hl0/+SJs/fEsXv7vj3BLAhFGLZ5fcjmMei2Ky63ISGt5wh9ROGFFmYjO24ETpZA8Qu5hKNLRvAr0To9vsGJCt44x0GrUOMoJfYojeQQ+33oKXdNicFHXuoluQy9KAYBGVeUdBwsAACP7e7d9vnxoZxj0Gry29ic88+4ePPD8ZtRYndj84xlEGDS4fe5AREXo8M3e85/09+8vj0CtVuHHY6XY8sNZfPrdCSTEGHHpoI4w6rW495ohyEiNwfMf/ACPAGaP64F4kxHXT74IR3MrcaqgCjPGdMecy3uc9xiiInS4dWZ/HM+vwumCatx7zRDEm4yIMGgZkumCxIoyEZ2Xo7kVePDlrVg8ewBmXNZd7uEoitXuQl6RGWMGdWrwuk6rQY9Osdh/ohQej+BuZQrhcnvw1/f24HRBNX7364sbfHOTnmJCUlwE9hwuwqSRGZAkD9Z+ewLvfXkYXdNi0Ll2LeLE2Ai8s2IyzFYncgqqseofO/HXf+/F4dPlGNE3DdEROowZ1BGb9ubD5nAjwtDy/34rzHY4nBJSE6Nw8GQZfjhWgpun98XmH85g9Zr9MFuduH5Kpn9lCaNBi4duGoElz32Hkf1TkZoYBQCYPqYbLumXiuT4iGaXumutsUM64acTpUiOi8Dwvqk/+3hESsagTETn5cCJUgDA+m2nMH1Mt3b5H/CF4nh+JYQAeqfHNXpv/LAueGXNfvz7qyNYMJlrzMrN7nTjT2/vwt7Dxbh5er9Gu8ipVCoMuygF3+7Nw4dZR7Fxdx7yi2swakAabp8zoMFnIwxaRBi06BAfiVtm9sPf1x4A4A2WADB+aBd8uT0Hm/bkYcrobmjK4ZxyrN10AtsPFEDyCFw5Ih1nSmoQZzJg6qXd0L9HEu5//jvotGpMHtm1wdemJUXh9YcnwqCv+9+7SqVCh4T22/RDpVLh7vmD2+14RErGoExE5yX7VDlUKiC/uAY/nSjFwJ7JbT5GUbkVSXER0FxgldX9x73fRNSfyOczdXRXHM+rxPtfH0HnDtEYd3HnUA+P6nnnf4ew70gx7vnVYFx1SUbAzwzL7IAvvj+Nf64/hMyMeDx44/AWNxeZMaY7juVW4sDJMgzp4/1v46KuCcjMiMcrH/8Eo0GL8UMbb+28/3gJHn1tOyIMWv9PatZtPgnJI3DrzP4w6rXonR6Pm6b1g1qtCjhxLtKoa+ttIKImMCgTUZsJIZB9qhyXDeqEvUeKsX7b6TYH5b2Hi/Ho379HcnwErhyRgeljusEUqQ/SiEOnxubCZ1tOYXjflIDXo1KpcOe8gSgos+C5/+xDeqoJ3TrGyjDS0HK5Jei0GlnObbY68dmWUxjRNwU9Osf5Xz+aW4HPNp/ElFFdmwzJADC8byqW3jAMPTvH+dsZWqJSqfD76y6G0+3xX7darcJji0d52zLe24ufjpcizmRAbLQBg3slwyMEVv1jJ9KSovDU3WP8f36uuiQDOw8WYurorv7jzx3fs+03gojajEGZiNosv7gGZqsTg3onIyHWiHWbT6K82o6EGGOrvl4IgXe/PISkWCM6JUXjvS8PY8/hIvzpzjFtXrYqmIQQOHy6Aj27xLV6XGs3HYfF5sL1ky9q8jM6rQYP3jgcv/3LN3j6nd149r5xMNbrWfVtXBETFf7fOADA1h/P4q/v7cGEEem4fc7AVv8E4eDJMny3Lx/XTco87yXHjudX4k9v70JxuRXvfXkYowakYdql3dAnIx4vffgj4kwG3DC1b7PHUKtVjfrNW0OlUsGga/jNQaRRh0cXjcQLH/6ArfvPwu6U4KmdEKtWAQkxRjx226gG32R1STGhS4qpzecnop+PQZmI2sy/u1e3BPTvnoi1357A3X/eCKfbg3iTATdO64tLB3Zssm95z+FiHM2txN3zB2HSyK7Y8uMZPPXP3Xjr84O4eXo/vPflYXy77wwevHE4etarABaWWfDxpuM4kluBeJMRKQmRmDQyIygVWSEE3vosG2s2HceIvqlYduOwFiuiVTUOfLr5BMYM6ojunZofU2y0Ab//9VD84bVt+PsnBzBheBds3X8WPx4tQU6hGXqtGo/cOhKDere9peV82R1u6HWa855kuPNgIWpsLnTvFIuUhEjotGpk7crFy//9EYlxEfjfttOoNDtw/4Kh0Osa30uPR0Cl8gbM7/bl49l/74Nb8mBndhEevmkEenaJa9U4XG4PDpwoxfYDBfh6Zy5iow344+2jkX26HGu/PY7vfyqAVqOCWxJ48MbhiIoIbauCXqfBkuuGAvD+OSursmPP4WIcOl2GuZf3RHI8lw4kUgqV8G3joxD5+fmYMGECsrKy0Lkze/eIlOjZf+/F7kNF+Ndjk6FSqfDfjceQV2RGTJQePx4rwamz1ejeKRY6rRo1VifiY4zokmJC326JGNk/FctXb0OF2Y5Xlk30V2pfW/sT1m0+iS4pJuQVmRFh0MKg0+Dpey6DTqvGP9dn49u9+VCr1ejXPQFmqwtnS2pgd0oYPTAN44d2Qe/0eJRUWPH51lM4dbYav7/u4jaF6IpqO8qq7OjUIRqfbTmJf64/hL7dEpB9qrzZsHw0twLH8yux40AhfjhajBcfuKLVFcC3P8/2bxKh06rRv3si+vVIxJYfzuJsqQUrbhuJAT2SWn0N56ug1IL/e2Ez0pKi8MiikYiO0CG3sBqb9uZjwvB0dEqObvJrhRB453+H8GHWsYDvD83sgGU3DseX23Pw+icHkJ5qwvWTMzGyf5r/m6nNP5zBqx/vh9vtQWpSFE7kV6FvtwT8+qo+eP6DH1BldmDskM4YPTANfTISYIrUwS0JnC6oQk5BNapqnKisceB4fiWO5lbC6ZJg0GtwSb9ULJ49wF+Rtjnc+Ol4KXYfLkJ0hA4Lp1zEiahEv2At5c6gBuV169Zh9erVcLlcuOmmm7BgwYIWv4ZBmUj5Fv9pA9JTTFh+yyWN3pM8Al/tyEHWrlxE6LWIitShvMqO3MJqWOxuGPQaOJySv5rs43J78ODLW5BXZMbd8waja8cYLH1xC3RaNSx2FzwegeljumPW2O5IjPVW3GpsLnzy7Ql8uvkErHa3/1i+kO2SPPjDLZfAanfh862noFGrMaJfKpLijPjhaAlyC824bHBHjB3SGRt25eIf6w7C7pT8xxk3pDN+f93F+GL7aaz+aD8SY40YNSANI/qmok9GPJwuD/6+9id894N362KDXoPZ43o023ZxLrfkwYdZx5CWGIkR/VL9E7EqzQ48tHoLSipsuHv+4CYn/QkhkFNoRmKs0f/jeovNBadbQrypda0w1RYn/u+F71BZ44TD6UZ6SgzGXdwZ735xCE63B2oVcPnQLhjeNwVpiVFIS4ryj7O82o4Ps47isy2nMGlkBmZc1h2nzlajvMoGl9uDqAgdJo3s6v+GaOfBQry57iDOlNSgY1IUenSOg9MlYcfBQvTqEodeXeKQX1yDzh2icevM/tDrNKiqceAfnx3E9p8KYKl9zlqNqvb+1f0vTKtRo2ua9xuygT2TMLhPh0atD0RE9ckWlIuKivDrX/8aa9asgV6vx7XXXou//vWv6Nmz+QkIcgVls9WJzzafhFarRrzJgH7dk5CW5J20IYSA0+3hX7hE8FZdb3jsS9w8vV+bJhR5PAIHT5Zhw65cVFuceOimEY36fh0uCS63B9G1Pwo/klOOFX/fjkG9k3Hz9H4Ndrk79+tO5lfhaF4FDDoNxg7phBqrC4+8tg1nSiwAgMRYIzRqFYorvNtHazVqJMYaUVRu9Yf3wb2TcdUlGThbWgONWo3Z43r416jdmV2Ir3fkYO/hYn941Ok0kCQPfjWhNyaOyEBirLFd10Yur7bjT2/txOGcClw2uBOmju6KxNgIqNUqlFXZcDS3Al98f9p/jR2TouD2CBSXWwEAnZKj0CcjAS63BzVWJ/Q6DWKi9LX/GGA0aGB3uLFtfwFOnq3CH+8YDZvDjSfe2gWnS8LQzA64cVpfbNydh/VbT8Hprtt+OTZaD51GjdIqOwBg5tjuWDSzf6uqs5Lkwaa9+djy41nkFplRVePAvCt6Yf4VvaDRNN0L7nJ78NPxUuQXm1FhdkAIgZ5d4tC9UyziTUYY9RpWh4moTWQLyh9//DF27dqFJ554AgDw0ksvQQiBu++++2cNOFhyCqvx4EtbYbY6/a91TYtBVIQOp89W+SthcdEGxJkMiIs2QK1WwS154HZ7/LuTxUUbEBdjQLzJiIQYQ4O1LInCmgAsdheyT5Uha1ce/nzPZcist4NZ0E4rxHmHn6oaB/71xWH065aAMYM7QaNW4XRBNSrNDlzUNQEGvQb7jpZg4648DOiZiKsuyWjxXDaHG4dOlePQ6XKUVdkwe1wPpKcGb0cySfLgo2+O470vDwfcBfGirgm4YlgXmK1OHMmpgE6rRvdOsdCo1fjpRClOnqlChEGDqAgdnC4Pqi0OVFucDSqxBr0G914zBJcN9k5YO5ZXgbMlFowd0sl/P+wONwrKLDhbakFhqQUFZRbYHRJ6pcfhoq4J6NUl7ryf0895xkREP0dLuTNoKa64uBjJyXWTUDp06ID9+/cH63Q/W0ZqDN57fArsDjdKKm3Yc7gYOw4WwO32YOzFnZEUG4FqixOVZgeqahwoKrfCIwS0GjV0GjW0WjU8HoFj+ZWoqLY3+PEt0YVEpQK6d4xtsMxWcM93/gEqNtqAu+YNavDauT3LF/fpgIv7dGj1MSMMWlyc2QEXZ7b+a34OjUaNX03sjSuGdUFekRllVXZ4hEBirBFpSVHomNR073BTFX8hBGwON+xOCREGbaNKbK8u8ejVpeEa0EaDFt06xgZl4iRDMhEpVdCCcqBCdTj8ZWg0aP1L8cwe1+O8j2NzuFFRbW/wo0qicBdh0CIhxqioJdx+KZLiIpAU1z6rIahUKkQaddyYgoioBUELyikpKdi9e7f/98XFxejQITQVGCWIMGgR0cwscSIiIiJStqCVhUaPHo3vv/8e5eXlsNls+OqrrzB27NhgnY6IiIiIqF0FtaL8u9/9DjfccANcLhfmzZuHgQMHBut0RERERETtKqhLMsyYMQMzZswI5imIiIiIiIKCM3KIiIiIiAJgUCYiIiIiCoBBmYiIiIgoAAZlIiIiIqIAGJSJiIiIiAJgUCYiIiIiCoBBmYiIiIgoAAZlIiIiIqIAgrrhyPmQJAkAUFhYKPNIiIiIiOhC5subvvx5LsUF5ZKSEgDAggULZB4JEREREf0SlJSUICMjo9HrKiGEkGE8TbLb7Thw4ACSk5Oh0WjkHg4RERERXaAkSUJJSQn69+8Po9HY6H3FBWUiIiIiIiXgZD4iIiIiogAYlImIiIiIAmBQJiIiIiIKgEGZiIiIiCgABmUiIiIiogAYlImIiIiIAmBQJiIiIiIKIGyD8osvvohp06Zh2rRpePrppwEA27Ztw4wZM3DVVVfh2Wef9X92w4YNmDVrFmbOnIk777wTVVVVDY713HPP4YUXXmjyXIcOHcLVV1+NSZMm4eGHH4bb7W7T14eaEu7Nnj17cPXVV2PWrFm48cYbcebMmSBcaWBKuP7du3dj7ty5mDFjBu64445Gx5WDEu6LT3Z2Nvr379+OV3d+lHBP1q5dizFjxmDWrFmYNWtWg3PKRQn3pbi4GIsXL8bs2bNx7bXXIj8/PwhX2npy35OysjL/n5FZs2bhiiuuwJAhQ4JzsW0g930BgPz8fCxYsACzZs3CwoULQ/r/m+Yo4d7s378fV199NWbMmIHbb7/dv/uxXEJ5T3yWLl2KNWvW+H9/9uxZLFiwAJMnT8ZvfvMbWCyW5g8gwtDWrVvFNddcIxwOh3A6neKGG24Q69atE+PGjRO5ubnC5XKJW265RWzatEmYzWZx6aWXisLCQiGEEH/729/E448/LoQQorq6Wjz44INi4MCB4vnnn2/yfNOmTRP79u0TQgjx4IMPinfffbdNXx9KSrk348ePF4cOHRJCCPHhhx+KO+64I4hXXUcp1z9x4kRx7NgxIYQQf/7zn8Vf/vKXIF51y5RyX4QQwmq1imuuuUb07t07eBfcCkq5JytXrhTr1q0L7sW2gVLuy4033ijee+89IYQQ7733nrj33nuDd9EtUMo98ZEkSVx//fXi008/Dc4Ft5JS7sv999/v//U///lPsWTJkiBedeso4d54PB4xbtw48f333wshhPj888/F7bffHtwLb0ao70lhYaG4/fbbxcCBA8VHH33kf33x4sXis88+E0II8eKLL4qnn3662XGHZUU5OTkZy5Ytg16vh06nQ48ePXD69GlkZGSgS5cu0Gq1mDFjBr744gu4XC6sWLECKSkpAIA+ffqgoKAAAJCVlYWuXbvi5ptvbvJcZ86cgd1ux+DBgwEAc+fOxRdffNHqrw81Jdwbp9OJe++9F5mZmY2OG2xKuH4AWL9+PXr27AmXy4WioiLExMQE98JboJT7AgBPPvkkbrrppqBda2sp5Z789NNPWLt2LWbOnIn7779f9p8+KOG+lJeX4/Dhw7j22msBAFdffTXuu+++oF53c5RwT+r76KOPEBERgRkzZgTngltJKffF4/GgpqYGAGCz2QJuQxxqSrg3FRUVsNvtGDlyJABg/Pjx2LJlC5xOZ3AvvgmhvCcAsG7dOkyYMAFTpkzxv+ZyubBr1y5MmjQJQOD/vs4VlkG5V69e/j8Qp0+fxvr166FSqZCcnOz/TIcOHVBUVIT4+HhMnDgRAGC32/Haa6/5fz979mwsXrwYGo2myXMVFxc3OG5ycjKKiopa/fWhpoR7o9frMWvWLADev8BefPFF/3GDTQnXDwA6nQ5HjhzBuHHjsGPHDkybNq29L7VNlHJfsrKyYLfbMXny5Pa+xDZTyj1JTk7GPffcg08++QRpaWlYuXJle19qmyjhvuTl5aFjx4544oknMHPmTPz2t7+FTqcLwtW2jhLuiY8kSVi9ejWWLFnSnpd4XpRyX+6991689dZbuOyyy/Dmm2/itttua+9LbTMl3Jv4+HhERkZiy5YtAIDPP/8cLpcLFRUV7X25rRLKewIAixYtwvz58xu8VlFRgejoaGi1WgCN//sKJCyDss+xY8dwyy23YOnSpUhPT2/0vkql8v/abDbjtttuQ2ZmJubMmdPqcwghmj2uUinh3jidTtx///1wu924/fbb23gFP48Srr9Pnz7Ytm0b7rzzTvzud79r4xUEh5z3paSkBKtXr8Yf/vCH8xt8kMj9Z+Wll17CoEGDoFKpsGjRInz33XfncRXtT8774na7kZ2djdGjR+PTTz/FhAkTsGzZsvO7kHYk958VANi8eTO6deuGPn36tHH0wSP3fVm6dClWrlyJzZs347HHHsPdd98d8PNykPPeqFQqPP/883j11Vcxe/ZsmM1mxMXFyfpNJxCae9KU88l0YRuU9+zZg5tuuglLlizBnDlzkJKSgtLSUv/7xcXF6NChg//X1113HTIzM7Fq1apmj1tUVOSfLHHbbbc1Om5JSYn/uEqlhHtjsViwaNEiuN1urF69OqT/Ycp9/Q6HAxs2bPC/PnPmTBw5cqSdr7Lt5L4vmzZtQmVlpX/SDQDMmjXL/yNTOch9T8xmM9566y3/60IIf6VDTnLfl+TkZERFRWH8+PEAgOnTp2P//v1BuNLWk/ue+GzYsAFTp05t56s7f3Lfl/Lycpw8edJfbZw0aRJKSkpkq5rWJ/e9AQCtVot33nkHa9euxZw5c+DxeBAXF9f+F9tKobonTUlISEBNTQ0kSQLQukwn/9/I56GgoAB33XUXnn32WYwaNQoAMGjQIJw6dQo5OTno3LkzPvvsM1x99dWQJAl33HEHpkyZgjvvvLPFY6ekpOCTTz5p8JrBYMCePXswdOhQrF27FmPHjg3KdbUHpdybBx54ABkZGVi5cmVIK/BKuH6tVovHHnsMqamp6N+/P/73v//h4osvDsr1tpYS7sv8+fMb/BisT58+jb4ulJRwTyIjI/H6669jyJAhGDRoEP71r3/hyiuvDMr1tpYS7kt6ejpSUlLw7bffYty4cfjmm2/Qr1+/oFxvayjhnvj88MMPimgtAJRxX+Lj42EwGLB7924MGzYMe/bsQVRUFBISEoJyza2lhHsDAA899BBWrFiBgQMH4s0338TkyZOhVstTIw31PQlEp9Nh2LBhWL9+PWbMmNGqTBeWQfmNN96Aw+HAk08+6X/t2muvxZNPPol77rkHDocD48aNw+TJk7FhwwZkZ2dDkiR8+eWXAID+/fu3+N1Jfc888wyWL18Oi8WCvn374oYbbmj3a2ovSrg32dnZyMrKQs+ePTF79mwA3r6jv//97+16rYEo4fo1Gg2effZZPPLII5AkCSkpKW06ZjAo4b4ojRLuiUajwd/+9jesWLECdrsdXbt29S+ZJBcl3BfAu4zUo48+ij//+c+Ijo5uMJ5QU8o9AYC8vDykpqa238X9DEq4LyqVCi+++CIef/xx2O12REVFKWK5ViXcGwBYsWIFHn30UdhsNvTp00fW/xeF+p405dFHH8WyZcuwevVqpKWl4a9//Wuzn1cJpTTyEBEREREpSNj2KBMRERERBRODMhERERFRAAzKREREREQBMCgTEREREQXAoExEREREFACDMhFREN1yyy0oLy/HbbfdhuPHjwf1XHl5ebjnnnuCeg4iol+SsFxHmYgoXGzduhUAQrKO+NmzZ3Hq1Kmgn4eI6JeC6ygTEQXJgw8+iDVr1qB37944fvw4PvjgA1itVvz1r39Fhw4dcOzYMUREROCee+7BO++8g1OnTuGqq67CQw89BADYuHEjVq9eDZfLBaPRiKVLl2LIkCE4ceIEHn74YTidTgghMG/ePFx77bWYPHkyioqKMHz4cLzxxht45ZVXsGHDBjgcDthsNixduhRXXnklXnjhBeTm5iIvLw/FxcUYOHAgLr30Uqxduxb5+fl44IEHMH36dLzwwgs4duwYSktLUVZW5t9KNjo6WuY7S0QUIoKIiIKmd+/eoqysTIwfP17s379fbN++XVx00UXi4MGDQgghbr31VnHNNdcIh8MhysrKRL9+/URhYaE4deqUmD59uigvLxdCCHH06FFx6aWXCovFIh588EHx6quvCiGEKC4uFvfdd5+QJEls375dTJs2TQghRH5+vli4cKGw2WxCCCE+++wzMX36dCGEEM8//7wYP368qK6uFjabTQwfPlz86U9/EkII8fXXX4urrrrK/7mxY8eKkpISIUmS+P3vfy+efPLJ0N08IiKZsfWCiCjEOnfujL59+wIA0tPTYTKZoNfrkZCQgKioKFRVVWHXrl0oLi7GTTfd5P86lUqF3NxcXHnllVi6dCn279+PUaNGYfny5VCrG0456dSpE5566imsW7cOOTk5+PHHH2GxWPzvjx49GiaTCYB3i/nLLrvMP57Kykr/5yZPnoykpCQAwLx58/DEE09g6dKlwbgtRESKw8l8REQhptfrG/xeq21cs/B4PBg1ahQ++eQT/z8ffPABevXqhfHjx+PLL7/ElClTcOjQIcyYMQO5ubkNvv7gwYO49tprUVNTg0svvRSLFi1q8xgAQKPRNBjTuYGciOhCxr/xiIiCSKPRwO12t/nrRo4cia1bt+LEiRMAgG+//RYzZ86Ew+HAkiVLsH79ekybNg2PPvoooqOjUVBQAI1GA5fLBQDYtWsX+vfvj5tvvhkjRoxAVlYWJElq8ziysrJgNpvh8XjwwQcfYPz48W0+BhFRuGLrBRFREF155ZW47rrrGrQ9tEavXr2wcuVK/P73v4cQAlqtFqtXr0ZkZCTuvPNOPPzww/jPf/4DjUaDiRMnYsSIEaiuroZGo8G8efPwyiuv4KuvvsLUqVOh0+kwatQoVFVVoaampk3jSEpKwm233YaKigoMHz4cd9xxR5u+nogonHHVCyIiCuiFF15ARUUFHnnkEbmHQkQkC7ZeEBEREREFwIoyEREREVEArCgTEREREQXAoExEREREFACDMhERERFRAAzKREREREQBMCgTEREREQXAoExEREREFMD/A3ikA9ywQL17AAAAAElFTkSuQmCC\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": 11, - "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": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# num_df = (transfers[[\"nft_address\", \"transaction_value\", \"timestamp\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "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": 141, - "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": 142, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABXMAAAFjCAYAAAB/tZiLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABY8UlEQVR4nO3deVxV1f7/8fdhcsIhEzDH65BUKk6YirPlhOCQmjjh0M1SUzNLITWcyBzKUnKsW2aaojlhXTQlM4Ush5yumlo4CyoOoSjT/v3Rz/MVERGFA+fwej4ePh7udfZZ67PX2eLnfNh7bZNhGIYAAAAAAAAAAHmaXW4HAAAAAAAAAADIHMVcAAAAAAAAALACFHMBAAAAAAAAwApQzAUAAAAAAAAAK0AxFwAAAAAAAACsAMVcAAAAAAAAALACFHMBAIBNaNWqlTp16qTk5OQ07Tdu3JC7u7t27tyZI+MGBARo+PDhOdJ3drh586Zee+011axZU7169Ur3+urVq+Xu7q7w8PB0r02bNk19+/Y1b7u7u9/3T6tWrXTmzJkMX7/z536OHDmiX375JfsO2ILujd3d3V0//vhjLkaUd2T27y6n/10CAADYKofcDgAAACC7HDlyRF9++aX+/e9/53YoecbmzZsVGRmpb775Rq6urhnuN2XKFDVu3FhFixZ9YH/Tp0+Xl5dXmjZ7e3sVL15c27dvN7eNHz9eBQsW1NixYx/Y35AhQzRw4EA1bNjwIY4mb7k39u3bt6t48eK5HBUAAABsGVfmAgAAm1G2bFmFhITozJkzuR1KnvH333+rVKlSqlGjRobF3MKFCyslJUUffvhhpv0VK1ZMLi4uaf6ULFlS9vb2adqcnJxUsGDBNG227s5xAwAAADmFYi4AALAZffv2VZkyZTRhwoQH7jNt2rQ0bXffHh8QEKCpU6cqMDBQtWvXVqtWrfTTTz9p7dq1atGihTw9PTV+/HgZhmF+f0JCgkaNGiUPDw+1atVKK1euTNP/2rVr1bZtW9WqVUtdunTR1q1bza8FBATo7bffVvfu3fX8888rMjJSu3btUrdu3eTh4aEmTZpo+vTpSklJue/xGIahr7/+Wm3btlXNmjXVqVMn/fTTT5KkOXPmaNKkSTp37pzc3d21evXq+/bh5OSkgIAALV++XHv37s1w7rJb3759dfbsWU2ePFl9+/Y1L9Uwd+5cPf/883r11VclSevXr5evr69q1KihunXravDgwbp06ZIkaefOnWrQoIHWrl2rVq1aycPDQ6+++qr59eTkZE2ePFmNGzeWh4eHevbsqf3795tj+Pnnn/Xyyy/Lw8NDtWrVkr+/v/766y/z60eOHFH//v1Vp04dNW/eXAsWLLhv7FLa8ygxMVEhISFq1aqVatasqZ49e2rfvn1pjn327NkaPHiwPDw81Lx58zTnTVbOgYCAAL333nsaNWqUatWqpdatW2vdunVp9snqOXivS5cuadSoUWrYsKFq1KihF198UatWrTK/npCQoLFjx6pevXpq2rSp/vvf/6Z5f2avt2rVStOnT1eLFi3UokULXbt2TRcvXtSIESNUp04dNWnSRGPHjtXff/9tfs+KFSvUunVr1ahRQ+3atdPatWvNr23evFk+Pj6qWbOmWrVqpc8+++y+cwcAAGBtKOYCAACb4ejoqEmTJmn79u367rvvHrmfpUuXqkqVKlq/fr1q1qypUaNGafXq1VqwYIEmTpyob7/9VhEREeb9t23bpieeeEJr1qzRwIEDFRQUpD179kj6p1gYHBysESNGKCwsTD169NDw4cPTFE03bNig3r17a/Hixapdu7aGDh2qhg0b6vvvv9eMGTO0cuXKDAuxCxcu1CeffKLhw4dr/fr1evHFFzV48GAdOXJEAwcO1FtvvaXSpUtr+/bt8vb2zvCYO3XqpEaNGum9995TUlLSI89dVsyZM0elS5fWW2+9pTlz5pjbt23bptDQUI0ePVp79uzRu+++q1deeUUbN27Up59+qsOHD2v+/Pnm/f/++2+tWLFCc+bM0eLFi3Xw4EHz619//bW2bNmiTz/9VN99953+9a9/afjw4TIMQ2fOnNHgwYPVrl07fffdd1q8eLGuXbum6dOnS5Li4uLUr18/ubq6auXKlZo0aZIWLlyoVatWZRj7HVOmTNHKlSsVFBSktWvX6umnn9aAAQMUGxtr3mfRokVq2rSpvvvuO7Vu3VoTJ07UpUuXlJKSkqVzQPpn7WNnZ2etXr1avXv3VkBAgHk936yeg3Xq1EnX/+jRoxUXF6cvv/xS3333nVq1aqUJEyaYi+YTJ07U7t27tWjRIoWEhOirr75K8/7MXpdkntc5c+aoePHiGjZsmKR/irbz5s3TqVOnNHLkSEnS//73P02YMEGjRo3Sxo0b5e/vr4CAAEVHR+vy5ct688031aNHD4WHh2v06NH6+OOPFRUVleH8AQAAWAvWzAUAADbF09NT3bt31/vvv6+mTZvK3t4+y31UqlTJvO7uSy+9pPDwcAUGBpof5DV37lwdP35cL7zwgiSpcuXKGjt2rEwmk6pUqaKdO3dq2bJlqlu3rhYsWKBXXnnFXEitUKGCDh06pC+++MJcNKtUqZI6d+4sSbp69aquXbumUqVKqWzZsipXrpw+//xzPfnkk+niNAxDX3zxhV5//XV16NBBkjRs2DDt27dPixYt0ocffqgiRYqYl0DIzMSJE+Xj46P//Oc/eu211+67z4gRI9LN6XfffacyZco8xMymVaJECdnb26tIkSIqUaKE4uPjJUn+/v7617/+JUk6dOiQJk+ebJ6fsmXL6oUXXtCxY8fM/aSkpCggIEDVq1eXJHXs2NF8FeyZM2dUoEABlSlTRq6urgoMDNT//vc/paamKjk5WWPGjDFfWVu+fHl16tRJy5YtkyT997//laOjo6ZMmSInJydVrVpVQUFBcnBwSBf73a5fv65Vq1bpo48+UvPmzSVJEyZM0O7du7V06VJzQbJBgwbmh9K9+eabWrJkiY4cOaIaNWo89DlwR9myZRUUFCQ7OztVqVJFv/76q5YvX66GDRtm+Ry8nxYtWqhly5YqX768JGnw4MFavHixoqOjVbBgQW3YsEEhISGqW7euJGnSpEnq0aOHJCk+Pv6Br9/Rvn171axZU5L0yy+/6OjRo/rqq6/MS1fMnDlTzZo107Fjx3T27FmZTCY99dRTKlu2rHr16qWKFSuqZMmSOnPmjJKSkuTq6qqyZcuqbNmyKlWqlPmcAgAAsGYUcwEAgM15++23FRERoRkzZiggICDL779TsJKkggULpmsrUKCAEhMTzdseHh4ymUzm7erVq5tvIz927Jj27dtnvj1fkpKSklSpUqX7jleiRAn5+/tr6tSpWrRokZo1ayZvb295eHikizMuLk5XrlxR7dq107TXq1dP4eHhWT1sVahQQUOHDtXcuXPVvn37++4zbtw4NWjQIE3bgx6s9ijKlStn/nv16tVVpEgRffrppzpx4oROnDihY8eOqV69emneU7FiRfPfnZ2dzVcX9+zZU+Hh4WrRooVq1aqlli1bqmvXrrK3t9e//vUvFSpUSIsWLdKxY8f0119/6fDhw+bjOX78uNzd3dOsg9uxY8dM44+OjlZKSkqaK1zt7OxUp06dNEXou4uLzs7Okv5ZFiIr58AdderUkZ3d/9105+HhobCwMElZPwfvp1evXgoPD9eXX36p6Oho/e9//5P0TyH9zz//VFJSkp577jnz/jVq1DDHk9nr94vh+PHjSkhISHeu3emvefPm8vDw0Msvv6zKlSurRYsW6tKli4oVK6Znn31Wbdq00fDhw1W2bFk1b95cHTt2VKlSpR54jAAAANaAYi4AALA5xYsX17vvvqtRo0apdevWD9w3OTk5XZuDQ/oU6e5i7b3uLUqlpqbK0dFR0j/FrlGjRqlly5YZjnGnYHzHu+++q169eunHH3/U1q1bNWjQIA0dOlRvvPFGmv0KFChw33hSU1OVmpqaYbwPMnDgQG3YsEFBQUF65pln0r3u4uKSpnCaE+6ej8jISL322mvy9vaWp6en/P39tWHDBh09ejTNe+7M9x131jSuUqWKIiIi9PPPP2vbtm366quv9PXXX2vlypW6evWqevbsKS8vL9WvX1/dunXTvn379M0335j7vHtt5IeV0UPQ7v1c7o357rgf9hy4496rpVNSUszn5aOcg/fG/e9//1sXLlxQhw4d1KNHD1WtWtVc8L/zb+PuubK3tzfHlNnr94shOTlZZcqU0RdffJEunieffFIFCxbUN998o7179+qnn35SRESEvv76a82fP1+NGzfWnDlzdOTIEfP8LV++XMHBwXrppZcyPE4AAABrwJq5AADAJnXo0EFNmjTRxIkT07Q7OTnpxo0b5u3Tp08/9lj3FhZ///13Va1aVdI/xcSzZ8+qYsWK5j8bNmzIcE3fS5cuaeLEiSpVqpQGDBigxYsXa9CgQffd39nZWa6urukeWrZ3715Vrlz5kY7lzrrDUVFR2rRp0yP1kZ2++uortW/fXtOmTVOvXr1Uu3ZtnTx58qGLrGvXrtX333+vF154QRMnTtTGjRsVFxen3bt3KzQ0VM8++6xCQkLUr18/Pf/88zp79qy573/961/6448/0qwhHBISohEjRjxwzIoVK8rR0dG8brL0TyHz999/f6jPJSvnwB13rpS9Y//+/eZifFbPwfv1HRUVpUWLFmnYsGFq06aNeUkMwzBUqVIlOTo6pnmw3NGjR83zltnr91OlShXFxsaqSJEi5pgdHBw0depUxcXFae/evZozZ47q1q2rkSNHKiwsTNWrV9emTZt04sQJTZkyRc8884wGDx6sFStWyNvbW99///1DHS8AAEBexpW5AADAZk2YMEE+Pj5p2mrUqKGVK1eqU6dOKlKkiD744IMMr6R8WIcPH9b06dPVtWtXRUREaPv27Vq7dq0k6d///rfeeustVa5cWY0bN9aOHTv06aefaubMmfftq3jx4tq8ebNu3bqlQYMGKSEhQdu3b8/wFvtBgwZp9uzZKlOmjJ577jlt2LBBO3bs0JIlSx75eOrUqSM/Pz998803j7QWblYUKVJEJ06c0OXLl+/7uqurq3799VcdOnRIhQsX1tq1a7Vt2zbVqlXrofq/ceOGZs+erSeeeEJVqlTRTz/9JMMw9Oyzz+rMmTP6/vvvtWvXLrm5uWnLli1auXKleQ3cjh07as6cOZo4caIGDhyo06dPa/HixQoMDEwX+93r2RYqVEh9+vTRBx98oMKFC6tcuXJasmSJzp49q5dffjnTmLN6Dkj/FFxnzZqlzp07m69EXr58uaSsn4P3cnFxkb29vb777jv5+voqOjpaU6ZMkSQlJibK2dlZ3bt319SpU1WsWDE5Oztr4sSJ5ityM3v9fho3bqynn35aI0eO1JgxY2Rvb6+JEyfqxo0bKlu2rG7evKkFCxaoRIkSatWqlaKjo3XixAl1795dxYsX17fffqtChQrp5Zdf1sWLF/X777+rU6dOD3W8AAAAeRnFXAAAYLPKlSunN954QzNmzDC3DRw4UH/++acGDhyoJ554QsOHD9fZs2cfa5yOHTvq5MmT6ty5s8qUKaPZs2erWrVqkqTWrVtr/Pjx+vzzzxUcHKyyZctq0qRJ5odR3cvR0VELFy7U+++/r5deekkODg5q1aqVxo0bd9/9+/Tpo5s3b2r69Om6fPmyqlWrpvnz58vT0/OxjmnUqFHasmXLY/XxMPz9/fXBBx9o7969CgkJSff68OHD9e6776pPnz4qUKCA6tSpozFjxigkJES3b9/OtP9evXrp0qVLCgoK0qVLl1SpUiV98sknqlSpkvr27aujR4/q9ddfl8lk0nPPPacJEyZo/PjxunDhgkqXLq1Fixbp/fffV6dOnVSqVCkNGTLEfKv+3bHfKd7f8dZbb8lkMikwMFA3btxQzZo19dVXXz3UQ7iyeg5IUpMmTXTy5El16tRJFSpU0Keffmou/mb1HLyXm5ubJk2apLlz52ru3LnmB46tXLlShw4dUrNmzRQYGCh7e3sNGzZMdnZ2Gj58uA4fPmzuI7PX72VnZ6d58+YpODhY/v7+srOzU6NGjfTxxx/L3t5ezzzzjGbMmKG5c+dqxowZKlmypAYMGKCuXbtKkubOnauZM2fqq6++UpEiRdShQwe9/vrrD3W8AAAAeZnJeJSFwAAAAADkCQEBAbp586Zmz56d26EAAAAgh7FmLgAAAAAAAABYAYq5AAAAAAAAAGAFWGYBAAAAAAAAAKwAV+YCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AHLUmTNn5O7urpUrV6Zp//zzzxUQECBJWr16terVq6dOnTql+bNlyxYNHz7cvO3u7i5fX1916tRJffv2fajxT5w4oUGDBsnX11e+vr7q06ePdu3a9VjHtHXrVn3yySf3fW316tVq0aKFXnnllccaI6+5+/O6l4+Pj3bu3GnhiAAAAPKf3M6tc9Inn3yitWvXZktf4eHhGR7TwIEDFRcXly3j5ITXXntNq1evTtceFxcnd3f3XIgIQF7jkNsBALB9dnZ2mjZtmjw9PVWpUqX77uPp6akFCxaka3/hhRfMf3d3d9fixYtVsmTJhx57+PDhevPNN9W6dWtJ0m+//abXXntNW7ZsUYkSJbJ2IP/fgQMHdO3atfu+tnbtWo0cOVKdOnV6pL4BAACAB8nN3DonjRgxwiLj7NixwyLjAEBOoZgLIMcVLFhQAwYM0KhRo7R8+XI5OTk9dp8nTpzQ2LFjlZiYKMMw1K1bN/Xu3TvdfhcvXtTNmzfN2/Xr19fHH38se3t7SdKePXs0c+ZMJSQkyGQyadiwYWrZsqVWr16tH374QXZ2djp58qQcHR01bdo0JSQkaPny5UpJSVHRokU1cuRIc9/vv/++Dhw4oDNnzujKlSs6cuSIrl69qtOnT6tFixZ6/fXXNXHiRB05ckQmk0lNmzbVW2+9JQcHB9WsWVP9+/fX1q1bFR8fr3feeUfh4eH6448/5Orqqvnz56tw4cJpju2vv/7SpEmTdPPmTcXGxuqZZ57Rxx9/rAIFCqhmzZoaNGiQduzYodjYWPn7+6t///7p5mfVqlVasWKFkpKSdO3aNb366qvq1auXkpKSNGXKFEVGRurJJ5/Uk08+qaJFi0qSjh8/rnfffVcJCQmqXLmyeX7PnDmj3r17q0qVKjp79qyWLFmiM2fO3Hd+L168qDFjxujKlSuSpObNm+vNN9/MsB0AAAD/yK3cOiu5niQtWLBAa9askYODgypWrKgPPvhARYsW1cqVK/XNN98oNTVVJUqU0Pjx41WlShUFBATo6aeflrOzsyIiIszF6BMnTpjz5OjoaAUHB+vq1atKSUlR37591a1bN0n/XNkbFhamEiVKqGLFivc9zsDAQElSv379tHDhQsXHx2vSpEm6evWqTCaTBg4cqM6dO6d7348//qgFCxYoMTFRcXFx6ty5s958803t3LlTs2bNUvny5XXs2DElJibqvffeU8OGDdO8PzU1Ve+//7727dunGzduyDAMTZkyRfXq1VNMTIwCAgIUGxurMmXK6PLly+b3bdq0SbNmzVKhQoVUo0YNc/vq1au1atUqJSQkyNnZWUuWLMlwXnft2qUPPvhAqampkv658rdt27YZtgOwAgYA5KDTp08btWvXNlJSUoxevXoZH3zwgWEYhvHZZ58ZY8aMMQzDML799lujbt26RseOHc1/xo8fn66vatWqGZcvXzYMwzACAwONBQsWGIZhGLGxscabb75ppKSkpHtPWFiY4enpaTRu3NgYPny4sWTJEuPKlSuGYRjG1atXjTZt2hinT582DMMwLly4YDRr1sw4e/as8e233xr16tUzzp8/bxiGYUyaNMkYPXq0YRiGMXv2bGPixIn3Pd4+ffoY//3vfw3DMIwxY8YY/fr1M782evRoY/LkyUZqaqpx+/ZtY+DAgeZjqFatmrF48WLDMAxjwYIFRp06dYwLFy4YKSkpRpcuXYz169enG+uDDz4w1q5daxiGYSQmJho+Pj5GeHi4ub8lS5YYhmEYBw4cMGrUqGHcunUrzfvj4+ONl19+2YiLizMMwzD27t1r1K5d2zAMw/jyyy8Nf39/4/bt28aNGzeMLl26mD+vTp06GaGhoYZhGMauXbsMd3d345dffjFOnz5tVKtWzfjtt98ynd+QkBDzZ3zjxg3jzTffNK5fv55hOwAAAHI3t85Krrd582ajTZs2xtWrVw3DMIz333/fmDt3rrFz506jV69exs2bNw3DMIyff/7ZaN++vWEY/+TOn332mfH3338b9erVM2JjYw3DMIzp06cbH330kZGUlGR4e3sbBw8eNAzDMK5fv260b9/e2Lt3r/HDDz8Y3t7ext9//20kJSUZgwYNMvr06XPfObxz3ElJScYLL7xgbNy40Rx/06ZNjT179qTZPzU11ejTp4/x119/mfd79tlnjcuXLxu//PKL8eyzzxr/+9//DMMwjM8//9zo3bt3ujH37NljDBs2zDynCxYsMF577TXDMAxjyJAhxqxZswzDMIzo6Gijdu3axrfffmtcvHjRqFevnnHs2DHDMAxj/vz5RrVq1cyfcf369Y2///7bMAzjgfPq7+9vbNiwwTAMwzh8+LAxYcKEB7YDyPu4MheARdjZ2WnGjBnq0qWLmjRpku71jG4Fy0jr1q01ZswY7d+/X40aNdK4ceNkZ5d+GXAfHx+1bt1au3fv1m+//aZvv/1W8+bN04oVK3TixAldvHhRQ4cONe9vMpl09OhRSVL16tVVunRpSdJzzz2nH374IauHrXr16pn/vm3bNn3zzTcymUxycnKSn5+fFi9erEGDBkmS+TfhFSpUULVq1eTm5iZJKleu3H2XdXjnnXe0Y8cOLVq0SNHR0YqNjU1zFfKd2+iqV6+uxMRE3bx5UwUKFDC/XqRIEc2fP18//fSToqOjdeTIEfP7o6Ki5OPjIycnJzk5OcnX11dHjx7VlStXdPToUfMVC/Xq1dPTTz9t7tPBwUG1a9eWJP3+++8Zzm/Tpk01aNAgnT9/Xl5eXho1apSKFi2aYTsAAAD+T27l1g+b60VFRaldu3YqXry4pP+7Inb69Ok6efKk/Pz8zO+5du2arl69at52dnZW27ZttX79evXv31/r16/XsmXLFB0drVOnTundd98173vr1i3973//04kTJ9S6dWs5OztLkrp27aolS5Y88Jijo6N1+/ZttWnTRpLk5uamNm3a6Oeff1adOnXSHNP8+fO1detWbdiwQSdOnJBhGEpISJAklSlTRs8++6ykf74zrFmzJt1YderUUfHixbV8+XKdPn1aO3fuVJEiRSRJkZGRGjNmjCSpYsWKatCggSRp9+7dqlatmqpWrSpJ6tGjhz766CNzn+7u7ubj3bp1a4bz2r59e02aNEkRERHy8vLSW2+9JUkZtgPI+yjmArCYMmXKaMKECRozZsx9b1/KipYtW2rjxo2KjIxUVFSUPv30Uy1fvlwVKlQw73PixAmtWbNGb7/9try8vOTl5aURI0ZowIAB2rhxoypVqqQqVaqkeYBETEyMSpYsqbCwMBUsWNDcbjKZZBhGluO8e2mEO7cw3b2dnJxs3nZ0dLzv3zPy1ltvKSUlRe3bt1eLFi10/vz5NDHeKdyaTCZJShf/hQsX1KNHD7388suqV6+e2rVrpx9//PG+Y91ZluJ+fTk4/N9/JU5OTubtlJSUDOfX0dFRW7ZsUVRUlH755Rd1795dn376qerWrZthOwAAAP6PpXNr6eFzvV9++cWcN0rS9evXdf36daWmpqpTp0565513JP2TD8fGxpqLvnd0797dvExA1apVVb58eR09elTFihXTunXrzPtdunRJRYsW1YwZM9Lkp3dy1we5NzeX/slx787PJenmzZvq0qWLXnzxRXl6eqpr167avHmzebyH+c6wdetWBQcHa8CAAXrhhRdUuXJlrV+//r7vuTO/GbXfce/3jIzm1c/PTy1bttSOHTv0888/KyQkROvXr8+wnQspgLwv/a/aACAHtW/fXs2aNdPixYsfq59Ro0bp+++/V4cOHRQUFCRnZ2edP38+zT6lSpVSaGiowsPDzW1Xr17VpUuX9Nxzz6l27do6efKkfvvtN0nS4cOH1bZtW8XGxj5wbHt7+3RJ3sNo0qSJli5dKsMwlJiYqNDQUHl5eWW5nzu2b9+uoUOHytvbWyaTSfv27VNKSspDv//gwYMqWbKkhgwZoqZNm5oLuSkpKWratKnWrl2r27dv6/bt2/r+++8lSSVKlFD16tXNSfuhQ4f0xx9/3Lf/B83vzJkzNXfuXL344osaO3asqlatqujo6AzbAQAAkJ4lc+t7PSjX8/Ly0g8//KD4+HhJ0pw5c/Tll1+qcePG+u6778z59jfffKN+/frdt29J+vTTT9W9e3dJUqVKlVSgQAFzMff8+fPy8fHRwYMH1bRpU4WHh5sLxncXfO91J5evVKmSHB0dtWnTJkn/FKI3btyYLj8/efKk4uPj9eabb6pVq1b69ddflZiYeN9icEZ27Nihli1bqlevXqpZs6Y2b95sztubNm2qFStWSJLOnTunnTt3Svrn6urjx4/ryJEjkv5ZJzcjD5pXPz8/HT58WC+99JImT56s69ev69q1axm2A8j7uDIXgMWNGzdOu3fvfqw+hgwZorFjx2rFihWyt7fXiy++qOeffz7NPsWLF9fixYv14Ycfavr06SpUqJCcnJz0yiuvqFGjRpKk2bNna/r06bp9+7YMw9D06dNVtmzZB47dqFEjDRs2TI6Ojho/fvxDxzxu3DhNmTJFvr6+SkpKUtOmTfX6669n/eD/v5EjR2ro0KEqXry4ChUqpPr16+vUqVMP/f7GjRtr1apVateunQoVKiQPDw+VLFnSfIvWqVOn5OPjk+4hEh999JECAwPNV2tUrlz5vv2XLFkyw/nt16+fAgICzEs5uLu7y8fHR9euXbtvOwAAAO7PUrn1vR6U65UtW1bHjx9Xz549JUlVq1bV5MmT5ezsrFdffVUDBw6UyWSSs7OzQkJC0lzFe0f37t3Nv+SX/rkqeO7cuQoODtZnn32m5ORkjRgxwrys2dGjR9W1a1cVK1ZMzzzzjPmBuvdq3bq1evXqpblz52ru3LmaMmWK5syZo5SUFA0dOjTdw8vc3d3VokULtW/fXsWKFVOFChVUtWpVnTx58qEfPufn56e3335bvr6+sre3l6enpzZt2qTU1FQFBQUpMDBQ7du3V+nSpfXMM8+Y53fmzJl6++235ejoqPr162fYf9OmTTOc17ffflvvv/++Pv74Y9nZ2emNN95QuXLlMmwHkPeZjEe5bxgAAAAAAAAAYFEsswAAAAAAAAAAVoBiLgAAAAAAAABYAYq5AAAAAAAAAGAFrL6Ym5ycrDNnzjzSk+UBAADwaMjBAAAAAMtzyO0AHtfZs2fVpk0bLV26VKVLl87tcAAAAPKFCxcuqHfv3tq0aZMqVqyY2+Egh9y6dUsHDx6Ui4uL7O3tczscAAAAm5eSkqKLFy+qRo0aKliwYLrXrb6Ye/HiRUlS7969czkSAACA/OfixYsUc23YwYMHybMBAABywdKlS+Xp6Zmu3eqLuS4uLpLElbkAAAAWdOfK3Du5GGwTuTYAAIBlZZZnW30x987tXqVLl1a5cuVyORoAAID8hVvvbRu5NgAAQO7IKM+2+gegAQAAAAAAAEB+QDEXAAAAAAAAAKwAxVwAAAAAAAAAsAIUcwEAAAAAAADAClDMBQAAAAAAAAArQDEXAAAAAAAAAKwAxVwAAAAAAAAAsAIUcwEAAAAAAADAClDMBQAAAAAAAAAr4JDbAVilxCtSyi3LjGVfUHJ6wjJjAQAAALko/maiEpNTLTaek4OdnAs7WWw8AACAx0Ux91Gk3JJ29LLMWI2XWWYcAAAAIJclJqdq5te7LTbe233qWWwsAACA7MAyCwAAAAAAAABgBSjmAgAAAAAAAIAVoJgLAAAAAAAAAFaAYi4AAAAAAAAAWAGKuQAAAAAAAABgBSjmAgAAAAAAAIAVoJgLAAAAAAAAAFaAYi4AAAAAAAAAWAGKuQAAAAAAAABgBSjmAgAAAAAAAIAVoJgLAAAAAAAAAFaAYi4AAAAAAAAAWAGH3A7gjuPHjysgIEBVq1bVM888o/79++d2SAAAAAAAAACQZ+SZK3N37dqlUqVKKTU1VbVq1crtcAAAAAAAAAAgT8kzV+Z6enqqTZs2cnZ21uuvv67//Oc/uR0SAAAAAAAAAOQZeebK3IMHDyo1NVVOTk5ydHTM7XAAAAAAAAAAIE/JM1fmVqhQQcHBwXJ2dtbLL7+c2+EAAAAAAAAAQJ6S48Xc+Ph4+fn5af78+SpXrpwkKSwsTPPmzVNSUpL69++v3r17q27duqpbt25OhwMAAAAAAAAAVilHl1nYt2+fevbsqejoaHNbTEyMZs2apWXLlmndunVasWKFjh8/npNhAAAAAAAAAIDVy9FibmhoqIKCguTq6mpui4yMVMOGDVWiRAkVLlxYbdu2VXh4eE6GAQAAAAAAAABWL0eXWQgODk7XFhsbKxcXF/O2q6ur9u/fn5NhAAAAAPna8ePHFRAQoKpVq+qZZ55R//79czskAAAAPIIcvTL3fgzDSNdmMpksHQYAAACQb+zatUulSpVSamqqatWqldvhAAAA4BHl+APQ7uXm5qZdu3aZt2NjY9MswwAAAAAge3l6eqpNmzZydnbW66+/rv/85z+5HRIAAAAegcWvzPXy8lJUVJTi4uKUkJCgTZs2qVmzZpYOAwAAAMg3Dh48qNTUVDk5OcnR0TG3wwEAAMAjypUrc0eOHCl/f38lJSWpW7du8vDwsHQYAAAAQL5RoUIFBQcHy9nZWS+//HJuhwMAAIBHZJFibkRERJptX19f+fr6WmJoAAAAwGbFx8fLz89P8+fPV7ly5SRJYWFhmjdvnpKSktS/f3/17t1bdevWVd26dXM5WgAAADwuiy+zAAAAAODx7du3Tz179lR0dLS5LSYmRrNmzdKyZcu0bt06rVixQsePH8+9IAEAAJCtKOYCAAAAVig0NFRBQUFpHiYcGRmphg0bqkSJEipcuLDatm2r8PDwXIwSAAAA2cnia+YCAAAAeHzBwcHp2mJjY+Xi4mLednV11f79+y0ZFgAAAHIQV+YCAAAANsIwjHRtJpMpFyIBAABATqCYCwAAANgINzc3Xbp0ybwdGxubZhkGAAAAWDeKuQAAAICN8PLyUlRUlOLi4pSQkKBNmzapWbNmuR0WAAAAsglr5gIAAAA2ws3NTSNHjpS/v7+SkpLUrVs3eXh45HZYAAAAyCYUcwEAAAArFhERkWbb19dXvr6+uRQNAAAAchLLLAAAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAXyVDE3OTlZffr00YEDB3I7FAAAAAAAAADIU/JUMTckJESlS5fO7TAAAAAAAAAAIM9xyO0A7li7dq1q164te3v73A4FAAAAAAAAAPKcPFPM3bhxo1xcXHTw4EFFR0frww8/zO2QAAAAAAAAACDPyDPF3Hnz5kmS5syZoxYtWuRuMAAAAAAAAACQx+T4mrnx8fHy8fHRmTNnzG1hYWHy9vZW69attXTp0jT7Dxs2TDVr1szpsAAAAAAAAADAquRoMXffvn3q2bOnoqOjzW0xMTGaNWuWli1bpnXr1mnFihU6fvx4ToYBAAAA5HvJycnq06ePDhw4kNuhAAAA4BHlaDE3NDRUQUFBcnV1NbdFRkaqYcOGKlGihAoXLqy2bdsqPDw8J8MAAAAA8r2QkBCVLl06t8MAAADAY3ioYm58fLwk6ffff9fatWuVlJT0UJ0HBwfL09MzTVtsbKxcXFzM266uroqJiXnYeAEAAACb8qi5dlasXbtWtWvXVsWKFbO9bwAAAFhOpg9A++STT3Tq1CmNGjVKQ4YMUdWqVfXbb78pODj4kQY0DCNdm8lkeqS+AAAAAGuW3bl2RjZu3CgXFxcdPHhQ0dHR+vDDD7O1fwAAAFhGplfm/vTTT5oyZYo2bdqkDh066KuvvtKRI0ceeUA3NzddunTJvB0bG5tmGQYAAAAgv8juXDsj8+bN06RJk9SyZUv1798/2/sHAACAZTzUMguFChUyr3UrSYmJiY88oJeXl6KiohQXF6eEhARt2rRJzZo1e+T+AAAAAGv2OLl2fHy8fHx8dObMGXNbWFiYvL291bp1ay1dujTN/sOGDVPNmjWzJ3AAAABYXKbF3CeeeEITJkzQwYMH5eXlpZkzZz7WlbRubm4aOXKk/P391blzZ/n4+MjDw+OR+wMAAACs1ePk2vv27VPPnj0VHR1tbouJidGsWbO0bNkyrVu3TitWrNDx48dzKHoAAABYWqbF3GnTpsnV1VULFixQoUKFZDKZNG3atCwNEhERoXLlypm3fX19tWHDBm3cuFGvvvpq1qMGAAAAbMDj5NqhoaEKCgpKU/y9c4VviRIlVLhwYbVt21bh4eE5FT4AAAAsLNNibqlSpfTSSy8pLi5OKSkp6tWrl0qVKmWJ2AAAAACb9ji5dnBwsDw9PdO0xcbGysXFxbzt6uqqmJiYbI0ZAAAAuSfTYu7WrVvl5+eniRMn6vLly/L29tbmzZstERsAAABg07I71zYMI12byWR6nBABAACQh2RazA0JCVFoaKiKFSsmV1dXLVu2TLNnz7ZEbAAAAIBNy+5c283NTZcuXTJvx8bGPtbzLgAAAJC3ZFrMTU1NTZMAPvvss/x2HwAAAMgG2Z1re3l5KSoqSnFxcUpISNCmTZvUrFmz7AgVAAAAeYBDZjsUKlRI586dMyeVu3btUoECBXI8MAAAAMDWZXeu7ebmppEjR8rf319JSUnq1q2bPDw8sitcAAAA5LJMi7lvv/22Bg4cqIsXL6pHjx6Kjo7WnDlzLBEbAAAAYNOyI9eOiIhIs+3r6ytfX9/sDBMAAAB5RKbF3Dp16ig0NFR79+5VamqqatWqpZIlS1oiNgAAAMCmkWsDAAAgKzJdMzchIUF//vmnmjdvrlOnTmnGjBk6d+6cJWIDAAAAbBq5NgAAALIi02JuYGCgtmzZogMHDuirr75SmTJlNH78eEvEBgAAANg0cm0AAABkRabF3NOnT2vUqFGKiIhQly5dNGzYMF29etUCoQEAAAC2jVwbAAAAWZFpMTcpKUmStH37djVs2FApKSm6efNmjgcGAAAA2DpybQAAAGRFpg9Aq1u3rry9vWVvb6+6deuqX79+8vLyskRsAAAAgE0j1wYAAEBWZFrMHT9+vPbu3St3d3fZ2dnplVdeUbNmzSwRGwAAAGDTyLUBAACQFZkus5CYmCgHBwcVLVpUixcv1saNG3XhwgVLxAYAAADYNHJtAAAAZEWmxdw7T9jdv38/T9gFAAAAshG5NgAAALIi02LunSfs/vjjjzxhFwAAAMhG5NoAAADIikyLuTxhFwAAAMgZ5NoAAADIikwfgMYTdgEAAICcQa4NAACArMi0mMsTdgEAAICcQa4NAACArMh0mQV7e3tdunRJn332mRISEhQfHy87u0zfBgAAACAT5NoAAADIikwzxYULF+qbb75ReHi4bt26pZCQEH366aeWiA0AAACwaeTaAAAAyIpMi7nfffedFi1apEKFCumJJ55QaGioNmzYYInYAAAAAJtGrg0AAICsyLSY6+DgICcnJ/N2sWLF5OCQ6VK7AAAAADJBrg0AAICsyDRTfOqpp7R161aZTCYlJibq888/V9myZS0RGwAAAGDTyLUBAACQFZkWc8ePH6/Ro0fr6NGjql27tmrVqqUPP/zQErEBAAAANo1cGwAAAFmRaTH3wIEDWrx4sRISEpSSkiJnZ2dLxAUAAADYPHJtAAAAZEWma+bOmjVLklSoUCGSSwAAACAbkWsDAAAgKzK9MrdatWqaN2+ePD09VbhwYXN79erVczQwAAAAwNaRawMAACArMi3m7tu3T/v27dPKlSvNbSaTSVu2bMnRwAAAAABbR64NAACArMi0mBsREWGJOAAAAIB8h1wbAAAAWZFhMTckJOSBb3zjjTeyPRgAAAAgPyDXBgAAwKPIsJh75coVSdKff/6pv/76Sy+++KIcHBy0ZcsWubu7Z3sgR44c0aJFi1SoUCG1b99ejRs3zvYxAAAAgLzA0rk2AAAAbEOGxdzx48dLkvz9/bV69WqVLFlSkjR48GANGTIk2wO5efOmxowZIwcHB82YMYNiLgAAAGyWpXNtAAAA2Aa7zHa4ePGiObmUpGLFiuny5cvZHkjdunV148YNDRkyRE2bNs32/gEAAIC8xlK5NgAAAGxDpg9Ac3d3V2BgoDp16iTDMLRq1SrVqlUr2wM5cOCAKleurOXLl2vgwIHy9vbO9jEAAACAvMRSuTYAAABsQ6bF3ClTpmj27NkKDg6WyWRS06ZNNWzYsGwP5NatWxo7dqxKliyp5s2bZ3v/AAAAQF5jqVwbAAAAtiHTYq6zs7PefffdRx4gPj5efn5+mj9/vsqVKydJCgsL07x585SUlKT+/furd+/eql+/vurXr//I4wAAAADW5nFz7YfFw4YBAABsQ4bF3FatWslkMmX4xi1btmTa+b59+zRu3DhFR0eb22JiYjRr1iytXr1aTk5O8vPzU4MGDVS1atWsRQ4AAABYqezItbOChw0DAADYhgyLubNnz5YkLVu2TI6OjurRo4fs7e21evVqJSUlPVTnoaGhCgoK0ujRo81tkZGRatiwoUqUKCFJatu2rcLDw/XGG288xmEAAAAA1iM7cu2sqFu3rv766y8FBgbK398/2/sHAACAZWRYzK1Ro4Yk6dixY1q5cqW5PTAwUN26dXuozoODg9O1xcbGysXFxbzt6uqq/fv3P3TAAAAAgLXLjlw7K3jYMAAAgG3IdM3c69evKy4uTiVLlpT0zzIJ8fHxjzygYRjp2h50ixkAAABgq7I7184IDxsGAACwDZkWc/v16ydfX181adJEhmFox44deueddx55QDc3N+3atcu8HRsbK1dX10fuDwAAALBWj5tr87BhAACA/CXTYm6vXr1Ut25dRUVFyWQy6d///reqVav2yAN6eXlpzpw5iouLU6FChbRp0yZNnjz5kfsDAAAArNXj5No8bBgAACD/sXuYnVJTU1WzZk1Vr15dcXFxCg0NfeQB3dzcNHLkSPn7+6tz587y8fGRh4fHI/cHAAAAWLNHzbXvPGz47rvc7n7YcOHChc0PGwYAAIBtyPTK3LFjxyoiIkK3bt2Sm5ubTp06pXr16unll19+6EEiIiLSbPv6+srX1zfr0QIAAAA25HFybR42DAAAkP9kemVuVFSUtmzZojZt2mjhwoX68ssvVbBgQUvEBgAAANi07M61edgwAACAbcu0mOvi4qLChQurcuXK+uOPP/T888/rypUrlogNAAAAsGnZnWu7ubnp0qVL5m0eNgwAAGBbMi3mOjo66rffflOVKlW0bds2/f333xRzAQAAgGyQ3bm2l5eXoqKiFBcXp4SEBG3atEnNmjXLxogBAACQmzIt5r799ttavny5mjdvrsOHD6thw4bq2LGjJWIDAAAAbFp259o8bBgAAMC2ZfoAtNq1a6t27dqSpJUrV+r69esqVqxYTscFAAAA2LzsyLV52DAAAED+kemVufeikAsAAADkDHJtAAAAPEiWi7kAAAAAAAAAAMvLsJj7ww8/SJISExMtFgwAAACQH5BrAwAA4FFkWMydPXu2JKlHjx4WCwYAAADID8i1AQAA8CgyfABakSJF1LZtW8XExNz3AQphYWE5GhgAAABgq8i1AQAA8CgyLOZ+9tlnOnz4sMaOHavx48dbMiYAAADAppFrAwAA4FFkWMx1dnZW/fr1tWDBArm6uurQoUNKTk6Wh4eHnJ2dLRkjAAAAYFPItQEAAPAoMizm3vH333+rb9++KlWqlFJSUhQTE6P58+erbt26logPAAAAsFnk2gAAAMiKTIu506ZN08yZM9WwYUNJUlRUlD744AOFhobmeHAAAACALSPXBgAAQFbYZbZDfHy8ObmUpEaNGikhISFHgwIAAADyA3JtAAAAZEWmxVw7OzudPXvWvH3mzBnZ29vnaFAAAABAfkCuDQAAgKzIdJmFoUOHqkePHmrUqJEkaceOHQoKCsrxwAAAAABbR64NAACArMi0mPviiy+qcuXK+uWXX2QYhl5//XVVqVLFErEBAAAANo1cGwAAAFmRaTFXkipXrqzKlSvndCwAAABAvkOuDQAAgIeV6Zq5AAAAAAAAAIDcRzEXAAAAAAAAAKxApsXc0aNHWyIOAAAAIN8h1wYAAEBWZFrMPXLkiAzDsEQsAAAAQL5Crg0AAICsyPQBaC4uLurQoYNq1aqlIkWKmNvHjRuXo4EBAAAAto5cGwAAAFmRaTG3Tp06qlOnjiViAQAAAPIVcm0AAABkRabF3DfeeEO3bt3SyZMn9fTTTysxMVEFCxa0RGwAAACATSPXBgAAQFZkumbuvn379OKLL+q1115TbGysmjdvrj179lgiNgAAAMCmkWsDAAAgKzIt5k6bNk1ffvmlSpQoodKlS2v69OkKDg62RGwAAACATSPXBgAAQFZkWsy9deuWqlatat5u3ry5UlJScjQoAAAAID8g1wYAAEBWZFrMdXBw0LVr12QymSRJf/75Z44HBQAAAOQH5NoAAADIikwfgDZ48GD16dNHFy9e1FtvvaUdO3Zo0qRJlogNAAAAsGnk2gAAAMiKTIu5LVu2VOXKlbVjxw6lpqZqyJAhaW4FAwAAAPBoyLUBAACQFZkWcyUpOTlZqampcnBwkKOjY44EcuzYMS1cuFBFixZVqVKlNGTIkBwZBwAAAMhLLJFrAwAAwDZkumbut99+q759++rAgQPavXu3evfurY0bN2Z7IFeuXNGYMWP03nvvae/evdnePwAAAJDXWCrXBgAAgG3I9MrcL7/8UmvXrpWrq6sk6dy5c3rttdfUtm3bbA3k+eeflyQtXLhQHTp0yNa+AQAAgLzIUrk2d8EBAADYhkyLuY6OjubkUpLKlCmTI7d/3b59W1OnTtULL7ygpk2bZnv/AAAAQF5jqVz7zl1wpUqV0quvvprt/QMAAMAyMizmHjp0SJLk7u6uSZMmqUePHrK3t9fq1atVt27dbA8kJCREhw4dUnx8vMLDwxUcHJztYwAAAAB5gaVzbe6CAwAAsA0ZFnOHDRuWZnvr1q3mv5tMJo0bN+6hBoiPj5efn5/mz5+vcuXKSZLCwsI0b948JSUlqX///urdu7dGjRr1COEDAAAA1ie7cu2HxV1wAAAAtiHDYm5ERMRjd75v3z6NGzdO0dHR5raYmBjNmjVLq1evlpOTk/z8/NSgQQNVrVr1sccDAAAArEF25NpZwV1wAAAAtiHTNXMvXryoNWvW6OrVq2naR48enWnnoaGhCgoKSrNvZGSkGjZsqBIlSkiS2rZtq/DwcL3xxhtZixwAAACwco+Ta0vcBQcAAJDfZFrMHTx4sEqXLq3y5ctnufP7/cY/NjZWLi4u5m1XV1ft378/y30DAAAA1u5xcm3uggMAAMh/Mi3mJiUlKSQkJNsGNAwjXZvJZMq2/gEAAABr8Ti5NnfBAQAA5D92me1QvXp1/fHHH9k2oJubmy5dumTejo2Nlaura7b1DwAAAFiLx8m1g4OD5enpmabtfnfBxcTEPFaMAAAAyDsyvTK3bt266ty5s1xcXOTg8H+7b9my5ZEG9PLy0pw5cxQXF6dChQpp06ZNmjx58iP1BQAAAFiz7M61uQsOAADAtmVazA0JCdHMmTNVoUKFbBnQzc1NI0eOlL+/v5KSktStWzd5eHhkS98AAACANcmJXHvXrl3mbe6CAwAAsC2ZFnOLFy8ub2/vxxokIiIizbavr698fX0fq08AAADA2mVHrn037oIDAACwbZkWc1u0aKFp06apTZs2cnJyMrdXr149RwMDAAAAbF1259rcBQcAAGDbMi3mhoWFSZI2btxobjOZTI+8jhcAAACAf2RHrs1dcAAAAPlHpsXce5NDAAAAANmDXBsAAABZkWkx94svvrhv+4ABA7I9GAAAACA/IdcGAABAVmRazP3jjz/Mf09MTNTu3bvVoEGDHA0KAAAAyA/ItQEAAJAVmRZzp06dmmY7Li5Oo0ePzrGAAAAAgPyCXBsAAABZYZfVN5QsWVJnz57NiVgAAACAfI1cGwAAAA+SpTVzDcPQwYMH9eSTT+ZoUAAAAEB+QK4NAACArMjSmrmS9NRTT3HrFwAAAJANyLUBAACQFVleMxcAAABA9iDXBgAAQFZkWMwNDAzM8E0mk0nvv/9+jgQEAAAA2DpybQAAADyKDIu5Tz/9dLq2K1euaPHixSpbtmyOBgUAAADYMnJtAAAAPIoMi7kDBw5Msx0ZGakxY8bI19dX48aNy/HAAAAAAFtFrg0AAIBHkemaucnJyfrwww+1Zs0aTZgwQe3atbNEXAAAAIDNI9cGAABAVjywmHvy5EmNHDlShQsX1po1a/TUU09ZKi4AAADAppFrAwAAIKvsMnph1apV6t69u1q3bq2vv/6a5BIAAADIJuTaAAAAeBQZXpk7btw42dnZaeHChVq0aJG53TAMmUwm7dmzxyIBAgAAALaGXBsAAACPIsNi7pYtWywZBwAAAJBvkGsDAADgUWRYzC1btqwl4wAAAADyDXJtAAAAPIoM18wFAAAAAAAAAOQdFHMBAAAAAAAAwApQzAUAAAAAAAAAK0AxFwAAAAAAAACsAMVcAAAAAAAAALACFHMBAAAAAAAAwApQzAUAAAAAAAAAK0AxFwAAAAAAAACsAMVcAAAAAAAAALACFHMBAAAAAAAAwApQzAUAAAAAAAAAK0AxFwAAAAAAAACsQJ4r5p4+fVovvfRSbocBAAAAAAAAAHlKnirmXr9+XcuXL1eRIkVyOxQAAADA5nDhBAAAgHXLU8XcYsWK6Z133lHhwoVzOxQAAADApnDhBAAAgPXLU8VcAAAAADmDCycAAACsH8VcAAAAAAAAALACFinmxsfHy8fHR2fOnDG3hYWFydvbW61bt9bSpUvT7L9gwQJLhAUAAAAAAAAAViPHi7n79u1Tz549FR0dbW6LiYnRrFmztGzZMq1bt04rVqzQ8ePHczoUAAAAwOZw4QQAAED+kePF3NDQUAUFBcnV1dXcFhkZqYYNG6pEiRIqXLiw2rZtq/Dw8JwOBQAAALApXDgBAACQv+R4MTc4OFienp5p2mJjY+Xi4mLednV1VUxMTE6HAgAAANgULpwAAADIXxxyY1DDMNK1mUymXIgEAAAAsF7BwcHp2u534cT+/fstGRYAAAByiEUegHYvNzc3Xbp0ybwdGxub5moCAAAAAI+GCycAAABsV64Uc728vBQVFaW4uDglJCRo06ZNatasWW6EAgAAANgULpwAAACwXbl2Ze7IkSPl7++vzp07y8fHRx4eHrkRCgAAAGBTuHACAADAdllszdyIiIg0276+vvL19bXU8AAAAEC+cPeFE0lJSerWrRsXTgAAANiIXHkAGgAAAIDsw4UTAAAA+UOuLLMAAAAAAAAAAMgarszN80xSwnnLDWdfUHJ6wnLjAQAAAAAAAHgoFHPzutQkKcrfcuM1Xma5sQAAAIBcZJIUd/2WxcZzcrCTc2Eni40HAABsD8VcAAAAAPlScqqhWcv2WGy8t/vUs9hYAADANrFmLgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBVwyO0AAAAAAAAA8PDibyYqMTnVYuM5OdjJubCTxcYDkDGKuQAAAAAAAFYkMTlVM7/ebbHx3u5Tz2JjAXgwllkAAAAAAAAAACtAMRcAAAAAAAAArADFXAAAAAAAAACwAhRzAQAAAAAAAMAKUMwFAAAAAAAAACvgkNsB3HH+/HnNmDFDRYoUUf369dWxY8fcDgkAAACwCeTaAAAAtiHPXJkbGhqqAQMGaPLkyVq3bl1uhwMAAADYDHJtAAAA25BnirmXLl2Sm5ubJMne3j6XowEAAABsB7k2AACAbcgzxdzSpUsrNjZWkpSamprL0QAAAAC2g1wbAADANuSZNXO7d++uadOmqUCBAuratWtuhwMAAADYDHJtAAAA25Djxdz4+Hj5+flp/vz5KleunCQpLCxM8+bNU1JSkvr376/evXvL1dVVH374YU6HAwAAANgMcm0AAID8JUeLufv27dO4ceMUHR1tbouJidGsWbO0evVqOTk5yc/PTw0aNFDVqlVzMhTkVYlXpJRblhnLZC8ZKZYZKzfGsy8oOT1hufEAWJYlf15K/EzJTpb87Pjc8hVybetjkhR33TI/D+xMJqUahkXGkiQnBzs5F3ay2HgAAMTfTFRisuWWj8or/9flaDE3NDRUQUFBGj16tLktMjJSDRs2VIkSJSRJbdu2VXh4uN54442cDAV5VcotaUcvy4zV6Cspyt8yY+XGeI2XWW4sAJZnyZ+XEj9TspMlPzs+t3yFXNv6JKcamrVsj0XGGtmrrsXGkqS3+9Sz2FgAAEhSYnKqZn6922Lj5ZX/63K0mBscHJyuLTY2Vi4uLuZtV1dX7d+/PyfDAAAAAGwOuTYAAED+Y2fpAY373OpjMpksHQYAAABgc8i1AQAAbJvFi7lubm66dOmSeTs2Nlaurq6WDgMAAACwOeTaAAAAts3ixVwvLy9FRUUpLi5OCQkJ2rRpk5o1a2bpMAAAAACbQ64NAABg23J0zdz7cXNz08iRI+Xv76+kpCR169ZNHh4elg4DAAAAsDnk2gAAALbNIsXciIiINNu+vr7y9fW1xNAAAACATSPXBgAAyD8svswCAAAAAAAAACDrKOYCAAAAAAAAgBWgmAsAAAAAAAAAVsDiD0DLbikpKZKkCxcuWG7QW7HS5WTLjHXuguXGkqSz56WCKZYbz5bn0tY/OwCWZcmflxI/U7KTJT87C35ud3KvO7kYbJOlc+1r8bd14/oli4wlSefPnbXZ8XLj2G5eL2Cx8YD8Ljd+XvJvHHmNrf47yCzPNhmGYeR4FDlo165d6t27d26HAQAAkC8tXbpUnp6euR0Gcgi5NgAAQO7IKM+2+mLurVu3dPDgQbm4uMje3j63wwEAAMgXUlJSdPHiRdWoUUMFCxbM7XCQQ8i1AQAALCuzPNvqi7kAAAAAAAAAkB/wADQAAAAAAAAAsAIUcwEAAAAAAADAClDMBQAAAAAAAAArQDEXAAAAAAAAAKwAxVwAAAAAAAAAsAIUcwEAAAAAAADAClDMBQAAAAAAAAArQDE3C8LCwuTt7a3WrVtr6dKluR1OrgkJCVGHDh3UoUMHTZ8+XZIUGRkpX19ftWnTRrNmzTLve/jwYXXt2lVt27bV2LFjlZycLEk6d+6cevfurXbt2mnw4MG6ceOGJOn69esaNGiQ2rdvr969e+vixYuWP0ALmDZtmgICAiRl3xwlJibqnXfeUfv27dWlSxedOHEidw4uh0REROill15Su3btNGXKFEmcdw9j3bp15n+v06ZNk8Q59yDx8fHy8fHRmTNnJOX8OWZLc3jv3K1YsUI+Pj7y9fVVYGCgEhMTJTF397p33u5YunSp+vbta97OrvkxDEPTpk1Tu3bt5O3trd27d1voSIHMkWs/HnL03EFebxl8F7AsvkNYBt89LM9mvrMYeCgXLlwwWrZsaVy5csW4ceOG4evraxw7diy3w7K4HTt2GD169DBu375tJCYmGv7+/kZYWJjRvHlz49SpU0ZSUpIxcOBAY+vWrYZhGEaHDh2MvXv3GoZhGIGBgcbSpUsNwzCMQYMGGRs2bDAMwzBCQkKM6dOnG4ZhGBMnTjQWLFhgGIZhrFmzxhgxYoRlD9ACIiMjjQYNGhhjxowxDCP75uizzz4zxo8fbxiGYfz6669Gt27dLHVIOe7UqVNGkyZNjPPnzxuJiYlGz549ja1bt3LeZeLmzZtG/fr1jcuXLxtJSUlGt27djB07dnDOZeD33383fHx8jOrVqxunT582EhIScvwcs5U5vHfu/vzzT6N169bG33//baSmphqjR482vvjiC8MwmLu73Ttvdxw7dsxo2rSp0adPH3Nbds3Pf//7X+PVV181UlJSjD///NN48cUXjaSkpBw/ViAz5NqPhxw9d5DXWwbfBSyL7xCWwXcPy7Ol7yxcmfuQIiMj1bBhQ5UoUUKFCxdW27ZtFR4entthWZyLi4sCAgLk5OQkR0dHValSRdHR0apYsaLKly8vBwcH+fr6Kjw8XGfPntWtW7dUu3ZtSdJLL72k8PBwJSUl6bffflPbtm3TtEvS1q1b5evrK0ny8fHRtm3blJSUlCvHmhOuXr2qWbNm6fXXX5ekbJ2jrVu3qmPHjpKk+vXr68qVKzp37pyFjzBn/PDDD/L29lbp0qXl6OioWbNmqVChQpx3mUhJSVFqaqoSEhKUnJys5ORkOTg4cM5lIDQ0VEFBQXJ1dZUk7d+/P8fPMVuZw3vnzsnJSRMmTJCzs7NMJpOqVaumc+fOMXf3uHfepH9+e//ee+9pxIgR5rbsnJ+ffvpJ3t7esrOzU6VKlVSmTBnt3bvXUocMZIhc+/GQo1seeb3l8F3AsvgOYRl897A8W/rOQjH3IcXGxsrFxcW87erqqpiYmFyMKHc8/fTT5hM6Ojpa33//vUwm033n5t45c3FxUUxMjK5cuSJnZ2c5ODikaZfSzrODg4OcnZ0VFxdnoaPLee+9955GjhypYsWKSUp/Xj3OHN2vrwsXLljq0HLUyZMnlZKSoldeeUUdO3bUsmXLMvw3yXn3f5ydnTVixAi1b99ezZo1U9myZeXo6Mg5l4Hg4GB5enqaty1xjtnKHN47d2XLlpWXl5ckKS4uTkuXLtULL7zA3N3j3nmTpA8//FBdu3ZVuXLlzG3ZOT+xsbFpisfWOG+wTeTaj4cc3fLI6y2H7wKWxXcIy+C7h+XZ0ncWirkPyTCMdG0mkykXIskbjh07poEDB2rMmDGqUKFCutdNJlOGc5bVubSzs43TdOXKlXrqqafUqFEjc1tOz5GtzF1KSoqioqI0Y8YMhYaG6sCBA+nWl5Q47+515MgRffvtt/rxxx+1fft22dnZaceOHen245y7v6yeS8xhejExMerXr5+6du2qBg0aMHeZ2LFjh86fP6+uXbumac/O+blfX9Y+b7AN5NrZgxzdMsjrLYvvApbFd4jcwXeP3GON31n41B6Sm5ubLl26ZN6+98qW/GT37t3q37+/Ro0apS5dumQ4N/e2X7x4Ua6uripZsqTi4+OVkpKSpl3657dPd96TnJys+Ph4lShRwnIHl4O+//577dixQ506ddLs2bMVERGhlStXZtscubq6plms/+73WLtSpUqpUaNGKlmypAoWLKgXXnhBO3bs4LzLxPbt29WoUSM9+eSTcnJy0ksvvaSdO3dyzj0kS/xss+U5PHHihHr27KkuXbpo6NChktLPKXOX1oYNG3Ts2DF16tRJ48aN08GDB/Xmm29m6/y4ubnZ3LzBNpBrPz5ydMshr7csvgtYFt8hcgffPXKHtX5noZj7kLy8vBQVFaW4uDglJCRo06ZNatasWW6HZXHnz5/X0KFDNXPmTHXo0EGSVKtWLf3111/m2182bNhgvh2jQIEC5idlr127Vs2aNZOjo6M8PT31/fffp2mXpObNm2vt2rWS/kmSPD095ejoaPkDzQFffPGFNmzYoHXr1mn48OFq1aqVpk6dmm1z1Lx5c61bt06StGvXLhUoUEBlypSx/IHmgJYtW2r79u26fv26UlJS9PPPP6tdu3acd5l45plnFBkZqZs3b8owDEVEROj555/nnHtIlvjZZqtzGB8fr1deeUUjRozQwIEDze3M3YNNnTpV//3vf7Vu3TpNmTJFNWrU0Mcff5yt89OsWTOFhYUpJSVFJ0+eVHR0tGrWrJkrxwvcjVz78ZCjWxZ5vWXxXcCy+A6RO/juYXnW/J3FZNzvOmHcV1hYmBYsWKCkpCR169ZNr776am6HZHFTpkzRt99+m+a2LT8/P/3rX//S1KlTdfv2bTVv3lyBgYEymUw6cuSIxo0bpxs3bui5557T1KlT5eTkpLNnzyogIECXL1/WU089pY8++kjFixfX1atXFRAQoNOnT6to0aKaOXNmmnUDbcXq1av166+/6oMPPsi2Obp9+7bee+89HTx4UE5OTpoyZYqqV6+e24eabVatWqUvv/xSSUlJaty4scaNG6edO3dy3mVi4cKFWr16tRwdHVWzZk0FBQXpr7/+4px7gFatWumrr75SuXLlFBUVlaPnmK3N4Z2527x5s2bOnKkqVaqkeW3EiBHM3X3cfc7dsXPnToWEhGjJkiWSlG3zYxiGpk+frm3btkmSAgMD1aRJk1w5buBe5NqPjhw995DXWwbfBSyL7xCWw3cPy7OF7ywUcwEAAAAAAADACrDMAgAAAAAAAABYAYq5AAAAAAAAAGAFKOYCAAAAAAAAgBWgmAsAAAAAAAAAVoBiLgAAAAAAAABYAYq5AHLUmTNn5O7urpUrV6Zp//zzzxUQEJBt47Rq1UoHDhzItv4eJD4+Xn5+furQoYM2btyY5rWtW7fqk08+sUgcWXX69GkNGzZMkhQTEyM/P79cjuj+7o4TAAAAD4/cO+/Ijdz71Vdf1fHjx3N8HAC5yyG3AwBg++zs7DRt2jR5enqqUqVKuR3OYzt8+LAuX76sH374Id1rBw4c0LVr13IhqsydO3dOf/31lyTJzc1Ny5cvz+WI7u/uOAEAAJA15N55Q27k3osWLcrxMQDkPoq5AHJcwYIFNWDAAI0aNUrLly+Xk5NTmtcDAgL09NNP65VXXkm33apVK/n4+Gjr1q26evWqhg0bpj179ujQoUNycHDQvHnz5ObmJklatmyZjhw5osTERA0YMEDdunWTJEVERGjevHlKSkpSwYIFNWbMGNWpU0dz5szR77//rtjYWLm7u2vmzJlp4tq8ebNCQkKUkpIiZ2dnBQYGytnZWe+++65iYmLUqVMnrVixQgULFpQk7du3T8uXL1dKSoqKFi2qihUratWqVUpISJCzs7MWLFigCRMmKDo6WteuXVORIkU0c+ZMVa5cWX379lXt2rW1Z88enT9/XvXq1dO0adOUmpqqyZMna8+ePXJ0dFS5cuU0depUFSlSRPPnz9fmzZt1+/ZtJSQkaMyYMWrdurWSk5M1Y8YMbd26Vfb29qpTp46CgoI0btw4xcTE6JVXXtHEiRPl6+urvXv3KikpSR988IGioqJkb28vDw8P87G2atVKXbp0UVRUlM6fP6/27dtr9OjRunHjhgIDA3Xy5EnZ2dmpevXqmjRpkuzs0t7wcezYMU2aNElXr16VyWTSwIED1blzZ+3cuVOTJ0/Whg0bJMm8vW7dujRxfv7559l/QgIAANgwcu/8m3u3atVKn3zyiW7evKlZs2apfPnyOnbsmBITE/Xee++pYcOGOXLOAbAsllkAYBGDBw9WoUKFNGvWrCy/9/bt21q/fr0CAgL03nvvqV+/flq/fr2eeuoprVmzxrxfgQIFtGbNGv3nP//Rhx9+qGPHjik6OlqzZs3SwoULtXbtWk2ePFnDhg3TzZs3JUlnz57VmjVr0iWTJ06cUFBQkObMmaOwsDANHz5cQ4YMkaurq6ZMmaIKFSpo3bp15mRSkmrVqiU/Pz95e3tr5MiRkqTjx49ryZIlWrJkibZt26ZixYopNDRUGzduVI0aNbR06VLz+0+dOqUlS5Zo/fr1+uWXX/Trr7/q999/16+//qr169dr9erVKl++vI4ePaqzZ88qMjJSX3/9tcLCwjRy5EjNnj1b0j+J9aFDh7Ru3Tpt2LBBN27c0Pfff2+O+94C6bx58xQbG6t169Zp3bp1Sk1N1fTp082v37x5U8uWLdPy5cv19ddf6/Tp0/rhhx9048YNrVu3TqtWrZL0z61kd0tOTtbgwYPVt29fhYWFadGiRfroo4+0d+/eDD9re3v7DOMEAADAwyH3zn+5973279+vgQMHau3aterWrZtCQkIe+hwAkLdxZS4Ai7Czs9OMGTPUpUsXNWnSJEvvbdOmjSSpfPnyKlWqlJ555hlJUoUKFdLcVnVnHSo3Nzc1adLE/Nvu2NhY9e/f37yfyWTSqVOnJEm1a9eWg0P6H4W//PKLGjZsqPLly0uSGjVqpJIlS+rgwYMymUwPHbu7u7ucnZ0lSe3atVP58uW1ZMkSnTx5Ur/++qvq1Klj3rdly5ays7OTs7OzKlasqGvXrqlRo0ayt7dX9+7d1aRJE7Vt21YeHh6SpGnTpiksLEwnT57Uvn37dOPGDUlSZGSkOnXqZE52P/74Y0n/XP16P9u2bdPIkSPl6OgoSerbt6+GDh1qfv2FF14wz+uTTz6pa9euqV69epo1a5b69u0rLy8v9evXTxUrVkzTb3R0tG7fvm3+/Nzc3NSmTRv9/PPPatCgwUPPIQAAALKG3Dv/5d73KlOmjJ599llJ0nPPPZemEA/AunFlLgCLKVOmjCZMmKAxY8boypUr5naTySTDMMzbSUlJad53961hd5Ke+7n7NiPDMOTg4KDU1FQ1atTI/JvvdevWKTQ0VE8//bQkqXDhwvft6+547m5LTk7O5CjTurv/ZcuWaezYsSpYsKB8fX3l4+OTZpy7rzS4MyfFihXTunXrNGbMGNnb2+vNN9/Ul19+qUOHDsnPz0/x8fFq3Lix/v3vf5vfe2+CfOnSJcXGxmYYY2pqarrtuz+DAgUKpIurfPny+uGHHzRo0CDFx8drwIABCg8Pf2C/0v/NYWafOQAAAB4PuXf+yr3vdb/jA2AbKOYCsKj27durWbNmWrx4sbntiSee0MGDByVJcXFx2rVr1yP1fee3zefOnVNkZKQaNWqkhg0baseOHTpx4oQk6aefflLHjh11+/btB/Z15313bl+6s25VrVq1Hvg+e3v7DJPO7du3q0uXLurevbsqVaqkiIgIpaSkPLC/H3/8Uf3791edOnU0bNgwde7cWUeOHNFvv/2mGjVqaMCAAXr++ee1ZcsWc1+NGjXShg0blJiYqNTUVE2YMEHfffed7O3t71s0bdq0qZYvX66kpCSlpqZq6dKlaty48QPjWrZsmQIDA9WkSRO98847atKkiY4dO5Zmn0qVKsnR0VGbNm2S9M9TfDdu3CgvLy+VLFlS586d0+XLl2UYhjZv3pxmDinuAgAAPD5y7/yTewPIP1hmAYDFjRs3Trt37zZv9+3bV2+//bbatm2rcuXK6fnnn3+kfm/fvq0uXbooKSlJ48aNMz+9d9KkSXrrrbfMVwzMmzcvw6sC7qhataqCgoL0xhtvKCUlRQULFtT8+fNVtGjRB76vUaNGGjZsmBwdHVW9evU0rw0cOFDvvfeeVq9eLXt7e1WvXl1//PHHA/tr1qyZtm3bJh8fHxUuXFjFixfX5MmTVbBgQW3atEne3t5ydHRUo0aNdO3aNcXHx8vPz09nz57VSy+9JMMw9Pzzz6tv3766ceOG7O3t1a1btzTrpw0ePFjTpk1T586dlZycLA8PD40fP/6BcXXu3Fm//vqrvL29VahQIZUpU0b+/v5p9nF0dNTcuXM1ZcoUzZkzRykpKRo6dKj5wQt+fn7q2rWrXFxc1KJFC/P7nn76aXOcK1euzNKtdQAAAEiL3Dt/5N4A8g+TwbX2AAAAAAAAAJDnscwCAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABWgGIuAAAAAAAAAFgBirkAAAAAAAAAYAUo5gIAAAAAAACAFaCYCwAAAAAAAABW4P8B0kTZ5z1AeEMAAAAASUVORK5CYII=\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": 143, - "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": 144, - "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": 145, - "metadata": {}, - "outputs": [], - "source": [ - "whales_tx=df[df[\"from_count\"]>60000]\n", - "whales_rx=df[df[\"to_count\"]>60000]" - ] - }, - { - "cell_type": "code", - "execution_count": 133, - "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": 133, - "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": 134, - "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": 134, - "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": 136, - "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": 137, - "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": 137, - "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": 138, - "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": 138, - "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": 2, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'transfers' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtransfers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'transfers' is not defined" - ] - } - ], - "source": [ - "transfers" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "transf" - ] - } - ], - "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 -} From 8312e7202b9a0cef38453c732863828bcd214157 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 18:57:01 +0200 Subject: [PATCH 46/87] transaction value breakdown --- datasets/nfts/notebooks/transfers_count.ipynb | 166 ++++++++++++++---- 1 file changed, 128 insertions(+), 38 deletions(-) diff --git a/datasets/nfts/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb index 3b9f4917..82905ee8 100644 --- a/datasets/nfts/notebooks/transfers_count.ipynb +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -59,7 +59,7 @@ "Text(0.5, 1.0, 'NFT transfers value over time')" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -103,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -124,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -181,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -191,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -237,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -247,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -302,7 +302,7 @@ "0xcDA72070E455bb31C7690a170224Ce43623d0B6f 76645.0 36116.0" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -325,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -374,7 +374,7 @@ "0x327305A797d92a39cEe1a225D7E2A1cC42B1a8fA NaN 106620.0" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -396,7 +396,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -447,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -502,7 +502,7 @@ "0xcDA72070E455bb31C7690a170224Ce43623d0B6f 76645.0 36116.0" ] }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -526,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -575,7 +575,7 @@ "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C 14124.0 23128.0" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -597,7 +597,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -607,7 +607,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -631,7 +631,7 @@ "Name: transaction_value, dtype: float64" ] }, - "execution_count": 24, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -644,27 +644,106 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "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", + "
transaction_value
nft_address
0x00000000000b7F8E8E8Ad148f9d53303Bfe207960.000000e+00
0x000000000437b3CCE2530936156388Bff5578FC34.175880e+18
0x000000000A42C2791eEc307FFf43Fa5c640e3Ef70.000000e+00
0x000000F36EDb9d436Be73cDBf0DCa7dF3E6F3A500.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" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "total_value_per_nft = transfers[\"nft_address\"].groupby(transfers[\"transaction_value\"]).sum()\n", + "total_value_per_nft = transfers[[\"nft_address\", \"transaction_value\"]].groupby(transfers[\"nft_address\"]).sum()\n", "total_value_per_nft.head(4)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "nft_address\n", + "0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 2.296429e+23\n", + "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D 1.588150e+23\n", + "0x60E4d786628Fea6478F785A6d7e704777c86a7c6 7.530649e+22\n", + "Name: transaction_value, dtype: float64" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "most_popular_nfts = transactions_per_nft.sort_values(ascending=False).head(8)\n", - "most_valuable_nfts = total_value_per_nft.sort_values(ascending=False).head(8)" + "most_valuable_nfts = total_value_per_nft[\"transaction_value\"].sort_values(ascending=False).head(3)\n", + "most_valuable_nfts" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -684,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -701,13 +780,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# plt.figure(figsize=(24, 12))\n", + "plt.figure(figsize=(24, 12))\n", "# new_df.unstack()\n", - "# ax = sns.lineplot(data=new_df, x='timestamp', y='transaction_value', hue='nft_address',)" + "ax = sns.lineplot(data=new_df, x='timestamp', y='transaction_value', hue='nft_address',)" ] }, { From 8b352b758f33529f49c224b1df66a6d9881d8b5a Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Thu, 7 Oct 2021 21:58:38 +0200 Subject: [PATCH 47/87] removed everything non developer related --- frontend/pages/index.js | 100 +++++++++++++++++++++++--------------- frontend/pages/welcome.js | 55 --------------------- 2 files changed, 60 insertions(+), 95 deletions(-) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 91c5be10..88d1e1fe 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -254,7 +254,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. + Product analytics for Web3. Moonstream helps you + understand exactly how people are using your smart + contracts. - Access this data through the Moonstream dashboard or API - + */} @@ -285,7 +285,7 @@ const Homepage = () => { colSpan="12" // pt={["20px", "20px", "100px", null, "120px"]} pt={0} - pb={["20px", "56px", null, "184px"]} + // pb={["20px", "56px", null, "184px"]} minH="100vh" > { // mb={[12, 12, 12, null, 48]} fontSize={["md", "2xl", "3xl", "3xl", "3xl", "4xl"]} > - {` 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. open source @@ -313,10 +313,10 @@ const Homepage = () => { - Data you can add to your stream: + See how your smart contracts are being used from: @@ -360,7 +360,7 @@ const Homepage = () => { Social media posts -
+ {/*
Moonstream is meant for you if @@ -404,9 +404,9 @@ const Homepage = () => { }, }} /> - + */} - { ]} imgURL={assets["cryptoTraders"]} /> - - */} + {/* { ]} imgURL={assets["algorithmicFunds"]} /> - + */} { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { @@ -553,7 +553,7 @@ const Homepage = () => { bgColor: "blue.900", }, ]} - imgURL={assets["smartDevelopers"]} + imgURL={assets["cryptoTraders"]} /> { 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`, + } + ); + toggleModal("hubspot"); + }} + 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`, + } + ); + toggleModal("hubspot-developer"); + }} + > + request early access + + +
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 - - - )} From 60763864ef6efab5056525eace2c8961c0fdd9e5 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Fri, 8 Oct 2021 02:36:59 +0300 Subject: [PATCH 48/87] Add fixes. --- datasets/nfts/nfts/derive.py | 171 ++++++++++++++++++++--------------- 1 file changed, 96 insertions(+), 75 deletions(-) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 0f5c3de8..9f57ded8 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -148,9 +148,9 @@ def current_values_distribution(conn: sqlite3.Connection) -> None: current_values_distribution_query = """ CREATE TABLE market_values_distribution AS select - nft_address as address, + 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 + CAST(current_market_values.market_value as REAL) / max_values.max_value as relative_value from current_market_values inner join ( @@ -214,7 +214,7 @@ def transfer_statistics_by_address(conn: sqlite3.Connection) -> None: conn.commit() except Exception as e: conn.rollback() - logger.error("Could not create derived dataset: current_values_distribution") + logger.error("Could not create derived dataset: transfer_statistics_by_address") logger.error(e) @@ -223,66 +223,78 @@ def qurtile_generating(conn: sqlite3.Connection): Create qurtile wich depends on setted on class defenition """ ensure_custom_aggregate_functions(conn) - drop_calculate_qurtiles = ( + drop_calculate_10_qurtiles = ( "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" ) - calculate_qurtiles = """ + calculate_10_qurtiles = """ CREATE TABLE transfer_values_quartile_10_distribution_per_address AS - select qurtiled_sum.address as address, - SUM(qurtiled_sum.sum_of_qurtile) over (PARTITION BY qurtiled_sum.address order by qurtiled_sum.qurtiles ) as cululative_total, - qurtiled_sum.qurtiles as qurtiles - from ( - select - qurtiled.address, - count(qurtiled.relative_value)/count_value.count_value as sum_of_qurtile, - qurtiled.qurtiles as qurtiles + select + cumulate.address as address, + CAST(qurtile_10(cumulate.relative_value) as TEXT) as qurtiles, + cumulate.relative_value as relative_value from - ( - select - cumulate.address as address, - quartile_10(cumulate.relative_value) as qurtiles, - 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 - ) as qurtiled - inner join ( + ( select - current_market_values.nft_address, - count(market_value) as count_value + 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 - group by - current_market_values.nft_address - ) as count_value on qurtiled.address = count_value.nft_address - ) as qurtiled_sum; + 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_qurtiles = ( + "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" + ) + calculate_25_qurtiles = """ + CREATE TABLE transfer_values_quartile_10_distribution_per_address AS + select + cumulate.address as address, + CAST(qurtile_10(cumulate.relative_value) as TEXT) as qurtiles, + 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: - cur.execute(drop_calculate_qurtiles) - cur.execute(calculate_qurtiles) + cur.execute(drop_calculate_10_qurtiles) + cur.execute(calculate_10_qurtiles) + cur.execute(drop_calculate_25_qurtiles) + cur.execute(calculate_25_qurtiles) conn.commit() except Exception as e: conn.rollback() - logger.error("Could not create derived dataset: current_values_distribution") + logger.error("Could not create derived dataset: qurtile_generating") logger.error(e) @@ -293,10 +305,10 @@ def transfers_mints_connection_table(conn: sqlite3.Connection): drop_transfers_mints_connection = "DROP TABLE IF EXISTS transfers_mints;" transfers_mints_connection = """ - CREATE transfers_mints as + CREATE TABLE transfers_mints as select - transfers.event_id, - mints.mint_id + transfers.event_id as transfer_id, + mints.mint_id as mint_id from transfers inner join ( @@ -351,7 +363,9 @@ def transfers_mints_connection_table(conn: sqlite3.Connection): conn.commit() except Exception as e: conn.rollback() - logger.error("Could not create derived dataset: current_values_distribution") + logger.error( + "Could not create derived dataset: transfers_mints_connection_table" + ) logger.error(e) @@ -360,27 +374,34 @@ 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 - nft_address, - token_id, - min(timestamp) as firts_transfer + 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 - transfers - group by - nft_address, - token_id - ) as firsts_transfers on firsts_transfers.nft_address = mints.nft_address - and firsts_transfers.token_id = mints.token_id ) as days_after_minted + 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() @@ -390,7 +411,7 @@ def mint_holding_times(conn: sqlite3.Connection): conn.commit() except Exception as e: conn.rollback() - logger.error("Could not create derived dataset: current_values_distribution") + logger.error("Could not create derived dataset: mint_holding_times") logger.error(e) @@ -433,5 +454,5 @@ def transfer_holding_times(conn: sqlite3.Connection): conn.commit() except Exception as e: conn.rollback() - logger.error("Could not create derived dataset: current_values_distribution") + logger.error("Could not create derived dataset: transfer_holding_times") logger.error(e) From 97b20b872d6b5a112d5de4dccb4821d823e0dfd7 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Fri, 8 Oct 2021 03:25:29 +0300 Subject: [PATCH 49/87] Fix misspell. --- datasets/nfts/nfts/cli.py | 2 +- datasets/nfts/nfts/derive.py | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 8187f969..2ad43ae4 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -33,7 +33,7 @@ derive_functions = { "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, "transfer_statistics_by_address": transfer_statistics_by_address, - # "qurtile_generating": qurtile_generating, + "qurtile_generating": qurtile_generating, "transfers_mints_connection_table": transfers_mints_connection_table, "mint_holding_times": mint_holding_times, "transfer_holding_times": transfer_holding_times, diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 9f57ded8..d9b760e8 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -230,7 +230,7 @@ def qurtile_generating(conn: sqlite3.Connection): CREATE TABLE transfer_values_quartile_10_distribution_per_address AS select cumulate.address as address, - CAST(qurtile_10(cumulate.relative_value) as TEXT) as qurtiles, + CAST(quartile_10(cumulate.relative_value) as TEXT) as qurtiles, cumulate.relative_value as relative_value from ( @@ -261,7 +261,7 @@ def qurtile_generating(conn: sqlite3.Connection): CREATE TABLE transfer_values_quartile_10_distribution_per_address AS select cumulate.address as address, - CAST(qurtile_10(cumulate.relative_value) as TEXT) as qurtiles, + CAST(quartile_25(cumulate.relative_value) as TEXT) as qurtiles, cumulate.relative_value as relative_value from ( @@ -287,8 +287,10 @@ def qurtile_generating(conn: sqlite3.Connection): """ cur = conn.cursor() try: + print("Creating transfer_values_quartile_10_distribution_per_address") cur.execute(drop_calculate_10_qurtiles) cur.execute(calculate_10_qurtiles) + print("Creating transfer_values_quartile_25_distribution_per_address") cur.execute(drop_calculate_25_qurtiles) cur.execute(calculate_25_qurtiles) conn.commit() From 1c76d2fb1db7e34089f5f4806e0016a76d13b850 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Fri, 8 Oct 2021 04:01:19 +0300 Subject: [PATCH 50/87] Add fixes. --- datasets/nfts/nfts/cli.py | 4 ++-- datasets/nfts/nfts/derive.py | 34 +++++++++++++++++----------------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 2ad43ae4..4111ccdd 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -16,7 +16,7 @@ from .derive import ( current_market_values, current_values_distribution, transfer_statistics_by_address, - qurtile_generating, + quartile_generating, mint_holding_times, transfer_holding_times, transfers_mints_connection_table, @@ -33,7 +33,7 @@ derive_functions = { "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, "transfer_statistics_by_address": transfer_statistics_by_address, - "qurtile_generating": qurtile_generating, + "quartile_generating": quartile_generating, "transfers_mints_connection_table": transfers_mints_connection_table, "mint_holding_times": mint_holding_times, "transfer_holding_times": transfer_holding_times, diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index d9b760e8..65b4d421 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -51,8 +51,8 @@ class LastNonzeroValue: class QuartileFunction: """ Split vlues to quartiles """ - def __init__(self, num_qurtiles) -> None: - self.divider = 1 / num_qurtiles + def __init__(self, num_quartiles) -> None: + self.divider = 1 / num_quartiles def __call__(self, value): if value is None or value == "None": @@ -63,9 +63,9 @@ class QuartileFunction: quartile += self.divider if quartile > 1: - qurtile = 1 + quartile = 1 - return qurtile + return quartile except Exception as err: print(err) @@ -218,19 +218,19 @@ def transfer_statistics_by_address(conn: sqlite3.Connection) -> None: logger.error(e) -def qurtile_generating(conn: sqlite3.Connection): +def quartile_generating(conn: sqlite3.Connection): """ - Create qurtile wich depends on setted on class defenition + Create quartile wich depends on setted on class defenition """ ensure_custom_aggregate_functions(conn) - drop_calculate_10_qurtiles = ( + drop_calculate_10_quartiles = ( "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" ) - calculate_10_qurtiles = """ + calculate_10_quartiles = """ CREATE TABLE transfer_values_quartile_10_distribution_per_address AS select cumulate.address as address, - CAST(quartile_10(cumulate.relative_value) as TEXT) as qurtiles, + CAST(quartile_10(cumulate.relative_value) as TEXT) as quartiles, cumulate.relative_value as relative_value from ( @@ -254,14 +254,14 @@ def qurtile_generating(conn: sqlite3.Connection): ) as cumulate """ - drop_calculate_25_qurtiles = ( + drop_calculate_25_quartiles = ( "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" ) - calculate_25_qurtiles = """ + calculate_25_quartiles = """ CREATE TABLE transfer_values_quartile_10_distribution_per_address AS select cumulate.address as address, - CAST(quartile_25(cumulate.relative_value) as TEXT) as qurtiles, + CAST(quartile_25(cumulate.relative_value) as TEXT) as quartiles, cumulate.relative_value as relative_value from ( @@ -288,15 +288,15 @@ def qurtile_generating(conn: sqlite3.Connection): cur = conn.cursor() try: print("Creating transfer_values_quartile_10_distribution_per_address") - cur.execute(drop_calculate_10_qurtiles) - cur.execute(calculate_10_qurtiles) + cur.execute(drop_calculate_10_quartiles) + cur.execute(calculate_10_quartiles) print("Creating transfer_values_quartile_25_distribution_per_address") - cur.execute(drop_calculate_25_qurtiles) - cur.execute(calculate_25_qurtiles) + cur.execute(drop_calculate_25_quartiles) + cur.execute(calculate_25_quartiles) conn.commit() except Exception as e: conn.rollback() - logger.error("Could not create derived dataset: qurtile_generating") + logger.error("Could not create derived dataset: quartile_generating") logger.error(e) From 9ad069e132a9697239f659d9dc9b31aab89d2c09 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Fri, 8 Oct 2021 04:44:09 +0300 Subject: [PATCH 51/87] Fix copy paste( --- datasets/nfts/nfts/derive.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 65b4d421..13e16f3d 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -258,7 +258,7 @@ def quartile_generating(conn: sqlite3.Connection): "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" ) calculate_25_quartiles = """ - CREATE TABLE transfer_values_quartile_10_distribution_per_address AS + CREATE TABLE transfer_values_quartile_25_distribution_per_address AS select cumulate.address as address, CAST(quartile_25(cumulate.relative_value) as TEXT) as quartiles, From 2ec5a0a4e2acdfde653e7968f3114da087171e27 Mon Sep 17 00:00:00 2001 From: Andrey Dolgolev Date: Fri, 8 Oct 2021 04:44:40 +0300 Subject: [PATCH 52/87] fix one more. --- datasets/nfts/nfts/derive.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 13e16f3d..8a09d6fb 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -255,7 +255,7 @@ def quartile_generating(conn: sqlite3.Connection): """ drop_calculate_25_quartiles = ( - "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" + "DROP TABLE IF EXISTS transfer_values_quartile_25_distribution_per_address;" ) calculate_25_quartiles = """ CREATE TABLE transfer_values_quartile_25_distribution_per_address AS From 841189319b1aa9f24c0eea99174f7889aad37a13 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Thu, 7 Oct 2021 19:30:41 -0700 Subject: [PATCH 53/87] quartile -> quantile --- datasets/nfts/nfts/cli.py | 45 ++++++++++++++++++------ datasets/nfts/nfts/derive.py | 68 ++++++++++++++++++------------------ 2 files changed, 68 insertions(+), 45 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index fc60dcf2..63fe9be9 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -16,7 +16,7 @@ from .derive import ( current_market_values, current_values_distribution, transfer_statistics_by_address, - quartile_generating, + quantile_generating, mint_holding_times, transfer_holding_times, transfers_mints_connection_table, @@ -33,7 +33,7 @@ derive_functions = { "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, "transfer_statistics_by_address": transfer_statistics_by_address, - "quartile_generating": quartile_generating, + "quantile_generating": quantile_generating, "transfers_mints_connection_table": transfers_mints_connection_table, "mint_holding_times": mint_holding_times, "transfer_holding_times": transfer_holding_times, @@ -70,7 +70,9 @@ def handle_filter_data(args: argparse.Namespace) -> None: 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, + source_conn, + start_time=args.start_time, + end_time=args.end_time, ) print("Filtering end.") for index, function_name in enumerate(derive_functions.keys()): @@ -99,7 +101,11 @@ def handle_materialize(args: argparse.Namespace) -> None: sqlite3.connect(args.datastore) ) as moonstream_datastore: create_dataset( - moonstream_datastore, db_session, event_type, bounds, args.batch_size, + moonstream_datastore, + db_session, + event_type, + bounds, + args.batch_size, ) @@ -111,11 +117,17 @@ def handle_enrich(args: argparse.Namespace) -> None: with contextlib.closing(sqlite3.connect(args.datastore)) as moonstream_datastore: enrich( - moonstream_datastore, EventType.TRANSFER, batch_loader, args.batch_size, + moonstream_datastore, + EventType.TRANSFER, + batch_loader, + args.batch_size, ) enrich( - moonstream_datastore, EventType.MINT, batch_loader, args.batch_size, + moonstream_datastore, + EventType.MINT, + batch_loader, + args.batch_size, ) @@ -222,7 +234,9 @@ def main() -> None: 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", + "--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" @@ -245,19 +259,28 @@ def main() -> None: # Create dump of filtered data parser_filtered_copy = subcommands.add_parser( - "filter-data", description="Create copy of database with applied filters.", + "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", + "--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.", + "--start-time", + required=False, + type=int, + help="Start timestamp.", ) parser_filtered_copy.add_argument( - "--end-time", required=False, type=int, help="End timestamp.", + "--end-time", + required=False, + type=int, + help="End timestamp.", ) parser_filtered_copy.set_defaults(func=handle_filter_data) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 8a09d6fb..4c1cf3ea 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -48,24 +48,24 @@ class LastNonzeroValue: return self.value -class QuartileFunction: - """ Split vlues to quartiles """ +class QuantileFunction: + """Split vlues to quantiles""" - def __init__(self, num_quartiles) -> None: - self.divider = 1 / num_quartiles + def __init__(self, num_quantiles) -> None: + self.divider = 1 / num_quantiles def __call__(self, value): if value is None or value == "None": value = 0 - quartile = self.divider + quantile = self.divider try: - while value > quartile: - quartile += self.divider + while value > quantile: + quantile += self.divider - if quartile > 1: - quartile = 1 + if quantile > 1: + quantile = 1 - return quartile + return quantile except Exception as err: print(err) @@ -78,8 +78,8 @@ def ensure_custom_aggregate_functions(conn: sqlite3.Connection) -> None: """ conn.create_aggregate("last_value", 1, LastValue) conn.create_aggregate("last_nonzero_value", 1, LastNonzeroValue) - conn.create_function("quartile_10", 1, QuartileFunction(10)) - conn.create_function("quartile_25", 1, QuartileFunction(25)) + conn.create_function("quantile_10", 1, QuantileFunction(10)) + conn.create_function("quantile_25", 1, QuantileFunction(25)) def current_owners(conn: sqlite3.Connection) -> None: @@ -218,19 +218,19 @@ def transfer_statistics_by_address(conn: sqlite3.Connection) -> None: logger.error(e) -def quartile_generating(conn: sqlite3.Connection): +def quantile_generating(conn: sqlite3.Connection): """ - Create quartile wich depends on setted on class defenition + Create quantile wich depends on setted on class defenition """ ensure_custom_aggregate_functions(conn) - drop_calculate_10_quartiles = ( - "DROP TABLE IF EXISTS transfer_values_quartile_10_distribution_per_address;" + drop_calculate_10_quantiles = ( + "DROP TABLE IF EXISTS transfer_values_quantile_10_distribution_per_address;" ) - calculate_10_quartiles = """ - CREATE TABLE transfer_values_quartile_10_distribution_per_address AS + calculate_10_quantiles = """ + CREATE TABLE transfer_values_quantile_10_distribution_per_address AS select cumulate.address as address, - CAST(quartile_10(cumulate.relative_value) as TEXT) as quartiles, + CAST(quantile_10(cumulate.relative_value) as TEXT) as quantiles, cumulate.relative_value as relative_value from ( @@ -252,16 +252,16 @@ def quartile_generating(conn: sqlite3.Connection): current_market_values.nft_address ) as max_values on current_market_values.nft_address = max_values.nft_address ) as cumulate - + """ - drop_calculate_25_quartiles = ( - "DROP TABLE IF EXISTS transfer_values_quartile_25_distribution_per_address;" + drop_calculate_25_quantiles = ( + "DROP TABLE IF EXISTS transfer_values_quantile_25_distribution_per_address;" ) - calculate_25_quartiles = """ - CREATE TABLE transfer_values_quartile_25_distribution_per_address AS + calculate_25_quantiles = """ + CREATE TABLE transfer_values_quantile_25_distribution_per_address AS select cumulate.address as address, - CAST(quartile_25(cumulate.relative_value) as TEXT) as quartiles, + CAST(quantile_25(cumulate.relative_value) as TEXT) as quantiles, cumulate.relative_value as relative_value from ( @@ -283,20 +283,20 @@ def quartile_generating(conn: sqlite3.Connection): 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_quartile_10_distribution_per_address") - cur.execute(drop_calculate_10_quartiles) - cur.execute(calculate_10_quartiles) - print("Creating transfer_values_quartile_25_distribution_per_address") - cur.execute(drop_calculate_25_quartiles) - cur.execute(calculate_25_quartiles) + 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: quartile_generating") + logger.error("Could not create derived dataset: quantile_generating") logger.error(e) @@ -307,7 +307,7 @@ def transfers_mints_connection_table(conn: sqlite3.Connection): drop_transfers_mints_connection = "DROP TABLE IF EXISTS transfers_mints;" transfers_mints_connection = """ - CREATE TABLE transfers_mints as + CREATE TABLE transfers_mints as select transfers.event_id as transfer_id, mints.mint_id as mint_id From cf3833bec495263bd868ff2f2034385148331809 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Thu, 7 Oct 2021 19:32:47 -0700 Subject: [PATCH 54/87] Whitespace --- datasets/nfts/nfts/derive.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 4c1cf3ea..98b15d53 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -252,7 +252,6 @@ def quantile_generating(conn: sqlite3.Connection): 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;" @@ -283,7 +282,6 @@ def quantile_generating(conn: sqlite3.Connection): current_market_values.nft_address ) as max_values on current_market_values.nft_address = max_values.nft_address ) as cumulate - """ cur = conn.cursor() try: From ab04ae39170f00fc56f9ecf1efe857eda5d48fad Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Thu, 7 Oct 2021 20:32:03 -0700 Subject: [PATCH 55/87] Added "nfts.dataset" module --- datasets/nfts/.gitignore | 1 + datasets/nfts/nfts/dataset.py | 118 ++++++++++++++++++++++++++++++++++ datasets/nfts/setup.py | 3 +- 3 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 datasets/nfts/nfts/dataset.py diff --git a/datasets/nfts/.gitignore b/datasets/nfts/.gitignore index adc9bb00..5f4df389 100644 --- a/datasets/nfts/.gitignore +++ b/datasets/nfts/.gitignore @@ -164,3 +164,4 @@ cython_debug/ .nfts/ venv/ .secrets/ +.analysis/ diff --git a/datasets/nfts/nfts/dataset.py b/datasets/nfts/nfts/dataset.py new file mode 100644 index 00000000..19cc53b6 --- /dev/null +++ b/datasets/nfts/nfts/dataset.py @@ -0,0 +1,118 @@ +""" +Functions to access various data in the NFTs dataset. +""" +import sqlite3 +from typing import Union + +import pandas as pd + +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" + +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. +""", +} + + +def explain() -> None: + """ + Explains the structure of the dataset. + """ + preamble = """ +The Moonstream NFTs dataset +=========================== + +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\t{name}_df = nfts.dataset.load_dataframe(, {name})" + ) + print("") + print(explanation) + print("- - -") + + +def load_dataframe(db: Union[str, sqlite3.Connection], 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_table(name, db) + return df diff --git a/datasets/nfts/setup.py b/datasets/nfts/setup.py index d0b5a435..77e17dfa 100644 --- a/datasets/nfts/setup.py +++ b/datasets/nfts/setup.py @@ -33,9 +33,10 @@ setup( install_requires=[ "moonstreamdb", "humbug", + "pandas", + "requests", "tqdm", "web3", - "requests", ], extras_require={ "dev": ["black", "mypy", "types-requests"], From 4b41b4cb3896c9e6e8e3e8a6b5e6cd2961033d54 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Thu, 7 Oct 2021 21:01:13 -0700 Subject: [PATCH 56/87] Made "nfts.dataset" more userfriendly --- datasets/nfts/nfts/dataset.py | 43 ++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 13 deletions(-) diff --git a/datasets/nfts/nfts/dataset.py b/datasets/nfts/nfts/dataset.py index 19cc53b6..112def74 100644 --- a/datasets/nfts/nfts/dataset.py +++ b/datasets/nfts/nfts/dataset.py @@ -2,7 +2,7 @@ Functions to access various data in the NFTs dataset. """ import sqlite3 -from typing import Union +from typing import Dict import pandas as pd @@ -92,27 +92,44 @@ def explain() -> None: 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\t{name}_df = nfts.dataset.load_dataframe(, {name})" + f'Load using:\n\t{name}_df = ds.load_dataframe(, "{name}")' ) print("") print(explanation) print("- - -") -def load_dataframe(db: Union[str, sqlite3.Connection], 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_table(name, db) - return df +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) + + 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_all(self) -> Dict[str, pd.DataFrame]: + """ + Load all the datasets and return them in a dictionary with the keys being the dataframe names. + """ + dfs = {f"{name}_df": self.load_dataframe(name) for name in AVAILABLE_DATAFRAMES} + return dfs From 96bc61d52a46231a8ace62c2ba4a6e0695387b88 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Fri, 8 Oct 2021 13:43:31 +0200 Subject: [PATCH 57/87] fix lint errors --- frontend/pages/index.js | 30 ------------------------------ 1 file changed, 30 deletions(-) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 88d1e1fe..4ac8c0f7 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -11,7 +11,6 @@ import { Heading, Box, Image as ChakraImage, - Button, Center, chakra, Stack, @@ -39,27 +38,6 @@ const SplitWithImage = dynamic( 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) ); @@ -68,14 +46,6 @@ 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) ); From a2ea96b35e5e8cb980c7149e22d246bba78db85e Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Fri, 8 Oct 2021 05:36:25 -0700 Subject: [PATCH 58/87] Made filters inclusive of start and end times This was a bug that I introduced in my review of @Andrei-Dolgolev's changes. --- datasets/nfts/nfts/datastore.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/datasets/nfts/nfts/datastore.py b/datasets/nfts/nfts/datastore.py index e78ce9ae..0f3f361e 100644 --- a/datasets/nfts/nfts/datastore.py +++ b/datasets/nfts/nfts/datastore.py @@ -445,20 +445,20 @@ def filter_data( """ cur = sqlite_db.cursor() - print(f"Remove by timestamp <= {start_time}") + print(f"Remove by timestamp < {start_time}") if start_time: - cur.execute(f"DELETE from transfers where timestamp <= {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}") + 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}") + print(f"Remove by timestamp > {end_time}") if end_time: - cur.execute(f"DELETE from transfers where timestamp >= {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}") + cur.execute(f"DELETE from mints where timestamp > {end_time}") print(f"Mints filtered out: {cur.rowcount}") sqlite_db.commit() From 45d7d32ad518c75c85ed1fa21a1a557bb5c908f7 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Fri, 8 Oct 2021 07:01:43 -0700 Subject: [PATCH 59/87] Added ownership_transitions derived dataset --- datasets/nfts/nfts/cli.py | 8 +++++--- datasets/nfts/nfts/derive.py | 38 +++++++++++++++++++++++++++++++++++- 2 files changed, 42 insertions(+), 4 deletions(-) diff --git a/datasets/nfts/nfts/cli.py b/datasets/nfts/nfts/cli.py index 63fe9be9..d0ea90b4 100644 --- a/datasets/nfts/nfts/cli.py +++ b/datasets/nfts/nfts/cli.py @@ -18,6 +18,7 @@ from .derive import ( transfer_statistics_by_address, quantile_generating, mint_holding_times, + ownership_transitions, transfer_holding_times, transfers_mints_connection_table, ) @@ -32,11 +33,12 @@ derive_functions = { "current_owners": current_owners, "current_market_values": current_market_values, "current_values_distribution": current_values_distribution, - "transfer_statistics_by_address": transfer_statistics_by_address, - "quantile_generating": quantile_generating, - "transfers_mints_connection_table": transfers_mints_connection_table, "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, } diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 98b15d53..88ca02ea 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -6,7 +6,6 @@ For example: - Current value of each token """ import logging -from typing import List, Tuple import sqlite3 @@ -109,6 +108,7 @@ def current_owners(conn: sqlite3.Connection) -> None: 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 @@ -456,3 +456,39 @@ def transfer_holding_times(conn: sqlite3.Connection): 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) From 0f0537b71b1d3fe3fc3744df46aa2534672d3b9b Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Fri, 8 Oct 2021 07:07:27 -0700 Subject: [PATCH 60/87] black formatting --- datasets/nfts/nfts/derive.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datasets/nfts/nfts/derive.py b/datasets/nfts/nfts/derive.py index 88ca02ea..37bf2321 100644 --- a/datasets/nfts/nfts/derive.py +++ b/datasets/nfts/nfts/derive.py @@ -108,7 +108,6 @@ def current_owners(conn: sqlite3.Connection) -> None: 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 @@ -457,6 +456,7 @@ def transfer_holding_times(conn: sqlite3.Connection): 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 fc75417407b8fa54e2543368b51450f524fc2ad7 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Fri, 8 Oct 2021 07:47:40 -0700 Subject: [PATCH 61/87] Added dataset loader for ownership_transitions --- datasets/nfts/nfts/dataset.py | 58 +++++++++++++++++++++++++++++++---- datasets/nfts/setup.py | 2 ++ 2 files changed, 54 insertions(+), 6 deletions(-) diff --git a/datasets/nfts/nfts/dataset.py b/datasets/nfts/nfts/dataset.py index 112def74..16c70e4e 100644 --- a/datasets/nfts/nfts/dataset.py +++ b/datasets/nfts/nfts/dataset.py @@ -2,9 +2,10 @@ Functions to access various data in the NFTs dataset. """ import sqlite3 -from typing import Dict +from typing import Any, List, Tuple import pandas as pd +import scipy.sparse from .datastore import event_tables, EventType @@ -19,6 +20,7 @@ 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. @@ -84,6 +86,21 @@ Columns: } +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. @@ -101,12 +118,18 @@ This dataset consists of the following dataframes:""" for name, explanation in AVAILABLE_DATAFRAMES.items(): print(f"\nDataframe: {name}") print( - f'Load using:\n\t{name}_df = ds.load_dataframe(, "{name}")' + f'Load using:\n>>> {name}_df = ds.load_dataframe(, "{name}")' ) print("") print(explanation) print("- - -") + for name, explanation in AVAILABLE_MATRICES: + print(f"\nMatrix: {name}") + print("") + print(explanation) + print("- - -") + class FromSQLite: def __init__(self, datafile: str) -> None: @@ -127,9 +150,32 @@ class FromSQLite: df = pd.read_sql_query(f"SELECT * FROM {name};", self.conn) return df - def load_all(self) -> Dict[str, pd.DataFrame]: + def load_ownership_transitions(self) -> Tuple[List[str], Any]: """ - Load all the datasets and return them in a dictionary with the keys being the dataframe names. + Loads ownership transitions adjacency matrix from SQLite database. + + To learn more about this matrix, run: + >>> nfts.dataset.explain() """ - dfs = {f"{name}_df": self.load_dataframe(name) for name in AVAILABLE_DATAFRAMES} - return dfs + 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;" + + for from_address, to_address, num_transitions in cur.execute(adjacency_query): + from_index = address_indexes[from_address] + to_index = address_indexes[to_address] + adjacency_matrix[from_index, to_index] = num_transitions + + return addresses, adjacency_matrix diff --git a/datasets/nfts/setup.py b/datasets/nfts/setup.py index 77e17dfa..4d8d17b8 100644 --- a/datasets/nfts/setup.py +++ b/datasets/nfts/setup.py @@ -33,8 +33,10 @@ setup( install_requires=[ "moonstreamdb", "humbug", + "numpy", "pandas", "requests", + "scipy", "tqdm", "web3", ], From 0ea64c8cd76e209e845247bb04f1017d3de2de0a Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Fri, 8 Oct 2021 17:27:20 +0200 Subject: [PATCH 62/87] content improvements --- frontend/pages/index.js | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 4ac8c0f7..913dfd5e 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -64,9 +64,7 @@ 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`, - smartDevelopers: `${AWS_ASSETS_PATH}/smart+contract+developers.png`, }; const Homepage = () => { const ui = useContext(UIContext); @@ -273,8 +271,13 @@ const Homepage = () => { > We believe that the blockchain is for everyone. This requires complete transparency. That’s why all our - software is open source. - + software is{" "} + open source @@ -505,7 +508,7 @@ const Homepage = () => { badge={`For smart contract developers`} bullets={[ { - text: `See how people use your smart contracts`, + text: `Monitor blockchain data in real time`, icon: IoTelescopeSharp, color: "blue.50", bgColor: "blue.900", From fe1e82b9577fa92d551dd50faafabc2e7e9ae7cb Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Fri, 8 Oct 2021 17:48:17 +0200 Subject: [PATCH 63/87] comic v0.1 --- frontend/pages/index.js | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 913dfd5e..46a117f4 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -65,6 +65,7 @@ const assets = { priceInformation: `${AWS_ASSETS_PATH}/Price+information.png`, socialMediaPosts: `${AWS_ASSETS_PATH}/Social+media+posts.png`, cryptoTraders: `${AWS_ASSETS_PATH}/crypto+traders.png`, + comicWhite: `${AWS_ASSETS_PATH}/moonstream-comic-white.png`, }; const Homepage = () => { const ui = useContext(UIContext); @@ -577,6 +578,17 @@ const Homepage = () => {
+ +
+ +
+ From 70b285a1eaf586b496b43e3a6ea8fff1dc5ffb9b Mon Sep 17 00:00:00 2001 From: kompotkot Date: Mon, 11 Oct 2021 12:12:19 +0000 Subject: [PATCH 64/87] Whales router --- backend/moonstream/api.py | 3 +++ backend/moonstream/routes/whales.py | 33 +++-------------------------- 2 files changed, 6 insertions(+), 30 deletions(-) diff --git a/backend/moonstream/api.py b/backend/moonstream/api.py index 74ee466c..218cc91b 100644 --- a/backend/moonstream/api.py +++ b/backend/moonstream/api.py @@ -16,6 +16,7 @@ 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 @@ -37,6 +38,7 @@ tags_metadata = [ {"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( @@ -126,3 +128,4 @@ 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/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), From 43e8816780e138e7c944bfa94a25aabb009f5ca9 Mon Sep 17 00:00:00 2001 From: kompotkot Date: Mon, 11 Oct 2021 12:18:32 +0000 Subject: [PATCH 65/87] Different queue of middlewares --- backend/moonstream/api.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/backend/moonstream/api.py b/backend/moonstream/api.py index 218cc91b..15bf4f4a 100644 --- a/backend/moonstream/api.py +++ b/backend/moonstream/api.py @@ -51,13 +51,6 @@ app = FastAPI( 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( { @@ -75,6 +68,13 @@ whitelist_paths.update( } ) app.add_middleware(BroodAuthMiddleware, whitelist=whitelist_paths) +app.add_middleware( + CORSMiddleware, + allow_origins=ORIGINS, + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) @app.get("/ping", response_model=data.PingResponse) From 6056b648ff273a0cc903538d6de539088c1729c8 Mon Sep 17 00:00:00 2001 From: Neeraj Kashyap Date: Mon, 11 Oct 2021 06:03:17 -0700 Subject: [PATCH 66/87] (Notebook) NFT ownership analysis --- datasets/nfts/nfts/dataset.py | 57 +- datasets/nfts/notebooks/.gitignore | 1 + datasets/nfts/notebooks/nft_ownership.ipynb | 1232 +++++++++++++++++++ 3 files changed, 1285 insertions(+), 5 deletions(-) create mode 100644 datasets/nfts/notebooks/.gitignore create mode 100644 datasets/nfts/notebooks/nft_ownership.ipynb diff --git a/datasets/nfts/nfts/dataset.py b/datasets/nfts/nfts/dataset.py index 16c70e4e..9062c9ca 100644 --- a/datasets/nfts/nfts/dataset.py +++ b/datasets/nfts/nfts/dataset.py @@ -2,10 +2,12 @@ Functions to access various data in the NFTs dataset. """ import sqlite3 -from typing import Any, List, Tuple +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 @@ -124,7 +126,7 @@ This dataset consists of the following dataframes:""" print(explanation) print("- - -") - for name, explanation in AVAILABLE_MATRICES: + for name, explanation in AVAILABLE_MATRICES.items(): print(f"\nMatrix: {name}") print("") print(explanation) @@ -137,6 +139,12 @@ class FromSQLite: 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: """ @@ -150,13 +158,17 @@ class FromSQLite: df = pd.read_sql_query(f"SELECT * FROM {name};", self.conn) return df - def load_ownership_transitions(self) -> Tuple[List[str], Any]: + 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 ( @@ -173,9 +185,44 @@ SELECT DISTINCT(all_addresses.address) AS address FROM all_addresses ORDER BY ad adjacency_matrix = scipy.sparse.dok_matrix((num_addresses, num_addresses)) adjacency_query = "SELECT from_address, to_address, num_transitions FROM ownership_transitions;" - for from_address, to_address, num_transitions in cur.execute(adjacency_query): + 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 - return addresses, adjacency_matrix + 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/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 +} From 22cd85ed20b6cda0d5778104a68f932582cd9d6d Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Mon, 11 Oct 2021 16:40:16 +0200 Subject: [PATCH 67/87] more charts --- datasets/nfts/notebooks/transfers_count.ipynb | 1004 ++++++++++++++++- 1 file changed, 976 insertions(+), 28 deletions(-) diff --git a/datasets/nfts/notebooks/transfers_count.ipynb b/datasets/nfts/notebooks/transfers_count.ipynb index 82905ee8..b9acefe5 100644 --- a/datasets/nfts/notebooks/transfers_count.ipynb +++ b/datasets/nfts/notebooks/transfers_count.ipynb @@ -644,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -692,6 +692,22 @@ " 0x000000F36EDb9d436Be73cDBf0DCa7dF3E6F3A50\n", " 0.000000e+00\n", " \n", + " \n", + " 0x00000633Df1228868270bAdB2B812E12e13fdB91\n", + " 2.829000e+17\n", + " \n", + " \n", + " 0x000E49C87d2874431567d38FF9548890aB39BAac\n", + " 1.399971e+19\n", + " \n", + " \n", + " 0x001B4b85192aa034bff1524f181e3a7060e0dC30\n", + " 1.800000e+17\n", + " \n", + " \n", + " 0x0025Eae58dF9F636F261CFdFa98cAcb57779DF74\n", + " 0.000000e+00\n", + " \n", " \n", "\n", "" @@ -702,50 +718,438 @@ "0x00000000000b7F8E8E8Ad148f9d53303Bfe20796 0.000000e+00\n", "0x000000000437b3CCE2530936156388Bff5578FC3 4.175880e+18\n", "0x000000000A42C2791eEc307FFf43Fa5c640e3Ef7 0.000000e+00\n", - "0x000000F36EDb9d436Be73cDBf0DCa7dF3E6F3A50 0.000000e+00" + "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": 28, + "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(4)" + "total_value_per_nft.head(8)" ] }, { "cell_type": "code", - "execution_count": 34, + "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": [ - "nft_address\n", - "0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270 2.296429e+23\n", - "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D 1.588150e+23\n", - "0x60E4d786628Fea6478F785A6d7e704777c86a7c6 7.530649e+22\n", - "Name: transaction_value, dtype: float64" + " 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": 34, + "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "most_popular_nfts = transactions_per_nft.sort_values(ascending=False).head(8)\n", - "most_valuable_nfts = total_value_per_nft[\"transaction_value\"].sort_values(ascending=False).head(3)\n", + "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": 35, + "execution_count": 154, "metadata": {}, - "outputs": [], + "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", @@ -758,34 +1162,35 @@ "#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\")" + "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": 36, + "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'])['transaction_value'].agg(transaction_value=\"sum\")" + "new_df = num_df.groupby([pd.Grouper(freq='d'), 'nft_address', 'info'])['transaction_value'].agg(transaction_value=\"sum\")\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 37, + "execution_count": 157, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -797,7 +1202,550 @@ "source": [ "plt.figure(figsize=(24, 12))\n", "# new_df.unstack()\n", - "ax = sns.lineplot(data=new_df, x='timestamp', y='transaction_value', hue='nft_address',)" + "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": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAH/CAYAAADQVqtKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABPTUlEQVR4nO3de3zO9f/H8ee1s/PMqTTKIadGJ2yK1JbDzDZMRctU34icvopszCkzjBxmhB859FUUY05JUchhUqlWSEnMaTnGmG3X9fn94ea6WZsZfbbL4XG/3dxurs/h/X593tfnNtfT+/25ZjEMwxAAAAAAmMjJ0QUAAAAAuPMQNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAkIfU1FTVrl1b4eHhufZFRUWpdu3aOnXq1E21/eOPP2rYsGF57vvkk0+0cOHCm2q3sF1d908//aS+ffs6uKIbl5CQoC+++KJI+kpMTFSDBg3066+/5tj++uuvKzExUZIUGRmpZs2aKTQ0NMef48eP2//eokULNWjQwP563LhxRVL/P5k9djfaXnJystq2bVvk/QK4eS6OLgAAblXu7u46cOCADh8+rPvuu0+SdOHCBX377bf/qt3ffvtNx48fz3Pft99+qwcffPBftV9Yrq67fv36io+Pd3BFNy45OVk1a9Yssv4Mw9Bbb72lJUuWyN3dPc9jXn75Zf3nP//JtT0pKUnS5ZpHjRplf+0oZo9dUb8Xju4XuBsRNADgGpydnRUYGKiVK1eqR48ekqR169YpICBA77//vv24xYsX64MPPpCTk5PKly+voUOHqlq1atq5c6fGjh0rm80m6fL/ZDdo0EDx8fE6d+6coqKiNGbMGHs7n3/+uTZs2KAtW7bIw8NDp06d0q5du5SWlqbatWsrMjJSw4YN08mTJ/XXX3/pvvvu0+TJk1WuXDn5+/urffv22rZtm44eParAwEC9/fbbSk9PV1RUlP788085OTnpoYce0jvvvCNJio2N1Q8//KD09HQZhqGYmBg9/vjjSk9PV0xMjL777js5Ozvr2WefVefOnXPU3a5dO40aNUqrVq3SuXPnNHLkSO3Zs0cWi0XNmjXTm2++KRcXF9WvX1/du3fXli1blJaWpoiICL388su5xvqHH35QTEyMLl68KFdXV7399ttq0qSJdu7cqbi4OPv2//73v3rqqaeUmJiozz77TDNnzpSkHK8jIyNVsmRJ7d27V8eOHVP16tU1ceJELV++XCkpKYqLi5Ozs7NatGhh7z85OVlxcXGqVKmSDh06JA8PD40dO1Y1atRQZmamJkyYoG+++UZWq1X16tVTdHS0SpYsKX9/fzVo0EB79+7Vm2++maNNSWrSpImysrI0bty4a85imWHJkiWaO3eunJycVLZsWY0bN0733nvvNe/Na41RiRIl8nwv9u/fn2Ps1q9frzNnzujQoUN6+umn1bFjR73zzju6cOGC0tLSVKdOHU2ePFnu7u4Fau+f45bX9UiXg37//v21f/9+Xbp0STExMWrYsKH++OOPa/bv4+OjgIAA7dmzR8HBwfn2C8BkBgAgl0OHDhmPPPKI8dNPPxmBgYH27V27djX27t1r1KpVyzh58qSxdetW49lnnzVOnjxpGIZhLF261AgMDDRsNpsRERFhrFq1yjAMw9i9e7cxYsQI+zHdu3fPs99BgwYZs2fPNgzDMOLj441WrVoZWVlZhmEYxrx584yZM2cahmEYNpvNeO2114w5c+YYhmEYzzzzjDF27FjDMAzj2LFjRv369Y2DBw8ay5YtM1599VXDMAwjOzvbGDJkiHHgwAHju+++M/r06WNYrVbDMAxj5syZxuuvv24YhmHExsYa/fv3N7Kzs41Lly4Z4eHhxvbt23PUvX37diMoKMgwDMN4++23jVGjRhk2m824dOmS8eqrr9rrrFWrlvHBBx8YhmEYP/30k+Hj42NkZGTkuObMzEzjySefNL788kv7cW3btjVOnTplNGnSxNi1a5dhGIbx66+/Go0bNzYOHjyYawyvfj1o0CDjhRdeMC5dumRkZmYa7dq1M5YsWWIYhmG89NJLxqeffppr3Ldv327UqVPH+OabbwzDMIwPP/zQaN++vWEYhjF16lRj7Nixhs1mMwzDMN59911j+PDh9nFPSEjI8728UtPx48cNPz8/Y8OGDYZhGEb37t2NpUuX2mtt2rSpERISYv/z8ccf56rtyljnZffu3Yavr69x5MgRwzAMY+7cucbQoUPzvTevNUbXei+sVmuOsRs0aJDRtWtXew1jx441li9fbhjG5fezbdu2xtq1awvcXkGuZ/v27UbdunXt98PcuXONiIiIfPs3jMv34LJly+ztX6tfAOZjRgMA8uHj4yMnJyelpKSoXLlySk9PV61atez7N2/erDZt2sjLy0uS1KFDB40ePVqpqakKDAzUO++8ow0bNuiJJ57Qm2++ecP9P/LII3JxufyjumvXrtq5c6fmzp2rAwcOaN++fXr44YftxwYEBEiSKlWqpHLlyuns2bN6/PHHNWnSJHXp0kVPPPGEunbtqvvvv1/333+/ypQpo0WLFunQoUNKTk5WiRIlJElbt25VVFSUnJ2d5ezsrP/973+SZH+u4J82bdqkjz76SBaLRW5uburUqZPmz5+v7t2756jroYceUmZmpi5cuJBjGdGvv/4qJycnPf300/YxX7lypTZu3KiqVavar/HBBx/UY489ph07dshiseQ7bs2aNZObm5skqVatWjp79ux1x7pOnTpq2LChJCksLEzvvPOOTp8+ra+++krnzp3T1q1bJUlZWVkqV66c/bwr51xLxYoVNXr0aA0ePFgrVqzItf9aS6cKatu2bWratKnuvfdee3uSFBcXd817U8p7jK71XuTl8ccft/994MCB2rJli/7v//5PBw4cUFpami5cuHBD7V3vepKTk1WlShX7/VCnTh0tXbo03/6vuN57BKBwEDQA4DpCQkK0YsUKeXl5KTQ0NMc+wzByHW8YhrKzs9WpUyc988wz2rJlizZv3qyEhIQ8P2jmp3jx4va/jx8/Xj/++KPCwsLk6+ur7OzsHP1f/eHdYrHIMAxVqVJFn3/+uZKTk7V9+3a98sorio6OloeHh0aPHq1XXnlFAQEBql69ur02FxeXHB/kjx49Kg8Pj2vWeGVp2NWvs7Ozc9V1pc1/jpmzs3Ou4PDrr7/mavfKudnZ2XJzc8vRTlZWVo7jrq73ylhcj7Ozc66+nJ2dZbPZNHjwYDVv3lySlJ6erkuXLtmPu/o9uhZ/f3+1bt1agwYNsgdHs/xz/DIyMnT48OF8700p7zG61ntRvXr1XG1dfd1vvvmmrFarAgMD9fTTT+vo0aM33N71rkeSXF1dc9WcX/951Qqg6PCtUwBwHaGhoVq7dq3WrFmT61tvmjZtqjVr1ti/gWrp0qXy9PTU/fffr06dOmn37t3q0KGDRo0apb///ltnz56Vs7Nzjg/iV8tv39dff62uXbuqXbt2KleunLZu3Sqr1Zpv7R9++KGioqLUtGlTDRw4UE2bNtW+ffu0ZcsWPfPMM3rxxRdVv359ffHFF/a2mjRpomXLlslmsykzM1N9+/bVN998c83amjZtqoULF8owDGVmZurjjz/WE088cd1xvaJ69eqyWCzasmWLJOnnn39W165d1aBBA/3xxx/68ccfJUn79u3TN998o8aNG8vLy0v79u3TpUuXlJ2drS+//LJAfeU3vnv27NGePXskXX7u5rHHHlPp0qXt15eZmSmbzaahQ4dq4sSJBb6+KyIjI5WWlqZt27bd8Ln58fX11bZt25SWliZJWrRokcaPH5/vvXkt13ovbDbbde/NXr16qU2bNrJYLPrhhx9ktVpvqr1rXU9+rtV/XvK7DgDmYkYDAK6jUqVKqlGjhkqVKiVPT88c+5588km9/PLL9g9PXl5emjlzppycnDRgwADFxsZq8uTJcnJyUu/eveXt7S2bzabJkyerV69emjZtWo72nnrqKY0aNSrPOnr16qW4uDhNnz5dzs7Oeuyxx3Tw4MF8a2/Xrp127NihNm3aqFixYqpcubIiIiJ04sQJDRgwQMHBwXJ2dlbDhg21bt062Ww29e7dW6NHj1ZoaKisVqvatGmjli1b6uDBg/a6IyIi7H1ER0crJiZGwcHBysrKUrNmzewPzxeEm5ubpk6dqtjYWMXFxcnV1VVTp05VuXLlNGXKFI0aNUoZGRmyWCwaM2aMqlWrpipVqqhRo0YKDAxUhQoV5Ovrq7179163r2eeeUbjxo1TVlaW2rdvn2Nf+fLlNXnyZB0+fFheXl6Ki4uTJL3xxhsaN26c2rdvL6vVqrp16yoyMrLA13eFu7u73n33XT333HM3fG5+ateurYEDB+q1116TJFWoUEGxsbGqVKnSNe/Na7nWe+Hm5pZj7P6pf//+6tWrl8qUKaNixYqpUaNGOnjwYIHbu/q9uNb1HDhw4Jp1X6v/vOR3DwAwl8UoyHwyAAB3sCtfIbtq1SpHlwIAdwyWTgEAAAAwHTMaAAAAAEzHjAYAAAAA0xE0AAAAAJiOb526y2RkZCglJUUVKlTI9Z3xAAAAgCRZrVb99ddf8vHxyfd3KeWHoHGXSUlJUXh4uKPLAAAAwG1g4cKFatiw4U2dS9C4y1SoUEHS5ZvmnnvucXA1AAAAuBUdO3ZM4eHh9s+ON4OgcZe5slzqnnvukbe3t4OrAQAAwK3s3yy152FwAAAAAKYjaAAAAAAwHUEDAAAAuEVlZlkdXcJN4xmNu1S/sUlyL+7p6DIAAACQjw/jbt9vC2VGAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6VwcXYAjrV27VrNmzVJ2drYMw1BoaKhee+01+/4VK1Zo9uzZslqtcnJyUuvWrdWjRw85OzsrOTlZPXr0UNWqVSVJNptN6enp6tatmzp37pyjn0OHDum9995TbGzsNWtJTU1VRESENmzYUDgXCwAAABShuzZoHD9+XOPGjVNiYqLKli2r9PR0denSRdWqVVNAQIASExM1d+5cTZs2TVWrVtX58+cVGRmpoUOH2gODj4+PPvjgA3ubu3fvVseOHRUcHKySJUvatx85ckSHDh0q8msEAAAAHOWuXTp1+vRpZWVlKSMjQ5JUokQJjR07VjVr1pQkJSQkKDo62j5jUbJkSY0ePVqrVq3S4cOH82zz8OHDKlasmNzc3HJsj4mJUUpKikaOHClJmjFjhtq0aaPg4GCNHTtWVqs1x/GfffaZQkJCdOrUKZ04cUJvvPGGOnTooLCwMG3dulWSNHXqVEVHR6tLly7y9/fXe++9Z97gAAAAAP/SXTujUadOHQUEBOjZZ59V3bp15evrq+DgYN1///06deqUDh8+rAYNGuQ4p0yZMqpZs6Z+/vlnlSlTRikpKQoNDdXFixd19uxZ+fr66v33388VNKKjo5WQkKDhw4dr48aN2rBhgxITE+Xi4qI+ffpo0aJFat68uSTp66+/1rRp0/T+++/Ly8tL/fv3V1hYmAICApSWlqYXX3xRy5cvlyTt3btXCxcu1Llz5/Tss88qPDxcpUuXLpLxAwAAAPJz185oSNLIkSO1YcMGde7cWUeOHNHzzz+vdevW2ff/c6ZBkrKysux/9/HxUVJSklatWiU/Pz95eHjkCif/tH37dgUFBcnDw0MuLi4KCwvTtm3bJF2eZenTp4/atWun8uXLS5K2bt2q+Ph4hYaGqlu3bsrOzrYvw/L19ZWbm5vKlSsnT09PnTt37l+PCQAAAGCGuzZofPXVV1qzZo0qVaqksLAwTZo0SdHR0VqyZIm8vLxUtWpVff/99znOOXXqlA4dOiQfH58c293c3BQTE6Ovv/5aq1atyrdfm82Wa1t2drYkyWKxaPr06ZozZ46OHz9uP37+/PlKSkpSUlKSFi9erFq1akmS3N3d7W1YLBYZhnHjAwEAAAAUgrs2aHh4eOjdd99VamqqJMkwDP3222+qW7euJOm///2vYmNj7bMH6enpio6OVps2bVS5cuVc7ZUqVUp9+vTRhAkT7M99XOHs7GwPE35+flq9erUyMjKUnZ2tpUuXys/PT5Lk6empJk2aqHPnzoqJibEf/+GHH0qSfvvtN4WEhOjixYuFMCIAAACAee7aZzT8/PzUu3dv9ejRw74cqlmzZurVq5ckKSgoSM7OzurXr58yMzNltVoVFBSkHj16XLPN5557TgsWLND777+vN954w769Ro0aOnfunAYOHKjx48dr9+7dCgsLU3Z2tpo1a6aXXnpJx44dsx/fvXt3hYSEaP369YqOjtawYcMUHBwsSYqLi8vxjVYAAADArchisN7mrpKamqqAgAD5tOgr9+Keji4HAAAA+fgwLtwh/V75zLh+/Xp5e3vfVBt37dIpAAAAAIWHoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYzsXRBcAxpkSGytvb29FlAAAAIB+ZWVa5uTo7uoybwowGAAAAcIu6XUOGRNAAAAAAUAgIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAA3PJs2VmOLgEAcINcHF0AHCNlZqSOl/JwdBkAUCCPvz3b0SUAAG4QMxoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAEznUhiNpqamqnXr1qpRo0aO7c8//7zCw8Pl7++v4OBg9e/f374vMjJSjRs3VocOHbRnzx7FxsbqzJkzslqteuSRRzRkyBAVL148R3uRkZHavn27ypQpI5vNJldXVw0fPlwPP/xwYVzWvzZlyhT5+PgoICAgz/2LFy9WiRIl1LZt2yKuDAAAADBXoQQNSapYsaKSkpKuuX/+/Plq0aKFfHx8cu3r37+/YmNj9eijj8pms2nkyJGaMmWKoqKich3bt29fdejQQZL0xRdfaNSoUVqyZIl5F2Kifv365bv/+++/V+PGjYuoGgAAAKDwFFrQuJ7XX39dUVFRWrp0qdzc3HLsO3HihDIyMiRJTk5O6t27tw4fPnzdNs+dO6fy5ctLkrKzszVixAjt27dPJ06cULVq1ZSQkKDs7Gy9+eabOnHihCSpV69eCggI0J9//qkRI0bozJkz8vDw0NChQ1WvXr0c7UdGRurMmTP6888/NXDgQJUvX15jxoxRRkaGypYtq5EjR6pKlSr69ddfFRkZKavVqoYNG2rTpk36/PPP7bM2LVu2zFVDsWLFtGHDBm3fvl0VKlTQ6tWrc/R16dIlzZ07VxkZGbp06ZJiYmLUqFEjdenSRWXKlNG+ffs0efJk1a1b91+/NwAAAMC/VWhBIy0tTaGhoTm2xcXFqXbt2pKk4OBg/fTTT5o2bVqOJVSSFBUVpZ49e6pixYry9fVVQECAnn766Tz7iY+P1/z583Xx4kUdOXJE7733nqTLswOurq5avHixbDabunbtqo0bN+rChQu67777NGvWLP3+++9asmSJAgICNGjQIA0bNkz16tXTb7/9pl69eumzzz7L1Z+np6dmzJihzMxMdezYUTNmzFDlypW1efNmDR06VPPmzVNkZKT69eun5s2ba968ebJarTna+Pzzz3PVMGjQIPn7+6tx48Zq1qyZVq9ebe/LZrPplVde0YwZM+Tl5aUlS5Zozpw5atSokSSpdu3aSkhIuKn3CQAAACgMDls6JUkjR45UaGioWrRokWN7hw4d1LJlS23btk1bt25VZGSkgoODNWTIkFxtXL106pdfftFLL72kpKQkNWrUSJ6enlq4cKH279+vAwcO6MKFC3r00Uc1ceJEHT9+XE8//bR69eql9PR0paSk5FiadeHCBZ0+fVply5bN0V+DBg0kSQcOHNChQ4fUs2dP+77z58/rzJkzOnz4sJo3by5JCgsL04IFC3K0kVcNebnSl5OTk6ZNm6YNGzbojz/+0I4dO+Tk5JTrOAAAAOBW4bClU5JUoUIFRUZGKioqSrVq1ZJ0+QP86tWr1atXL7Vo0UItWrRQ165d1a5duzyDxtXq1aunqlWr6ueff9avv/6q+Ph4RUREqEOHDjp9+rQMw9ADDzygTz/9VJs3b9aXX36p999/X5988onc3NxyBKNjx47J09MzVx8eHh6SJJvNJm9vb/s5VqtVJ06ckLOzswzDyLfOvGr49NNPr9lXenq6wsLCFBoaqkaNGql27dpauHBhruMAAACAW4XDv942JCREVapUsS9T8vLy0oIFC7Rt2zb7Mb/99luBnj04fPiwUlNTVadOHW3btk2BgYEKCwtT+fLl9c0338hqtep///ufpk6dqsDAQA0fPlynTp2yB5AroWHLli0KDw/Pt6/q1avr7Nmz2rlzpyRp6dKlGjBggEqVKqWqVatq48aNkqSVK1fmOjevGs6dOydnZ+dcy6yky+HLyclJPXr0kJ+fnzZt2pTncQAAAMCtokif0WjUqJGio6NzHTty5Ej7V7qWLl1as2bN0vjx4xUdHS1XV1dVq1ZNEydOzLOfK89oSFJGRoYGDRqkBx54QM8995wGDBigtWvXys3NTY888ohSU1PVrVs3vfnmmwoODpaLi4t69+6t0qVLa/z48RoxYoRmz54tV1dXTZo0SRaL5ZrX5+bmpilTpmj06NG6dOmSSpYsqXHjxkmSxo0bp8GDB2vy5MmqXbt2rhmHdu3a5VnDE088oYkTJ6pUqVI5jq9Tp47q1q2rwMBAeXh4qFGjRjpy5Mh13gEAAADAcSzG9db54IYlJCTo+eefV8WKFbVu3TqtXLlSU6dOdXRZki7/jpOAgABNeb6RKpRiyRWA28Pjb892dAkAcFe58plx/fr18vb2vqk2HPqMxp2qcuXKevXVV+Xi4qLSpUtr9OjRji4JAAAAKFIEjULQoUMH+zdhAQAAAHcjhz8MDgAAAODOQ9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMJ2LowuAY/i8Plbe3t6OLgMACsSWnSUnF1dHlwEAuAHMaAAAbnmEDAC4/RA0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQCFIDM7y9ElAADgUC6OLgCOMeCTkfLwLO7oMoA71rxXpji6BAAAHIoZDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApnNxdAH5SU5OVo8ePVS1alUZhqGsrCyFhISoZ8+ekiR/f38tWLBA3t7euc5dsWKFZs+eLavVKicnJ7Vu3Vo9evSQs7OzJCktLU1xcXHavXu3nJ2dde+99yo6OlpVqlRRYmKiduzYobFjx0qSjh8/roiICIWHhysiIkLJycmaOHGiLl68KKvVqubNm+utt96yty1JS5cu1YIFCyRJv//+u6pWrSpXV1c99thjGj58eK56/9knAAAAcDu7pYOGJPn4+OiDDz6QJKWnp6tNmzZq0aKFatasec1zEhMTNXfuXE2bNk1Vq1bV+fPnFRkZqaFDhyo2NlYXLlxQly5d9Oqrr2r8+PGyWCxasWKFXnnlFX366ac52vrrr7/08ssv24NGZmam3nrrLX300UeqUqWKMjMz1bdvXy1cuFARERH288LCwhQWFibpciCaNWtWnoEIAAAAuBPd8kHjahkZGXJ2dlapUqXyPS4hIUFjxoxR1apVJUklS5bU6NGj1axZM/Xq1Utbt25VxYoV9cILL9jPCQkJkZubmzIzM+3bTp48qVdeeUWvvPKKnn/+eUnSxYsXdf78eV28eFGS5ObmpiFDhig9Pb1A13Dx4kVFR0dr7969slgs+s9//qN27drlOCY2NlYnTpzQ+PHj9fPPP2vMmDHKyMhQ2bJlNXLkSFWpUkVdunRR/fr19e233+rUqVOKjo5W8+bNC1QDAAAAUNhu+aCRkpKi0NBQ2Ww2HTx4UIGBgapYseI1jz916pQOHz6sBg0a5NhepkwZ1axZUz///LN2796da78ktW7dOkc7L7/8srKysnIEgTJlyuj1119Xhw4dVK1aNfn6+qp169Zq2LBhga5n6tSpKlu2rFatWqVTp07pueeeU506dXLsP3bsmCZOnCir1aro6GjNmDFDlStX1ubNmzV06FDNmzdPkpSVlaXFixdrw4YNmjJlCkEDAAAAt4xb/mFwHx8fJSUlaeXKldq6dasOHz6sWbNmXfc8q9Waa1tWVpYkycnJSYZh5Hv+5s2b9eqrr6pq1ap69913c+zr2bOnNm3apNdff13p6enq1q2b/cP/9Wzfvl0dO3aUJHl5eSkgIEA7duyQJG3atEnTpk1T9+7d5eLiogMHDujQoUPq2bOnQkNDNWHCBB06dMjeVrNmzSRJDz74oM6cOVOg/gEAAICicMsHjauVKFFCzz77rL777rtrHuPl5aWqVavq+++/z7H91KlTOnTokHx8fOTj46OUlJRc5w4ZMkT79u2TJAUGBqp9+/aKjY1VUlKSNm7cKEnatWuXFi5cKC8vL7Vt21ZjxoxRQkKCPvnkkwJdwz8DjmEY9lB03333adSoUXrnnXdks9lks9nk7e2tpKQkJSUlKTExUR9++KH9XHd3d0mSxWIpUN8AAABAUbmtgobVatWOHTtUr169fI/773//q9jYWPv//qenpys6Olpt2rRR5cqV1bp1ax0+fDhHOFi6dKl27Nih+++/X9LlZy8kqUKFCho5cqSioqJ04sQJlSlTRgkJCdqzZ4/93H379qlu3boFugY/Pz8tWbJE0uXws379ejVu3FiSVKNGDT333HMqVqyYFi5cqOrVq+vs2bPauXOnvcYBAwYUqB8AAADAkW6bZzSkyw9S169fX926dbPvb9u2bY7/0f/+++8VFBQkZ2dn9evXT5mZmbJarQoKClKPHj0kSR4eHpo3b55iY2M1b948WSwWeXt76/3337cHjKu1atVKGzZs0KBBgzR79myNHTtWgwcP1vnz52WxWPTwww9r2LBhBbqeXr16acSIEQoODpbValWPHj300EMPae/evfZjRowYoc6dO6tFixaaMmWKRo8erUuXLqlkyZIaN27cTY0jAAAAUJQsxvUeVsAdJTU1VQEBAXq0x1Py8Czu6HKAO9a8V6Y4ugQAAG7alc+M69evv+lf0XBbLZ0CAAAAcHsgaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmc3F0AXCMCc8Nl7e3t6PLAO5YmdlZcnNxdXQZAAA4DDMaAFAICBkAgLsdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAUADWzCxHlwAAwG3FxdEFwDG+emugvNw9HF0GcNtos2Cuo0sAAOC2wowGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTuTi6gOtJTU1V69atVaNGjRzbZ8yYoSVLlmjlypVasWKFPDw8JEnJyclKSEjQBx98oKlTp2rRokUqX768DMNQVlaWOnTooG7dukmSpk6dWuDzr6hXr54aNmyoBQsWSJJ+//13Va1aVa6urnrsscc0fPhwSdLevXv19ttvS5KOHj2q4sWLq0yZMnJzc9Mnn3yS53VGRERow4YNJo8gAAAAUPRu+aAhSRUrVlRSUlKe+44cOaKJEydq8ODBee7v1KmT+vTpI0k6deqUunbtKk9PTz333HM3fP7VwsLCJEn+/v6aNWuWvL29c+yvXbu2vebIyEg1btxYHTp0KMDVAgAAALe/237pVKdOnbRmzRrt3Lnzusd6eXmpZ8+e+vDDD2/qfLPMmDFDbdq0UXBwsMaOHSur1Zpj/2effaaQkBCdOnVKJ06c0BtvvKEOHTooLCxMW7dulXR5NiY6OlpdunSRv7+/3nvvvSKrHwAAALie22JGIy0tTaGhofbXwcHBeu211yRJZcqU0YgRIzRkyJBrznpcrVatWtq/f7/99fXOX7Rokb744gv760mTJql69eo3fS0bN27Uhg0blJiYKBcXF/Xp00eLFi1S8+bNJUlff/21pk2bpvfff19eXl7q37+/wsLCFBAQoLS0NL344otavny5pMvLsxYuXKhz587p2WefVXh4uEqXLn3TtQEAAABmuS2CRn5LpyTp2Wef1aeffqqJEycqICAg37YsFov9eYyCnH+tpVM3a/v27QoKCrLXEBYWpuXLl6t58+Y6ffq0+vTpoz59+tifC9m6dav279+v+Ph4SVJ2drYOHTokSfL19ZWbm5vKlSsnT09PnTt3jqABAACAW8JtETQKYujQoWrbtq08PT3zPW7v3r25Hiy/kfP/LZvNlmtbdna2pMshaNq0aRowYICCgoJUqVIl2Ww2zZ8/317X8ePHVb58eX3xxRdyd3e3t2GxWGQYRqHWDgAAABTUbf+MxhWenp4aMWKEpk+ffs1j0tLSNGPGDIWHh9/U+Wbw8/PT6tWrlZGRoezsbC1dulR+fn72Gpo0aaLOnTsrJibGfvyVZ0p+++03hYSE6OLFi4VaIwAAAPBv3TEzGtLlJVCtWrVSWlqafduVZyyu/I//Cy+8oKCgoAKfb7ZnnnlGu3fvVlhYmLKzs9WsWTO99NJLOnbsmP2Y7t27KyQkROvXr1d0dLSGDRum4OBgSVJcXJxKlixZaPUBAAAAZrAYrLe5q6SmpiogIEBDH3lMXu4e1z8BgCSpzYK5ji4BAIAic+Uz4/r163P9GoeCumOWTgEAAAC4dRA0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOpeCHGSz2TRnzhxt2rRJ2dnZevLJJ9WjRw+5uBTodAAAAAB3mQIlhXfffVd79uxR165dZbPZtHjxYsXFxWnw4MGFXR8KydPvjpe3t7ejywBuG9bMLDm7uTq6DAAAbhsFChqbN2/W0qVL5ep6+R/Zp59+WiEhIQQNAHcNQgYAADemQM9oGIZhDxmS5ObmluM1AAAAAFytQEGjTp06io2N1cGDB3Xw4EGNGTNGtWrVKuzaAAAAANymChQ0hg8frr///ludOnXS888/r1OnTmno0KGFXRsAAACA21S+z2i89tprmj17tpYuXaqxY8cWVU0AAAAAbnP5Bo3ff/9dK1eu1AcffKDKlSvLMIwc+1u2bFmoxQEAAAC4PeUbNPr27aslS5bo5MmTWrBgQY59FouFoAEAAAAgT/kGjfbt26t9+/YaM2aMoqKiiqomAAAAALe5Av0ejX79+mnZsmU6e/ZsjuVTr7zySqEVBgAAAOD2VaCg8eabbyotLU21atWSxWIp7JoAAAAA3OYKFDT279+vNWvWyMWlQIcDKGTZWVa5uDo7ugwAAIBrKlByuOeeewq7DhSx6RM+VckSZR1dBm7S4NEdHV0CAABAvgoUNGrVqqWIiAg1a9ZMHh4e9u08owEAAAAgLwUKGunp6br//vt18ODBwq4HAAAAwB0g36DRr18/TZkyRSkpKUVVDwAAAIA7QL5Bo1u3bpKkoUOHFkkxAAAAAO4M+QYNHx8fSVLjxo2LpBgAAAAAdwYnRxcAAAAA4M5D0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiuSIPG+fPnNXLkSLVt21ahoaHq0qWLfv75Z1Pajo+P186dO/M9JjIyUomJifbXO3bsUNOmTfXtt99q/fr1mjJlSq62Fi9erFWrVkmSpkyZovXr1//rWnft2qWuXbsqJCREbdu21YgRI5SRkfGv2wUAAABuFUUWNGw2m7p166YyZcpo+fLlSkpKUq9evdStWzedPn36X7f/zTffyGq1Fvj4nTt3asCAAUpISNDjjz+ugIAA9evXL1db33//vTIzMyVJ/fr1U0BAwL+qc8+ePerdu7fefPNNrVixQsuXL5dhGBo6dOi/ahcAAAC4lbgUVUfJyclKS0tT37595eR0Od/4+flpzJgxstlsSk5O1vjx42Wz2VSjRg19++23mjNnjqpVq6YLFy4oMDBQ69atU/PmzfXMM88oJSVFJUqU0IQJE7Rz506lpKQoOjpaCQkJcnNz07Bhw3TmzBkVL15cQ4YMUYMGDey1fPfddxo4cKCmTZum+vXrS5ISExO1Y8cO+fn52duKiIjQhg0btH37dlWoUEGrV69W48aN1aFDBy1fvlzz58+XzWbTQw89pOHDh8vJyUmDBw/Wvn37JEkvvviinn/++RzjMGfOHL3wwgt6+OGHJUkuLi4aOHCgtmzZIkk6ceKEhgwZoiNHjsjFxUX9+/fXU089palTp2rXrl06evSowsPD1bRpU40YMUJnzpyRh4eHhg4dqnr16hX6+wgAAAAURJHNaPzyyy+qX7++PWRc0bx5c5UrV06SdODAAc2fP1/jx49Xu3bttGLFCknSunXr9PTTT8vd3V2nT59W48aNtXLlSgUFBSkmJkbt2rWTj4+PYmJiVLt2bQ0cOFBdunTRypUrFRUVpX79+tlnJX744Qd169ZNjRs3toeMq13dVpcuXeTv76++ffuqWbNm9mP27dunjz/+WIsWLVJSUpLKlSunOXPm6Pvvv9fZs2e1fPlyzZ07V999912u9nfv3p0j9EhSyZIl1apVK0nSqFGj5Ofnp5UrVyo+Pl6DBw/WiRMnJEmZmZlas2aNwsPDNWjQIA0cOFDLli3TqFGj1L9//5t9awAAAADTFVnQcHJykmEY+R5TrVo1lSpVSpLUoUMH+7MRy5YtU4cOHSRJ7u7uateunSSpffv2Sk5OztFGenq6Dh48qJYtW0qSHnnkEZUpU0b79++XJK1du1bTpk3Ttm3bbvp5i+TkZP355596/vnnFRoaqvXr12v//v168MEH9ccff+g///mPVqxYoQEDBuQ612Kx5Nv29u3b1bFjR0lSlSpV9PDDD+uHH36QJHtASU9PV0pKiqKiohQaGqq33npLFy5cMGUJGgAAAGCGIls65ePjow8//FCGYeT4sD1x4kQ98cQTslgs8vDwsG/39vZW5cqVtW7dOp08edK+1MjJycl+vs1mk7Ozc45+DMPIFWgMw7A/c9G/f3/5+fkpNjZWAwYMkI+PjypVqnRD12K1WhUYGKjo6GhJlz/4W61WlS5dWqtXr9aWLVu0ceNGtW/fXqtXr1bp0qVzjMNPP/2k5s2b27edP39eAwYMUHx8fL61Xxkfm80mNzc3JSUl2Y87duyYPD09b+g6AAAAgMJSZDMaDRs2VLly5ZSQkGD/4Lx582YlJiaqZs2aeZ4TFhammJgYhYSE2LddvHhRGzZskHT5uYqnnnpKkuTs7Cyr1aqSJUuqSpUqWrdunaTL3/B04sQJPfjgg5IkNzc3SVLTpk0VFBSkgQMHymaz5ej3Slv//PsVvr6++vzzz3Xy5EkZhqERI0Zo/vz5Wr9+vQYMGKCnn35a0dHRKl68uI4ePZrj3JdfflkfffSRfvzxR0lSVlaWxo4dq5IlS8rNzU1+fn5asmSJJOnQoUP67rvv9Mgjj+Roo1SpUnrggQfsQWPLli0KDw/Pd/wBAACAolRkMxoWi0XTp0/XmDFj1LZtW7m4uKhs2bKaNWuWypcvr99//z3XOS1bttTQoUMVGhqaY/vatWs1adIkVaxYUePGjZMkNWvWTMOHD9e4ceM0fvx4jRgxQlOnTpWrq6umTp1qDxhXGzhwoNq3b6+ZM2fmmNW4uq0nnnhCEydOtC/pkqQ6deqod+/e6tq1q2w2m+rWravu3bvLyclJn332mYKCguTu7q6WLVuqdu3aOfqsXbu2xo8fr9GjR+vixYvKzs5WkyZN7LMjQ4YM0bBhw+xfwxsTE6OKFSvmqv3KNc6ePVuurq6aNGnSdZdlAQAAAEXFYlzvwQkHMQxDmzZt0kcffaQZM2bYt9euXVt79+51YGW3t9TUVAUEBCgscIBKlijr6HJwkwaP7ujoEgAAwB3symfG9evXy9vb+6baKLIZjRsVGxurL7/8Uv/3f//n6FIAAAAA3KAi/c3gN2LIkCH64osvVK1atRzbmc0AAAAAbn23bNAAAAAAcPsiaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYzsXRBcAx3hgQKG9vb0eXgZuUnWWVi6uzo8sAAAC4JmY0gNsQIQMAANzqCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9DAHSc7K8vRJQAAANz1XBxdABxjTtxglSpRzNFlFIo3x8x0dAkAAAB3PWY0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYzsXRBRSW5ORk9ejRQ1WrVpVhGMrKylJISIh69uyZ47iwsDBVqFBBM2bMkCS9/vrrql69ugYNGmQ/ZvHixVq6dKk++ugjOTk5ad68eVq+fLkkycnJSa+99pqCgoJytDty5Eh99913ysrK0sGDB1WjRg1JUkREhMLCwnLVGxkZqcaNG6tDhw5mDgMAAADgEHds0JAkHx8fffDBB5Kk9PR0tWnTRi1atFDNmjUlSXv37pWrq6v27Nmjo0eP6t5779U777yjkJAQBQcHq169ejp+/LimTp2qBQsWyNnZWRMnTtQvv/yi//3vfypVqpSOHTuml156SWXLltUTTzxh73v48OGSpNTUVEVERCgpKanoBwAAAABwkLtm6VRGRoacnZ1VqlQp+7bExEQ9+eSTCggI0McffyxJqlSpkgYMGKDo6GjZbDbFxMSoW7duql69utLT0zV//nyNGDHC3s4999yjiRMnqkKFCgWq448//lCXLl0UHBysF154QT/++GOO/RcvXlTnzp21cOFCSdLy5cvVvn17hYaGavDgwbp06ZIkqWnTpho1apTatWunsLAwHTp06F+PEQAAAGCWOzpopKSkKDQ0VMHBwfL391fjxo1VsWJFSVJWVpZWrFihwMBABQYGasmSJcrOzpYkPffcc/L09NTAgQN15swZRURESJL279+vEiVKyNvbO0c/DRo00IMPPligmgYOHKguXbpo5cqVioqKUr9+/ZSZmWmvqXfv3mrVqpXCw8O1b98+ffzxx1q0aJGSkpJUrlw5zZkzR5L0119/qUmTJlq+fLkaNWpkDyYAAADAreCuWjrVo0cPzZo1S6+//ro2btyoChUqqGbNmjIMQ05OTvryyy/VokULSdKoUaPk7++v9evXy2KxSLr8PIZhGDddT3p6ug4ePKiWLVtKkh555BGVKVNG+/fvlyRNmTJFTk5OSkhIkHT5OZM///xTzz//vKTLQaRevXr29po1ayZJevDBB7Vz586brgsAAAAw2x0dNK5WokQJPfvss9q6daskaenSpTp69Kj8/f0lSefPn9eiRYvsQeO+++6TpByzFzVq1FBGRoaOHDmiypUr27evXr1aJ06cUNeuXfOtwTCMXEHFMAxZrVZJUlBQkC5cuKD4+HgNGjRIVqtVgYGBio6OlnQ5qFw5VpLc3d0lSRaL5V8FIAAAAMBsd/TSqatZrVbt2LFD9erV04kTJ7RlyxatWrVKGzZs0IYNG7R8+XJt374932cdPDw8FB4erhEjRuj8+fOSLj/sPXHiRPu3SuWnZMmSqlKlitatWydJ2rVrl06cOGFfdlW3bl0NHDhQK1eu1O7du+Xr66vPP/9cJ0+elGEYGjFihObPn2/CaAAAAACF646e0bjyjIZ0+SHr+vXrq1u3blq0aJGaN2+uSpUq2Y+tUqWK/P39tXjxYg0YMOCabfbv318JCQl6/vnn5eLiImdnZ7311ltq2rRpgWoaP368RowYoalTp8rV1VVTp06Vm5ubfb+np6feeustRUdH6+OPP1bv3r3VtWtX2Ww21a1bV927d7/J0QAAAACKjsVgzc1dJTU1VQEBAXqxla9KlSjm6HIKxZtjZjq6BAAAgNvalc+M69evz/VFSAV11yydAgAAAFB0CBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6VwcXQAc4z9vx8rb29vRZRSK7Kwsubi6OroMAACAuxozGrjjEDIAAAAcj6ABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaOC2Y8u2OroEAAAAXIeLowuAY+z+33adLF3e0WXclIffeNrRJQAAAOA6mNEAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6F0cXUFjOnz+vd999V998842cnZ1VunRpRUZG6qGHHpIkpaena8KECfr6669VrFgxlSxZUn369FGTJk3sbWzevFnx8fE6f/68nJyc9OSTT6p///4qVqyYkpOTlZCQoA8++CDP/jdv3qwJEyZIkg4ePKjy5curePHi8vb21rRp03Idf732AAAAgNvJHRk0bDabunXrJl9fXy1fvlwuLi7avn27unXrptWrV8vT01M9evRQ3bp1tXr1arm5uemXX35R9+7d9e6778rX11fbtm3T8OHDNXXqVD300EPKzMzU2LFj9cYbb+j999+/bg3NmjVTs2bNJEldunRR79695evrW9iXDgAAANwS7silU8nJyUpLS1Pfvn3l4nI5S/n5+WnMmDGy2WzasWOHjhw5oqioKLm5uUmS6tWrp549e2r69OmSpOnTp6t37972GRA3NzdFRUXpt99+07fffnvTtdlsNsXExCgoKEht27bVrFmzch0zf/58denSRRcvXtSff/6pV155Re3bt1fnzp31yy+/SJIiIyMVExOjzp07y9/fX0uXLr3pmgAAAACz3ZFB45dfflH9+vXl5JTz8po3b65y5crpp59+ko+PjywWS479jRo10k8//SRJ+umnn9SgQYMc+11dXfXoo4/aj7kZH330kY4ePaoVK1bok08+0bp16/TVV1/Z9y9dulTr1q3TzJkzVaxYMQ0aNEgDBw7UsmXLNGrUKPXv399+7LFjx/Thhx/qvffeU1xc3E3XBAAAAJjtjlw65eTkJMMwrrnfYrHIarXm2p6VlZXjmOzs7FzHZGZm/qvakpOT1b59ezk7O6tYsWIKDg7Wtm3b5O/vr19//VXDhg3TxIkTVbx4caWnpyslJUVRUVH28y9cuKDTp09Lkp588klZLBbVqlVLZ86c+Vd1AQAAAGa6I2c0fHx89Msvv+QKGxMnTtT27dv18MMPKyUlJUewkKRdu3apfv36kqQGDRpo165dOfZnZmbaZ0tuls1my/HaMAx76ClRooTi4+MVFxenCxcuyGazyc3NTUlJSfY/n3zyiTw9PSVJ7u7ukpRrZgYAAABwtDsyaDRs2FDlypVTQkKC/UP85s2blZiYqJo1a6phw4aqWbOmYmNj7WEjJSVF7733nt544w1JUp8+ffTee+/p559/lnR5tiMmJkbVq1fX448/ftO1+fn5afny5bJarbp48aJWrlxpf0j8vvvuU0BAgBo3bqz4+HiVKlVKDzzwgJKSkiRJW7ZsUXh4+E33DQAAABSVO3LplMVi0fTp0zVmzBi1bdtWLi4uKlu2rGbNmqXy5ctLkhISEjRp0iS1bdtWzs7OKlOmjMaPH2//0N+wYUONGzdOo0eP1tmzZ5Wdna2nnnpK06dPt88g7Ny5U48++qi93+DgYL3zzjv51vbCCy/owIEDCg0NVVZWlkJCQtSiRQslJyfbj3n77bfVtm1bBQcHa/z48RoxYoRmz54tV1dXTZo0iRkMAAAA3PIsRn4PM+COk5qaqoCAACW8MloVS5d3dDk35eE3nnZ0CQAAAHe0K58Z169fL29v75tq445cOgUAAADAsQgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwnYujC4Bj1H3JT97e3o4u46bYsq1ycnF2dBkAAADIBzMauO0QMgAAAG59BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BA7eN7OxsR5cAAACAAnJxdAFwjNmzZ6tUqVKOLuOGvPXWW44uAQAAAAXEjAYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANO5OLqAopaamqrWrVurRo0aslgsysrKUsWKFTVmzBjdc8896tKli44dO6bixYvLMAwZhqGePXuqTZs2kqRTp07p3Xff1Y4dO+Ti4iIPDw/17t1bAQEBOfp57733tHbtWknSnj17VKdOHUlS69at1bNnz1x1TZ06VZLUp0+fwrx8AAAAoEjcdUFDkipWrKikpCT763fffVejRo3StGnTJEkxMTHy9fWVJP3222/q2LGjfH19VapUKXXt2lWtWrXS2rVr5ezsrP379+s///mP7rvvPnuYkKSePXvaA0Xt2rVz9AcAAADc6Vg6Jalhw4Y6cOBAnvtq1qyp4sWL6/Dhw/rss8/k7u6u3r17y9nZWZJUvXp1jRgxQlartUB9nThxQq+//rqCg4PVvn17bdq0Kcd+q9Wqvn37Ki4uTpK0adMmdezYUe3atVPv3r11+vRpSZK/v78mT56sjh07KigoSCkpKTd59QAAAID57vqgkZWVpU8//VSPPfZYnvs3b94sq9WqGjVq6IcfflCjRo1yHdO8eXM99NBDBepv1KhR8vPz08qVKxUfH6/BgwfrxIkTkiTDMBQdHa177rlHb7/9tn2Z1pw5c7R8+XI1bdpUEyZMsLfl6empJUuWqFOnTpo5c+ZNXD0AAABQOO7KpVNpaWkKDQ2VJGVmZqpBgwZ666237Pujo6NVvHhxWa1WlSlTRpMnT1aJEiVytTNhwgRt3rxZGRkZatasmaKjo6/b9/bt2xUTEyNJqlKlih5++GH98MMPkqRFixbp3LlzWr9+vSTphx9+0NGjRxURESFJstlsKlOmjL2tZs2aSZIefPBBrVu37maGAgAAACgUd2XQ+OczGv909TMaV/Px8dGiRYvsrwcMGKABAwYoMTFRO3bsKFDfhmHken1l2dWjjz6qevXqKSYmRvHx8bJarXrsscc0Y8YMSdKlS5eUnp5uP9fd3V2SZLFYCtQ3AAAAUFTu+qVTN6JNmza6ePGi3nvvPWVlZUmSzp8/r+TkZDk5FWwo/fz8tGTJEknSoUOH9N133+mRRx6RJNWpU0fdunXTvn379OWXX+rhhx/Wrl279Mcff0iSpk+fbn92AwAAALiV3ZUzGjfLzc1NCxYs0OTJk9WuXTu5uLjIZrPJ399fr732WoHaGDJkiIYNG6bExERJl2dPKlasmKOPESNGKDIyUqtWrVJsbKz++9//ymazqVKlSho/fnyhXBsAAABgJovxz7U8uKOlpqYqICBAnTt3VqlSpRxdzg25+jkaAAAAFJ4rnxnXr18vb2/vm2qDpVMAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAEzn4ugC4BivvfaavL29HV3GDcnOzpaLC7csAADA7YAZDdw2CBkAAAC3D4IGAAAAANMRNAAAAACYjrUodxmr1SpJOnbsmIMrAQAAwK3qymfFK58dbwZB4y7z119/SZLCw8MdXAkAAABudX/99Zfuv//+mzrXYhiGYXI9uIVlZGQoJSVFFSpUkLOzs6PLAQAAwC3IarXqr7/+ko+Pjzw8PG6qDYIGAAAAANPxMDgAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9C4i6xcuVJt2rRRixYttHDhQkeXc0uIiIhQUFCQQkNDFRoaqh9++OGa47R161YFBwerZcuWmjRpkn377t27FRYWplatWmnIkCHKzs6WJB05ckTh4eFq3bq1evbsqfT09CK/vsJy/vx5tW3bVqmpqZLMG5u///5b3bt3V2BgoMLDw+2/yT4zM1MDBw5UYGCg2rdvr99//72Ir9hc/xy/qKgotWzZ0n4ffv7555IKf1xvVwkJCQoKClJQUJDi4uIkcQ/eqLzGkPuw4KZMmaI2bdooKChIc+fOlcQ9eKPyGkPuwRs3btw4RUZGSir8e80wDI0bN06tW7dWmzZt9O23316/QAN3hWPHjhnPPPOMcfr0aSM9Pd0IDg429u3b5+iyHMpmsxlPPvmkkZWVZd92rXG6ePGi0bx5c+PgwYNGVlaW8eqrrxpfffWVYRiGERQUZHz//feGYRhGVFSUsXDhQsMwDKN79+7GqlWrDMMwjISEBCMuLq5oL7CQ7Nq1y2jbtq3x0EMPGYcOHTJ1bEaOHGnMnDnTMAzDWLZsmdGvXz/DMAxj9uzZxtChQw3DMIwdO3YYHTt2LKrLNd0/x88wDKNt27bG8ePHcxxXFON6O9qyZYvxwgsvGJcuXTIyMzONiIgIY+XKldyDNyCvMVy3bh33YQElJycbnTp1MrKysoyLFy8azzzzjLF7927uwRuQ1xj+/vvv3IM3aOvWrYavr68xaNAgwzAK/1779NNPjW7duhlWq9XYv3+/8eyzz+b4DJUXZjTuElu3bpWfn588PT1VvHhxtWrVSmvXrnV0WQ61f/9+WSwWdevWTSEhIfrf//53zXH68ccfdf/996tKlSpycXFRcHCw1q5dq8OHDysjI0OPPPKIJKlDhw5au3atsrKy9M0336hVq1Y5tt8JPv74Yw0fPlwVK1aUJFPH5quvvlJwcLAkqW3bttq0aZOysrL01VdfKSQkRJLUqFEjnT59WkeOHCniKzfHP8fvwoULOnLkiIYOHarg4GDFx8fLZrMVybjejipUqKDIyEi5ubnJ1dVVNWrU0IEDB7gHb0BeY3jkyBHuwwJq3LixFixYIBcXF508eVJWq1V///039+ANyGsM3d3duQdvwJkzZzRp0iT16NFDkorkXtu4caPatGkjJycnVatWTZUrV9b333+fb50EjbtEWlqaKlSoYH9dsWJFHT9+3IEVOd7ff/+tJk2aaNq0aZo3b54WLVqkI0eO5DlO1xq/f26vUKGCjh8/rtOnT6tkyZJycXHJsf1OMHr0aDVs2ND+2syxufocFxcXlSxZUqdOncqzrWPHjhXqdRaWf47fyZMn5efnp9jYWH388cfauXOnlixZUiTjejt68MEH7f+QHjhwQGvWrJHFYuEevAF5jWGzZs24D2+Aq6ur4uPjFRQUpCZNmvBz8Cb8cwytViv34A0YNmyY+vfvr9KlS0vK/W9xYdxraWlp9v8ku3p7fggadwnDMHJts1gsDqjk1vHoo48qLi5OxYsXl5eXlzp27Kj4+Phcx1kslmuO341uvxMV9tg4OeX9Y+pa2283VapU0bRp01SuXDkVK1ZMXbp00caNGx02rreLffv26dVXX9WgQYNUtWrVXPu5B6/v6jGsXr069+EN6tu3r7Zt26ajR4/qwIEDufZzD17f1WO4bds27sEC+uSTT3TvvfeqSZMm9m1Fca/l1db1xu/2G13clEqVKunEiRP21/9MpXejnTt3atu2bfbXhmHovvvuy3OcrjV+/9z+119/qWLFivLy8tL58+dltVpzbL8TmTk2FStWtJ+TnZ2t8+fPy9PTUxUrVszx0N6dNJ579+7VZ599Zn9tGIZcXFyKZFxvV99++61efvllvfXWW2rfvj334E345xhyHxbc77//rt27d0uSihUrppYtWyo5OZl78AbkNYZr1qzhHiygNWvWaMuWLQoNDVV8fLw2bNigTz75pNDvtUqVKt3wPUjQuEs88cQT2rZtm06dOqWLFy9q3bp1euqppxxdlkOdO3dOcXFxunTpks6fP69ly5Zp/PjxeY7Tww8/rD/++EN//vmnrFarVq1apaeeekr33Xef3N3d7d+8sHz5cj311FNydXVVw4YNtWbNmhzb70Rmjk3z5s21fPlySZd/kDZs2FCurq5q3ry5kpKSJF0OiO7u7qpcuXLRX2whMAxDsbGxOnv2rLKysrR48WK1aNGiSMb1dnT06FH16tVLEyZMUFBQkCTuwRuV1xhyHxZcamqqoqOjlZmZqczMTK1fv16dOnXiHrwBeY1ho0aNuAcLaO7cuVq1apWSkpLUt29f+fv7a8yYMYV+rz311FNauXKlrFar/vzzTx04cED169fPt1aLkdc8CO5IK1eu1MyZM5WVlaWOHTuqW7duji7J4SZPnqzPPvtMNptNL774orp27XrNcdq2bZvGjBmjS5cuqXnz5oqKipLFYtGePXsUHR2t9PR01atXT2PGjJGbm5sOHz6syMhInTx5Uvfee68mTpyoMmXKOPiKzePv768FCxbI29vbtLE5c+aMIiMjdejQIZUqVUoTJkyQt7e3Ll26pGHDhiklJUVubm6KiYnRQw895Ogh+FeuHr+FCxdq4cKFys7OVsuWLTVgwABJ5t1z1xrX21FMTIyWLl2aY7lUp06d9MADD3APFtC1xtBms3EfFlB8fLzWrl0rZ2dntWzZUn369OHn4A3Kawz5WXjjEhMTtWPHDo0dO7bQ7zXDMBQXF6dNmzZJuvx1xE2bNs23PoIGAAAAANOxdAoAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAMANevXVV3Xq1ClHlwEAtzSCBgAAN2jLli2OLgEAbnkEDQDAHWXJkiUKCgpScHCwIiIidPToUS1evFht27ZVSEiIXn31Vf3xxx+SpMjISM2ZM8d+7tWv/f39NXXqVL344ot65plnFBcXJ+nyL6mSpK5du+ro0aNFfHUAcPtwcXQBAACYZc+ePZowYYKWLVume++9V/PmzdPLL78sm82mxYsXy8vLS4mJierVq5dWr1593fYuXLigDz/8UMePH1eLFi3UuXNnjRkzRomJiZo/f768vLyK4KoA4PbEjAYA4I6xbds2NW3aVPfee68k6eWXX1ZAQIDatGljDwUdOnTQ8ePHlZqaet32AgICJEmVKlVSuXLldPbs2cIrHgDuMAQNAMAdw9nZWRaLxf46IyMjz0BhGIays7NlsVhkGIZ9e1ZWVo7j3N3d7X//57EAgPwRNAAAdwxfX19t27ZNaWlpkqRFixbpq6++0po1a+zfErV06VJ5enrq/vvvV9myZZWSkiJJOnXqlHbu3FmgfpydnZWdnV04FwEAdwie0QAA3DFq166tgQMH6rXXXpMkVahQQZ9//rm++OILde3aVTabTV5eXpo5c6acnJzUpUsXDRgwQK1atZK3t7caN25coH5atGihF198UdOnT1etWrUK85IA4LZlMZgHBgAAAGAylk4BAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKb7f0VFWL+/ADwZAAAAAElFTkSuQmCC\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\")" ] }, { From 600bba36bb03f18979194815795630dd27f5de08 Mon Sep 17 00:00:00 2001 From: kompotkot Date: Tue, 12 Oct 2021 18:57:02 +0000 Subject: [PATCH 68/87] Timeout for node serivce stop --- crawlers/deploy/ethereum-node.service | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crawlers/deploy/ethereum-node.service b/crawlers/deploy/ethereum-node.service index 4c22b89d..5486b081 100644 --- a/crawlers/deploy/ethereum-node.service +++ b/crawlers/deploy/ethereum-node.service @@ -7,9 +7,10 @@ User=ubuntu Group=www-data ExecStart=/usr/bin/geth --syncmode full \ --port 41381 --datadir /mnt/disks/nodes/ethereum \ - --txpool.globalslots 450000 --txpool.globalqueue 50000 \ + --txpool.globalslots 153600 --txpool.globalqueue 30720 \ --http --http.port 18375 --http.api eth,web3,txpool ExecStop=/bin/kill -s SIGINT -$MAINPID +TimeoutStopSec=300 SyslogIdentifier=ethereum-node [Install] From 1de9b6b6f960040f9651b16c38ba4bb3ad2d6ce3 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 17:22:01 +0200 Subject: [PATCH 69/87] flow buttons support 3 and 4 button option --- frontend/src/components/ConnectedButtons.js | 126 +++++++++++++++++--- 1 file changed, 108 insertions(+), 18 deletions(-) diff --git a/frontend/src/components/ConnectedButtons.js b/frontend/src/components/ConnectedButtons.js index 990f1cc1..f04897d5 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,24 +28,65 @@ 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} @@ -50,8 +102,9 @@ const ArrowCTA = (props) => { variant="solid" colorScheme="green" className="MoonStockSpeciality element1" - w={["180px", "180px", "250px", null, "250px"]} + w={buttonWidth} onClick={props.button1.onClick} + fontSize={fontSize} > {props.button1.label} @@ -67,7 +120,8 @@ const ArrowCTA = (props) => { variant="solid" colorScheme="orange" className="MoonStockSpeciality element2" - w={["180px", "180px", "250px", null, "250px"]} + w={buttonWidth} + fontSize={fontSize} onClick={props.button2.onClick} > {props.button2.label} @@ -83,46 +137,82 @@ const ArrowCTA = (props) => { boxShadow="md" variant="solid" colorScheme="blue" - w={["180px", "180px", "250px", null, "250px"]} + w={buttonWidth} + fontSize={fontSize} onClick={props.button3.onClick} > {props.button3.label} + {props.button4 && ( + + )} + {props.button4 && ( + + )} ); }; From 8e608773c9f145940408da390cb8ea99e7455d86 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 17:22:21 +0200 Subject: [PATCH 70/87] product and team link for sidebar on mobileview --- frontend/src/components/Sidebar.js | 8 ++++++++ 1 file changed, 8 insertions(+) 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 + )} From 22b3c3e027cb7837487b352b8de730c2b371d974 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 17:22:58 +0200 Subject: [PATCH 71/87] feature component more customization options --- frontend/src/components/SplitWithImage.js | 93 ++++++++++++++--------- 1 file changed, 57 insertions(+), 36 deletions(-) diff --git a/frontend/src/components/SplitWithImage.js b/frontend/src/components/SplitWithImage.js index 5220d052..9fec3a1b 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,36 @@ 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 +213,14 @@ const SplitWithImage = ({ {(!mirror || ui.isMobileView) && ( - + {"feature )} From 65df03af420ed00ed2688d5f657ba32112ca8574 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 17:23:09 +0200 Subject: [PATCH 72/87] hide 1000 user banner --- frontend/src/layouts/RootLayout.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 ( Date: Wed, 13 Oct 2021 17:23:28 +0200 Subject: [PATCH 73/87] simplify landing page for now --- frontend/pages/product/index.js | 239 ++++++++++++++++++++++---------- 1 file changed, 167 insertions(+), 72 deletions(-) diff --git a/frontend/pages/product/index.js b/frontend/pages/product/index.js index fa03ba4a..dbf6f77b 100644 --- a/frontend/pages/product/index.js +++ b/frontend/pages/product/index.js @@ -1,26 +1,31 @@ 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, + MIXPANEL_EVENTS, + MIXPANEL_PROPS, +} from "../../src/core/constants"; +import SplitWithImage from "../../src/components/SplitWithImage"; +import mixpanel from "mixpanel-browser"; 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 +136,162 @@ 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; From 89cfb15ffa1ba5ed8d086fe26115898ac3503a20 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 17:23:49 +0200 Subject: [PATCH 74/87] product page improvements --- frontend/pages/index.js | 271 ++++++++++++++++++++++++++++++---------- 1 file changed, 203 insertions(+), 68 deletions(-) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 46a117f4..eebddf96 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -1,6 +1,6 @@ import React, { useState, - useContext, + // useContext, Suspense, useEffect, useLayoutEffect, @@ -10,16 +10,16 @@ import { Flex, Heading, Box, - Image as ChakraImage, 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"; @@ -29,27 +29,55 @@ 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"), +// import UIContext from "../src/core/providers/UIProvider/context"; +// const SplitWithImage = dynamic( +// () => import("../src/components/SplitWithImage"), +// { +// ssr: false, +// } +// ); +// const GiSuspicious = dynamic(() => +// import("react-icons/gi").then((mod) => mod.GiSuspicious) +// ); + +// const GiHook = dynamic(() => +// import("react-icons/gi").then((mod) => mod.GiHook) +// ); + +// const IoTelescopeSharp = dynamic(() => +// import("react-icons/io5").then((mod) => mod.IoTelescopeSharp) +// ); + +// const AiFillApi = dynamic(() => +// import("react-icons/ai").then((mod) => mod.AiFillApi) +// ); + +// const BiTransfer = dynamic(() => +// import("react-icons/bi").then((mod) => mod.BiTransfer) +// ); + +// 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 ConnectedButtons = dynamic( + () => import("../src/components/ConnectedButtons"), { ssr: false, } ); -const GiSuspicious = dynamic(() => - import("react-icons/gi").then((mod) => mod.GiSuspicious) -); - -const GiHook = dynamic(() => - import("react-icons/gi").then((mod) => mod.GiHook) -); - -const IoTelescopeSharp = dynamic(() => - import("react-icons/io5").then((mod) => mod.IoTelescopeSharp) -); - const HEADING_PROPS = { fontWeight: "700", fontSize: ["4xl", "5xl", "4xl", "5xl", "6xl", "7xl"], @@ -66,9 +94,10 @@ const assets = { socialMediaPosts: `${AWS_ASSETS_PATH}/Social+media+posts.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 ui = useContext(UIContext); const [background, setBackground] = useState("background720"); const [backgroundLoaded720, setBackgroundLoaded720] = useState(false); const [backgroundLoaded1920, setBackgroundLoaded1920] = useState(false); @@ -334,7 +363,7 @@ const Homepage = () => { Social media posts - {/*
+
Moonstream is meant for you if @@ -343,49 +372,59 @@ 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", + 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", + 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", + label: "Social media posts", 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`, }); }, }} /> - */} + {/* { onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: Crypto trader`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer txpool button`, }); - toggleModal("hubspot-trader"); + toggleModal("hubspot-developer"); }, }} elementName={"element1"} colorScheme="green" - badge={`For crypto traders`} - title={``} - body={``} + badge={`Transaction pool data`} + title={`Get real-time access to transaction pool`} + body={`In blockchains, transaction pool is place where future blocks are being forged. + Having insight in to this dynamic, always changing data means to be in the present moment + `} bullets={[ { text: `Subscribe to the defi contracts you care about`, @@ -412,28 +453,28 @@ const Homepage = () => { bgColor: "green.900", }, { - text: `Make sense of how others are calling these contracts using Moonstream dashboards. + text: `Get data directly from the transaction pool through our global network of Ethereum nodes `, icon: RiDashboardFill, color: "green.50", bgColor: "green.900", }, { - text: `Get data directly from the transaction pool through our global network of Ethereum nodes`, + text: `Setup notifications to be first to know when and how your contract is being interacted`, icon: GiMeshBall, color: "green.50", bgColor: "green.900", }, ]} - imgURL={assets["cryptoTraders"]} + imgURL={assets["pendingTransactions"]} /> - */} - {/* + { onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: Algo fund`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer exchanges button`, }); - toggleModal("hubspot-fund"); + toggleModal("hubspot-developer"); }, }} elementName={"element2"} mirror={true} colorScheme="orange" - badge={`For algorithmic funds`} + badge={`Centralized exchange prices`} bullets={[ { text: `Get API access to your stream`, @@ -471,9 +512,9 @@ const Homepage = () => { bgColor: "orange.900", }, ]} - imgURL={assets["algorithmicFunds"]} + imgURL={assets["priceInformation"]} /> - */} + { onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer smartDeveloper button`, }); toggleModal("hubspot-developer"); }, @@ -506,30 +547,87 @@ const Homepage = () => { }} elementName={"element3"} colorScheme="blue" - badge={`For smart contract developers`} + badge={`Know your people`} bullets={[ { - text: `Monitor blockchain data in real time`, + text: `Subscribe to social media tags and people`, icon: IoTelescopeSharp, color: "blue.50", bgColor: "blue.900", }, { - text: `Set up alerts on suspicious activity`, + text: `Automatically process content with our semantics AI analysis`, icon: GiSuspicious, color: "blue.50", bgColor: "blue.900", }, { - text: `Register webhooks to connect your off-chain infrastructure`, + text: `Register webhooks to connect your infrastructure`, icon: GiHook, color: "blue.50", bgColor: "blue.900", }, ]} - imgURL={assets["cryptoTraders"]} + imgURL={assets["socialMediaPosts"]} /> + + { + mixpanel.get_distinct_id() && + mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer analytics button`, + }); + 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="red" + badge={`Analyse blockchain activity`} + bullets={[ + { + text: `Monitor blockchain data in real time`, + icon: IoTelescopeSharp, + color: "red.50", + bgColor: "red.900", + }, + { + text: `Set up alerts on suspicious activity`, + icon: GiSuspicious, + color: "red.50", + bgColor: "red.900", + }, + { + text: `Register webhooks to connect your off-chain infrastructure`, + icon: GiHook, + color: "red.50", + bgColor: "red.900", + }, + ]} + imgURL={assets["smartDevelopers"]} + /> + */} { [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Join our discord`, } ); - toggleModal("hubspot"); }} isExternal href={"https://discord.gg/K56VNUQGvA"} @@ -566,7 +663,7 @@ const Homepage = () => { mixpanel.track( `${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer`, + [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer want to find more button`, } ); toggleModal("hubspot-developer"); @@ -578,17 +675,6 @@ const Homepage = () => {
- -
- -
- @@ -625,3 +711,52 @@ export async function getStaticProps() { } export default Homepage; + +// +// +// +// 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 +// +// . +// +// From 8177e23bf56ec3d69ab81bfa66ef1c16dcca1608 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 17:29:38 +0200 Subject: [PATCH 75/87] fix compile warnings --- frontend/pages/product/index.js | 11 +++++------ frontend/src/core/hooks/hookCommon.js | 1 + 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/frontend/pages/product/index.js b/frontend/pages/product/index.js index dbf6f77b..10131e1c 100644 --- a/frontend/pages/product/index.js +++ b/frontend/pages/product/index.js @@ -8,14 +8,13 @@ import { useBreakpointValue, Center, } from "@chakra-ui/react"; -import { - AWS_ASSETS_PATH, - MIXPANEL_EVENTS, - MIXPANEL_PROPS, -} from "../../src/core/constants"; +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`, 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; From 1443a15c66df199657ce6e81a353220574d0459a Mon Sep 17 00:00:00 2001 From: kompotkot Date: Wed, 13 Oct 2021 16:02:18 +0000 Subject: [PATCH 76/87] Reduced glob tx pool size --- crawlers/deploy/ethereum-node.service | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crawlers/deploy/ethereum-node.service b/crawlers/deploy/ethereum-node.service index 5486b081..00400566 100644 --- a/crawlers/deploy/ethereum-node.service +++ b/crawlers/deploy/ethereum-node.service @@ -7,11 +7,11 @@ User=ubuntu Group=www-data ExecStart=/usr/bin/geth --syncmode full \ --port 41381 --datadir /mnt/disks/nodes/ethereum \ - --txpool.globalslots 153600 --txpool.globalqueue 30720 \ + --txpool.globalslots 153600 --txpool.globalqueue 1024 \ --http --http.port 18375 --http.api eth,web3,txpool ExecStop=/bin/kill -s SIGINT -$MAINPID TimeoutStopSec=300 SyslogIdentifier=ethereum-node [Install] -WantedBy=multi-user.target \ No newline at end of file +WantedBy=multi-user.target From 9e9462c519e0f4279335d6199830fbfbe4182a33 Mon Sep 17 00:00:00 2001 From: kompotkot Date: Wed, 13 Oct 2021 16:03:05 +0000 Subject: [PATCH 77/87] x3 glob queue txpool value for geth --- crawlers/deploy/ethereum-node.service | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crawlers/deploy/ethereum-node.service b/crawlers/deploy/ethereum-node.service index 00400566..6157071e 100644 --- a/crawlers/deploy/ethereum-node.service +++ b/crawlers/deploy/ethereum-node.service @@ -7,7 +7,7 @@ User=ubuntu Group=www-data ExecStart=/usr/bin/geth --syncmode full \ --port 41381 --datadir /mnt/disks/nodes/ethereum \ - --txpool.globalslots 153600 --txpool.globalqueue 1024 \ + --txpool.globalslots 153600 --txpool.globalqueue 3072 \ --http --http.port 18375 --http.api eth,web3,txpool ExecStop=/bin/kill -s SIGINT -$MAINPID TimeoutStopSec=300 From ea0895546d62d766b9ea5a0da9058534ee8a8a85 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 18:30:39 +0200 Subject: [PATCH 78/87] remove comments --- frontend/pages/index.js | 326 +--------------------- frontend/pages/product/index.js | 47 ---- frontend/src/components/SplitWithImage.js | 2 - 3 files changed, 2 insertions(+), 373 deletions(-) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index eebddf96..4851a0b6 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -1,10 +1,4 @@ -import React, { - useState, - // useContext, - Suspense, - useEffect, - useLayoutEffect, -} from "react"; +import React, { useState, Suspense, useEffect, useLayoutEffect } from "react"; import { Fade, Flex, @@ -31,46 +25,6 @@ import { } from "../src/core/providers/AnalyticsProvider/constants"; import { AWS_ASSETS_PATH } from "../src/core/constants"; import mixpanel from "mixpanel-browser"; -// import UIContext from "../src/core/providers/UIProvider/context"; -// const SplitWithImage = dynamic( -// () => import("../src/components/SplitWithImage"), -// { -// ssr: false, -// } -// ); -// const GiSuspicious = dynamic(() => -// import("react-icons/gi").then((mod) => mod.GiSuspicious) -// ); - -// const GiHook = dynamic(() => -// import("react-icons/gi").then((mod) => mod.GiHook) -// ); - -// const IoTelescopeSharp = dynamic(() => -// import("react-icons/io5").then((mod) => mod.IoTelescopeSharp) -// ); - -// const AiFillApi = dynamic(() => -// import("react-icons/ai").then((mod) => mod.AiFillApi) -// ); - -// const BiTransfer = dynamic(() => -// import("react-icons/bi").then((mod) => mod.BiTransfer) -// ); - -// 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 ConnectedButtons = dynamic( () => import("../src/components/ConnectedButtons"), @@ -97,7 +51,6 @@ const assets = { 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); @@ -264,30 +217,14 @@ const Homepage = () => { understand exactly how people are using your smart contracts. - {/* - Access this data through the Moonstream dashboard or - API - */} - + { > We believe that the blockchain is for everyone. This @@ -419,215 +355,6 @@ const Homepage = () => { /> - {/* - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer txpool button`, - }); - toggleModal("hubspot-developer"); - }, - }} - elementName={"element1"} - colorScheme="green" - badge={`Transaction pool data`} - title={`Get real-time access to transaction pool`} - body={`In blockchains, transaction pool is place where future blocks are being forged. - Having insight in to this dynamic, always changing data means to be in the present moment - `} - bullets={[ - { - text: `Subscribe to the defi contracts you care about`, - icon: FaFileContract, - color: "green.50", - bgColor: "green.900", - }, - { - text: `Get data directly from the transaction pool through our global network of Ethereum nodes - `, - icon: RiDashboardFill, - color: "green.50", - bgColor: "green.900", - }, - { - text: `Setup notifications to be first to know when and how your contract is being interacted`, - icon: GiMeshBall, - color: "green.50", - bgColor: "green.900", - }, - ]} - imgURL={assets["pendingTransactions"]} - /> - - - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer exchanges button`, - }); - toggleModal("hubspot-developer"); - }, - }} - elementName={"element2"} - mirror={true} - colorScheme="orange" - badge={`Centralized exchange prices`} - 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["priceInformation"]} - /> - - - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer smartDeveloper button`, - }); - 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={`Know your people`} - bullets={[ - { - text: `Subscribe to social media tags and people`, - icon: IoTelescopeSharp, - color: "blue.50", - bgColor: "blue.900", - }, - { - text: `Automatically process content with our semantics AI analysis`, - icon: GiSuspicious, - color: "blue.50", - bgColor: "blue.900", - }, - { - text: `Register webhooks to connect your infrastructure`, - icon: GiHook, - color: "blue.50", - bgColor: "blue.900", - }, - ]} - imgURL={assets["socialMediaPosts"]} - /> - - - { - mixpanel.get_distinct_id() && - mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { - [`${MIXPANEL_PROPS.BUTTON_NAME}`]: `Early access CTA: developer analytics button`, - }); - 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="red" - badge={`Analyse blockchain activity`} - bullets={[ - { - text: `Monitor blockchain data in real time`, - icon: IoTelescopeSharp, - color: "red.50", - bgColor: "red.900", - }, - { - text: `Set up alerts on suspicious activity`, - icon: GiSuspicious, - color: "red.50", - bgColor: "red.900", - }, - { - text: `Register webhooks to connect your off-chain infrastructure`, - icon: GiHook, - color: "red.50", - bgColor: "red.900", - }, - ]} - imgURL={assets["smartDevelopers"]} - /> - */} -// -// -// 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 -// -// . -// -// diff --git a/frontend/pages/product/index.js b/frontend/pages/product/index.js index 10131e1c..ad154392 100644 --- a/frontend/pages/product/index.js +++ b/frontend/pages/product/index.js @@ -141,31 +141,9 @@ const Product = () => { title={`Smart contracts are starting to dominate blockchain activity`} elementName={"element1"} colorScheme="blue" - // badge={`State of art`} body={`web3 stands for decentralized automation through smart contracts. Smart contract developers are building the future of the decentralized web. `} - // 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["environment"]} imgBoxShadow="lg" /> @@ -174,31 +152,9 @@ const Product = () => { py={["12px", "24px", "48px"]} elementName={"element1"} colorScheme="blue" - // badge={`development tool`} title={`But smart contract activity can be opaque`} body={`Even smart contract developers have a difficult time finding out who is using their smart contracts and how. This makes it difficult for them to improve their users’ experience and to secure their decentralized applications.`} - // 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["developers"]} imgBoxShadow="lg" /> @@ -206,7 +162,6 @@ const Product = () => { elementName={"element1"} colorScheme="blue" py={["12px", "24px", "48px"]} - // badge={`Complex functionality`} title={`Blockchain explorers are not enough`} body={`Today, analyzing smart contract activity involves viewing data in or crawling data from blockchain explorers. The process is tedious and unreliable, and the data is difficult to interpret. @@ -219,7 +174,6 @@ const Product = () => { elementName={"element1"} py={["12px", "24px", "48px"]} colorScheme="blue" - // badge={`Simple to use`} title={`Meanwhile, on Web 2.0`} body={`Developers on the centralized web have access to tools like Google Analytics and Mixpanel. They can instantly build dashboards to understand their user journeys and identify any issues that their users may be experiencing. @@ -232,7 +186,6 @@ const Product = () => { elementName={"element1"} colorScheme="blue" py={["12px", "24px", "48px"]} - // badge={`Here to help you`} title={`Meet Moonstream!`} body={`Moonstream brings product analytics to web3. Instantly get analytics for any smart contract you write. diff --git a/frontend/src/components/SplitWithImage.js b/frontend/src/components/SplitWithImage.js index 9fec3a1b..203d9dbf 100644 --- a/frontend/src/components/SplitWithImage.js +++ b/frontend/src/components/SplitWithImage.js @@ -135,14 +135,12 @@ const SplitWithImage = ({ > {badge} From b6fbe8b6d97ad01a126ec8f024c98d4c1ea6a3c0 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 19:37:54 +0200 Subject: [PATCH 79/87] speed changes --- frontend/pages/index.js | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/frontend/pages/index.js b/frontend/pages/index.js index 4851a0b6..4250fea8 100644 --- a/frontend/pages/index.js +++ b/frontend/pages/index.js @@ -311,10 +311,12 @@ const Homepage = () => { pb="32px" > { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { @@ -324,7 +326,8 @@ const Homepage = () => { }} button1={{ label: "TX pool real time data", - link: "/#txpool", + speed: 9, + // link: "/#txpool", onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { @@ -334,7 +337,8 @@ const Homepage = () => { }} button2={{ label: "Exchange price stream", - link: "/#exchanges", + speed: 6, + // link: "/#exchanges", onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { @@ -344,7 +348,8 @@ const Homepage = () => { }} button3={{ label: "Social media posts", - link: "/#smartDeveloper", + speed: 3, + // link: "/#smartDeveloper", onClick: () => { mixpanel.get_distinct_id() && mixpanel.track(`${MIXPANEL_EVENTS.BUTTON_CLICKED}`, { From fa4b92f5ab48039f095e6f62eb505b9a0b4412a3 Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Wed, 13 Oct 2021 19:38:09 +0200 Subject: [PATCH 80/87] speed and cursor link changes --- frontend/src/components/ConnectedButtons.js | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/frontend/src/components/ConnectedButtons.js b/frontend/src/components/ConnectedButtons.js index f04897d5..590416b2 100644 --- a/frontend/src/components/ConnectedButtons.js +++ b/frontend/src/components/ConnectedButtons.js @@ -93,6 +93,7 @@ const ArrowCTA = (props) => {