funding/orm.py

@@ -10,7 +10,6 @@ from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.types import Float
 from sqlalchemy_json import MutableJson
-from sqlalchemy import and_, or_, not_
 import hashlib
 import json
 
@@ -94,23 +93,6 @@ class Slate(db.Model):
             list_slates.append(slate_db.slate)
         return list_slates
 
-    @classmethod
-    def delete_slate(cls, address, slate):
-        q = cls.query
-        q = q.filter(and_(Slate.receivingAddress == address, Slate.slate == slate) )
-        result = q.first()
-        if result is None:
-            print("none guy")
-            return True
-        try:
-            db.session.delete(result)
-            db.session.commit()
-            db.session.flush()
-            return True
-        except Exception as ex:
-            db.session.rollback()
-            return False
-
     @classmethod
     def add(cls, slate, receivingAddress):
         from funding.factory import db
@@ -130,73 +112,3 @@ class Slate(db.Model):
         except Exception as ex:
             db.session.rollback()
             raise
-
-
-class Cancel(db.Model):
-    __tablename__ = "cancels"
-    id = db.Column(db.Integer, primary_key=True)
-    slate_id = db.Column(db.String())
-    # TODO: clear slatse that have been in the database past a certain time
-    posted_time = db.Column(db.DateTime)
-    receivingAddress = db.Column(db.String(52), nullable=False)
-    sendersAddress = db.Column(db.String(52), nullable=False)
-
-    def __init__(self, slate_id, receivingAddress, sendersAddress):
-        from funding.factory import bcrypt
-        self.slate_id = slate_id
-        self.receivingAddress = receivingAddress
-        self.sendersAddress = sendersAddress
-        self.posted_time = datetime.utcnow()
-
-    def __repr__(self):
-        return "<Cancel(slate_id='%s', receivingAddress='%s', sendersAddress='%s', posted_time='%s)>" % (
-            self.slate_id, self.receivingAddress, self.sendersAddress, self.posted_time)
-
-    @classmethod
-    def find_slate_ids(cls, address):
-        q = cls.query
-        q = q.filter(Cancel.receivingAddress == address)
-        result = q.all()
-        print(f'{result}')
-        list_slates = []
-        for slate_db in result:
-            list_slates.append({slate_db.slate_id: slate_db.sendersAddress})
-        return list_slates
-
-    @classmethod
-    def delete_slate_id(cls, address, slate_id):
-        q = cls.query
-        q = q.filter(and_(Cancel.receivingAddress == address, Cancel.slate_id == slate_id))
-        result = q.first()
-        if result is None:
-            print("none guy")
-            return True
-        try:
-            db.session.delete(result)
-            db.session.commit()
-            db.session.flush()
-            return True
-        except Exception as ex:
-            db.session.rollback()
-            return False
-
-    @classmethod
-    def add(cls, slate_id, receivingAddress, sendersAddress):
-        from funding.factory import db
-
-        try:
-
-            previous = cls.query.filter(Cancel.slate_id == slate_id).first()
-            if previous is not None:
-                print(previous)
-                print("was inputted before")
-                return
-            # put in new one
-            new_cancel_request = Cancel(slate_id=slate_id, receivingAddress=receivingAddress, sendersAddress=sendersAddress)
-            db.session.add(new_cancel_request)
-            db.session.commit()
-            db.session.flush()
-            return new_cancel_request
-        except Exception as ex:
-            db.session.rollback()
-            raise

funding/routes.py

@@ -8,10 +8,7 @@ import json
 
 import settings
 from funding.factory import app, db, cache
-from funding.orm import Address, Slate, Cancel
+from funding.orm import Address, Slate
-
-import secp256k1
-import base58
 
 
 @app.route('/')
@@ -53,162 +50,15 @@ def postSlate(receivingAddress, slate):
 @app.route('/getSlates', methods=['POST'])
 @endpoint.api(
     parameter('receivingAddress', type=str, required=True),
-    parameter('signature', type=str, required=True)
 )
-def getSlates(receivingAddress, signature):
+def getSlates(receivingAddress):
     try:
-        if receivingAddress is None or signature is None:
+        if receivingAddress is None:
             return make_response(jsonify({'status': 'failure', 'error': str("missing correct arguments")}))
 
-        # Deserialize the base-58 address to an internal public key format
-        # NOTE: This assumes that the network version (which is not part of the key) is exactly 2 bytes
-        public_key = secp256k1.PublicKey(base58.b58decode_check(receivingAddress)[2:], raw=True)
-
-        # Prepare the message bound to the signature: a domain separator and the encoded address
-        # For some reason, the original client code calls this the "challenge"
-        message = 'SubscribeRequest_' + receivingAddress
-
-        # Deserialize and verify the provided signature against the message and address public key
-        if not public_key.ecdsa_verify(message.encode(),
-                                       public_key.ecdsa_deserialize(bytes(bytearray.fromhex(signature)))):
-            return make_response(jsonify({'status': 'failure', 'error': str("bad signature")}))
-
         slates = Slate.find_slates(address=receivingAddress)
         return make_response(jsonify({'status': 'success', 'slates': slates}))
 
     except Exception as ex:
         print(f'{ex}')
         return make_response(jsonify({'status': 'failure', 'error': str(ex)}))
-
-
-@app.route('/deleteSlate', methods=['POST'])
-@endpoint.api(
-    parameter('receivingAddress', type=str, required=True),
-    parameter('signature', type=str, required=True),
-    parameter('slate', type=str, required=True)
-)
-def deleteSlate(receivingAddress, signature, slate):
-    try:
-        if slate is None or signature is None or receivingAddress is None:
-            return make_response(jsonify({'status': 'failure', 'error': str("missing correct arguments")}))
-
-        # Deserialize the base-58 address to an internal public key format
-        # NOTE: This assumes that the network version (which is not part of the key) is exactly 2 bytes
-        public_key = secp256k1.PublicKey(base58.b58decode_check(receivingAddress)[2:], raw=True)
-
-        # Prepare the message bound to the signature: a domain separator and the encoded address
-        # For some reason, the original client code calls this the "challenge"
-        message = 'SubscribeRequest_' + receivingAddress
-
-        # Deserialize and verify the provided signature against the message and address public key
-        if not public_key.ecdsa_verify(message.encode(),
-                                       public_key.ecdsa_deserialize(bytes(bytearray.fromhex(signature)))):
-            return make_response(jsonify({'status': 'failure', 'error': str("bad signature")}))
-
-        is_deleted = Slate.delete_slate(address=receivingAddress, slate=slate)
-
-        return make_response(jsonify({'status': 'success', 'is_deleted': is_deleted}))
-
-    except Exception as ex:
-        print(f'{ex}')
-        return make_response(jsonify({'status': 'failure', 'error': str(ex)}))
-
-
-@app.route('/postCancel', methods=['POST'])
-@endpoint.api(
-    parameter('receivingAddress', type=str, required=True),
-    parameter('signature', type=str, required=True),
-    parameter('slate', type=str, required=True),
-    parameter('sendersAddress', type=str, required=True),
-)
-def postCancel(receivingAddress, signature, slate, sendersAddress):
-    try:
-        if sendersAddress is None or slate is None or signature is None or receivingAddress is None:
-            return make_response(jsonify({'status': 'failure', 'error': str("missing correct arguments")}))
-
-        # Deserialize the base-58 address to an internal public key format
-        # NOTE: This assumes that the network version (which is not part of the key) is exactly 2 bytes
-        public_key = secp256k1.PublicKey(base58.b58decode_check(sendersAddress)[2:], raw=True)
-
-        # Prepare the message bound to the signature: a domain separator and the encoded address
-        # For some reason, the original client code calls this the "challenge"
-        message = 'SubscribeRequest_' + sendersAddress
-
-        # Deserialize and verify the provided signature against the message and address public key
-        if not public_key.ecdsa_verify(message.encode(),
-                                       public_key.ecdsa_deserialize(bytes(bytearray.fromhex(signature)))):
-            return make_response(jsonify({'status': 'failure', 'error': str("bad signature")}))
-
-        try:
-            Cancel.add(receivingAddress=receivingAddress, slate_id=slate, sendersAddress=sendersAddress)
-        except Exception as ex:
-            print(f'{ex}')
-
-        return make_response(jsonify({'status': 'success'}))
-    except Exception as ex:
-        print(f'{ex}')
-        return make_response(jsonify({'status': 'failure', 'error': str(ex)}))
-
-
-@app.route('/getCancels', methods=['POST'])
-@endpoint.api(
-    parameter('receivingAddress', type=str, required=True),
-    parameter('signature', type=str, required=True),
-)
-def getCancels(receivingAddress, signature):
-    try:
-        if receivingAddress is None or signature is None:
-            return make_response(jsonify({'status': 'failure', 'error': str("missing correct arguments")}))
-
-        # Deserialize the base-58 address to an internal public key format
-        # NOTE: This assumes that the network version (which is not part of the key) is exactly 2 bytes
-        public_key = secp256k1.PublicKey(base58.b58decode_check(receivingAddress)[2:], raw=True)
-
-        # Prepare the message bound to the signature: a domain separator and the encoded address
-        # For some reason, the original client code calls this the "challenge"
-        message = 'SubscribeRequest_' + receivingAddress
-
-        # Deserialize and verify the provided signature against the message and address public key
-        if not public_key.ecdsa_verify(message.encode(),
-                                       public_key.ecdsa_deserialize(bytes(bytearray.fromhex(signature)))):
-            return make_response(jsonify({'status': 'failure', 'error': str("bad signature")}))
-
-        slates = Cancel.find_slate_ids(address=receivingAddress)
-        return make_response(jsonify({'status': 'success', 'canceled_slates': slates}))
-
-    except Exception as ex:
-        print(f'{ex}')
-        return make_response(jsonify({'status': 'failure', 'error': str(ex)}))
-
-
-@app.route('/deleteCancels', methods=['POST'])
-@endpoint.api(
-    parameter('receivingAddress', type=str, required=True),
-    parameter('signature', type=str, required=True),
-    parameter('slate', type=str, required=True)
-)
-def deleteCancels(receivingAddress, signature, slate):
-    try:
-        if slate is None or signature is None or receivingAddress is None:
-            return make_response(jsonify({'status': 'failure', 'error': str("missing correct arguments")}))
-
-        # Deserialize the base-58 address to an internal public key format
-        # NOTE: This assumes that the network version (which is not part of the key) is exactly 2 bytes
-        public_key = secp256k1.PublicKey(base58.b58decode_check(receivingAddress)[2:], raw=True)
-
-        # Prepare the message bound to the signature: a domain separator and the encoded address
-        # For some reason, the original client code calls this the "challenge"
-        message = 'SubscribeRequest_' + receivingAddress
-
-        # Deserialize and verify the provided signature against the message and address public key
-        if not public_key.ecdsa_verify(message.encode(),
-                                       public_key.ecdsa_deserialize(bytes(bytearray.fromhex(signature)))):
-            return make_response(jsonify({'status': 'failure', 'error': str("bad signature")}))
-
-        is_deleted = Cancel.delete_slate_id(address=receivingAddress, slate_id=slate)
-
-        return make_response(jsonify({'status': 'success', 'is_deleted': is_deleted}))
-
-    except Exception as ex:
-        print(f'{ex}')
-        return make_response(jsonify({'status': 'failure', 'error': str(ex)}))

requirements.txt

@@ -14,6 +14,4 @@ pypng
 pillow-simd
 Flask-Caching
 flask-sqlalchemy
-sqlalchemy_json
+sqlalchemy_json
-secp256k1
-base58