feat: instatiate db using sqlalch

starklings-backend/starklings_backend/db.py

@@ -0,0 +1,17 @@
+import os
+import pymysql
+from sqlalchemy.orm import declarative_base, sessionmaker
+from models import StarklingsUser,Path,Exercise,ValidatedExercise, Base
+from sqlalchemy import create_engine
+from dotenv import load_dotenv
+load_dotenv()
+
+host=os.environ.get('DATABASE_HOST', '')
+database=os.environ.get('DATABASE_NAME', '')
+user=os.environ.get('DATABASE_USER', '')
+password=os.environ.get('DATABASE_PWD', '')
+
+engine = create_engine(f'mysql+pymysql://{user}:{password}@{host}/{database}', echo=True)
+
+Session = sessionmaker(bind=engine)
+Base.metadata.create_all(engine)

starklings-backend/starklings_backend/models.py

@@ -0,0 +1,42 @@
+from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
+from sqlalchemy.orm import sessionmaker, relationship, declarative_base
+
+Base = declarative_base()
+
+class StarklingsUser(Base):
+    __tablename__ = "starklings_user"
+    wallet_address = Column(String(42), primary_key=True)
+    signature = Column(String(255), nullable=False)
+    github = Column(String(255), nullable=True)
+    username = Column(String(255), nullable=False)
+    score = Column(Integer, nullable=False, default=0)
+    starklings_user = relationship("ValidatedExercise")
+
+
+class Path(Base):
+    __tablename__ = "path"
+    path_name = Column(String(255), primary_key=True)
+    num_exercises = Column(Integer, nullable=False)
+    path = relationship("Exercise")
+
+
+class Exercise(Base):
+    __tablename__ = "exercise"
+    exercise_name = Column(String(255), primary_key=True)
+    score = Column(Integer, nullable=False, default=0)
+    path_name = Column(String(255), ForeignKey("path.path_name"), nullable=False)
+    exercise = relationship("ValidatedExercise")
+
+
+class ValidatedExercise(Base):
+    __tablename__ = "validated_exercise"
+    validated_exercise_id = Column(String(64), primary_key=True)
+    exercise_name = Column(
+        String(255),
+        ForeignKey("exercise.exercise_name"),
+        nullable=False,
+    )
+    wallet_address = Column(
+        String(42), ForeignKey("starklings_user.wallet_address"), nullable=False
+    )
+

starklings-backend/starklings_backend/routes.py

@@ -3,15 +3,19 @@
 import bcrypt
 from sqlalchemy.exc import IntegrityError
 from flask_sqlalchemy import SQLAlchemy
-from starklings_backend.utils import verify_email
-from starklings_backend.models.shared import db
-from starklings_backend.models.user import Starklingsuser
+from starklings_backend.utils import verify_email, VerifySignature
+from starklings_backend.models import StarklingsUser, Path, Exercise, ValidatedExercise, Base
 from starklings_backend.exercise import verify_exercise
 from checker import ExerciceFailed
 import tempfile
+from starklings_backend.db import Session
+
+
 
 app_routes = Blueprint('app_routes', __name__)
 
+db = Session()
+
 @app_routes.route('/', methods=['GET'])
 def landing():
     return 'Starklings API'
@@ -27,18 +31,27 @@ def register_user():
     """
     try:
         signature = request.json.get('signature', None)
+        # convert string to tuple
+        signature = eval(signature)
         wallet_address = request.json.get('wallet_address', None)
         username = request.json.get('username', wallet_address)
+        github = request.json.get('github', None)
+        message_hash = request.json.get('message_hash', '')
+        network = request.json.get('network', 'testnet')
         if None in [wallet_address, signature]:
             return "Wrong form", 400 
-        #@TODO: Check Signature validity
-
-        user = Starklingsuser(wallet_address=wallet_address, signature=signature, username=username)
-        db.session.commit()
-        return f'Welcome! {username}', 200
+        # verify signature
+        verify_signature = VerifySignature(abi, network, wallet_address)
+        is_valid, error = verify_signature.verify_signature(message_hash, signature)
+        if error is None:
+            user = StarklingsUser(wallet_address=wallet_address, signature=signature, github=github, username=username)
+            db.add(user)
+            db.commit()
+            return f'Welcome! {username}', 200
+        return 'Signature invalid', 400
 
     except IntegrityError as e:
-        db.session.rollback()
+        session.rollback()
         return 'User Already Exists', 400
     except AttributeError:
         return 'Provide an Email and Password in JSON format in the request body', 400
@@ -54,7 +67,7 @@ def fetch_user_info():
         wallet_address = request.json.get('wallet_address', None)
         if not wallet_address:
             return 'Missing address', 400
-        user = Starklingsuser.query.filter_by(wallet_address=wallet_address).first()
+        user = StarklingsUser.query.filter_by(wallet_address=wallet_address).first()
         if not user:
             return 'User Not Found!', 404
 

starklings-backend/starklings_backend/utils.py

@@ -2,15 +2,21 @@
 import json
 import os
 import re
+from starknet_py.net.gateway_client import GatewayClient
+from starknet_py.net.networks import TESTNET, MAINNET
+from starknet_py.contract import Contract
+import asyncio
 
-regex = re.compile(r'([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+')
+
+regex = re.compile(r"([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+")
 
 
 def verify_email(email):
     if re.fullmatch(regex, email):
-      return True
+        return True
     else:
-      return False
+        return False
+
 
 class Requester:
     def __init__(self, base_url, **kwargs):
@@ -22,25 +28,25 @@ def __init__(self, base_url, **kwargs):
             setattr(self.session, arg, kwargs[arg])
 
     def request(self, method, url, **kwargs):
-        return self.session.request(method, self.base_url+url, **kwargs)
+        return self.session.request(method, self.base_url + url, **kwargs)
 
     def head(self, url, **kwargs):
-        return self.session.head(self.base_url+url, **kwargs)
+        return self.session.head(self.base_url + url, **kwargs)
 
     def get(self, url, **kwargs):
-        return self.session.get(self.base_url+url, **kwargs)
+        return self.session.get(self.base_url + url, **kwargs)
 
     def post(self, url, data, **kwargs):
-        return self.session.post(self.base_url+url, data=data, **kwargs)
+        return self.session.post(self.base_url + url, data=data, **kwargs)
 
     def put(self, url, **kwargs):
-        return self.session.put(self.base_url+url, **kwargs)
+        return self.session.put(self.base_url + url, **kwargs)
 
     def patch(self, url, **kwargs):
-        return self.session.patch(self.base_url+url, **kwargs)
+        return self.session.patch(self.base_url + url, **kwargs)
 
     def delete(self, url, **kwargs):
-        return self.session.delete(self.base_url+url, **kwargs)
+        return self.session.delete(self.base_url + url, **kwargs)
 
     @staticmethod
     def __deep_merge(source, destination):
@@ -51,3 +57,35 @@ def __deep_merge(source, destination):
             else:
                 destination[key] = value
         return destination
+
+
+class VerifySignature:
+    SUPPORTED_NETWORKS = ["mainnet", "testnet"]
+
+    def __init__(self, abi, network, contract_address):
+        with open(abi, "r") as reader:
+            abi = json.load(reader)
+        assert network in self.SUPPORTED_NETWORKS
+        network = self.set_network(network)
+        self.contract = Contract(
+            contract_address,
+            abi,
+            network,
+        )
+
+    def set_network(self, network):
+        if network == "testnet":
+            return GatewayClient(TESTNET)
+        elif network == "mainnet":
+            return GatewayClient(MAINNET)
+
+    def __call__(self, message_hash, signature):
+        try:
+            asyncio.run(
+                self.contract.functions["is_valid_signature"].call(
+                    message_hash, (signature[0], signature[1])
+                )
+            )
+            return "Valid Signature", None
+        except Exception as e:
+            return "Invalid Signature", 400