EpicCash/epicpost
5
0
Fork 2
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Compare commits

base: EpicCash:master
Branches Tags
EpicCash:master
dan:master
..
compare: dan:master
Branches Tags
dan:master
EpicCash:master

No commits in common. "master" and "master" have entirely different histories.
master ... master

3 changed files with 4 additions and 244 deletions
Show Stats Expand all files Collapse all files

88
funding/orm.py
View File

@ -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

156
funding/routes.py
View File

@ -8,10 +8,7 @@ import json
import settings
from funding.factory import app, db, cache
from funding.orm import Address, Slate, Cancel
import secp256k1
import base58
from funding.orm import Address, Slate
@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)}))

4
requirements.txt
View File

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