cryptoadvance-specter 2.1.2__py3-none-any.whl

cryptoadvance/specter/__main__.py

@@ -0,0 +1,7 @@
+from logging.config import dictConfig
+from .cli import entry_point
+import logging
+
+if __name__ == "__main__":
+
+    entry_point()

cryptoadvance/specter/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2.1.2'
+__version_tuple__ = version_tuple = (2, 1, 2)
+
+__commit_id__ = commit_id = None

cryptoadvance/specter/api/__init__.py

@@ -0,0 +1,18 @@
+""" API Blueprint Application """
+
+import os
+from flask import Flask, Blueprint, session
+from flask_restful import Api
+from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth
+from flask import current_app as app
+
+api_bp = Blueprint("api_bp", __name__, template_folder="templates", url_prefix="/api")
+
+api_rest = Api(api_bp, decorators=[app.csrf.exempt])
+
+auth = HTTPBasicAuth()
+
+token_auth = HTTPTokenAuth()
+
+from . import views
+from .rest import api

cryptoadvance/specter/api/rest/api.py

@@ -0,0 +1,83 @@
+import logging
+import json
+
+import cryptoadvance.specter as specter
+from ...wallet import Wallet
+from .base import (
+    SecureResource,
+    rest_resource,
+)
+from ..security import require_admin, verify_password
+from flask_restful import abort
+from flask import current_app as app
+from datetime import datetime
+from ...specter_error import SpecterError
+
+from ...util.fee_estimation import get_fees
+
+from .. import token_auth
+from .resource_jwt import JWTResource, JWTResourceById
+from .resource_healthz import ResourceLiveness, ResourceReadyness
+from .resource_psbt import ResourcePsbt
+from .resource_specter import ResourceSpecter
+from .resource_txlist import ResourceTXlist
+
+logger = logging.getLogger(__name__)
+
+
+@rest_resource
+class ResourceWallet(SecureResource):
+
+    endpoints = ["/v1alpha/wallets/<wallet_alias>/"]
+
+    def get(self, wallet_alias):
+        user = token_auth.current_user()
+        try:
+            wallet: Wallet = app.specter.user_manager.get_user(
+                user
+            ).wallet_manager.get_by_alias(wallet_alias)
+        except SpecterError as se:
+            logger.error(se)
+            if str(se).startswith(f"Wallet {wallet_alias} does not exist!"):
+                return abort(403, message=f"Wallet {wallet_alias} does not exist")
+            logger.error(se)
+            return abort(500)
+
+        wallet.update_balance()
+        wallet.check_utxo()
+        wallet.check_unused()
+
+        return_dict = {}
+        address_index = wallet.address_index
+        validate_merkle_proofs = app.specter.config.get("validate_merkle_proofs")
+        tx_list = []
+        idx = 0
+        tx_len = 1
+        transactions = app.specter.wallet_manager.full_txlist(
+            fetch_transactions=False, validate_merkle_proofs=validate_merkle_proofs
+        )
+        tx_list.append(transactions)
+
+        # Flatten the list
+        flat_list = []
+        for element in tx_list:
+            for dic_item in element:
+                flat_list.append(dic_item)
+
+        # Check if scanning
+        scan = wallet.rescan_progress
+        return_dict[wallet_alias] = wallet.__dict__
+        return_dict["txlist"] = flat_list
+        return_dict["scan"] = scan
+        return_dict["address_index"] = address_index
+        return_dict["utxo"] = wallet.utxo
+
+        # Serialize only objects that are json compatible
+        # This will exclude classes and methods
+        def safe_serialize(obj):
+            def default(o):
+                return f"{type(o).__qualname__}"
+
+            return json.dumps(obj, default=default)
+
+        return json.loads(safe_serialize(return_dict))

cryptoadvance/specter/api/rest/base.py

@@ -0,0 +1,92 @@
+""" API Backend - Base Resource Models """
+
+from functools import wraps
+import logging
+import re
+from flask_restful import Resource, abort
+
+from cryptoadvance.specter.api import api_rest
+from cryptoadvance.specter.api.security import require_admin
+from cryptoadvance.specter.api import auth, token_auth
+from cryptoadvance.specter.specter_error import SpecterError
+
+logger = logging.getLogger(__name__)
+
+
+def error_handling(func):
+    """User needs Admin-rights method decorator"""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        """wrapping the whole error-handling around methods"""
+        try:
+            return func(*args, **kwargs)
+        except SpecterError as se:
+            logger.error(se)
+            # Not that elegant as this function is accumulating all the error-handling for different
+            # endpoints. On the other hand, this is probabyl more tied to different SpecterErrors
+            # rather than the implementation of a rest-endpoint.
+            match = re.match("Wallet (.+) does not exist!", str(se))
+            if match:
+                return abort(403, message=f"Wallet {match.group(1)} does not exist")
+            if str(se).endswith(
+                "does not have sufficient funds to make the transaction."
+            ):
+                return abort(
+                    412,
+                    message=f"Wallet does not have sufficient funds to make the transaction.",
+                )
+            return abort(500)
+        except Exception as e:
+            logger.error("Unexpected Exception in Rest-Request:")
+            logger.exception(e)
+            return abort(
+                500,
+                message="Can't tell you the reason of the issue. Please check the logs",
+            )
+
+    return wrapper
+
+
+class BaseResource(Resource):
+    """A baseClass for rsources which returns Method not allowed by default"""
+
+    method_decorators = [error_handling]
+
+    def get(self, *args, **kwargs):
+        abort(405)
+
+    def post(self, *args, **kwargs):
+        abort(405)
+
+    def put(self, *args, **kwargs):
+        abort(405)
+
+    def patch(self, *args, **kwargs):
+        abort(405)
+
+    def delete(self, *args, **kwargs):
+        abort(405)
+
+
+class SecureResource(BaseResource):
+    """A REST-resource which makes sure that the user is Authenticated"""
+
+    method_decorators = [error_handling, token_auth.login_required]
+
+
+class BasicAuthResource(BaseResource):
+    """A REST-resource which makes sure that the user is Authenticated"""
+
+    method_decorators = [error_handling, auth.login_required]
+
+
+class AdminResource(BaseResource):
+    """A REST-resource which makes sure that the user is an admin"""
+
+    method_decorators = [error_handling, require_admin, token_auth.login_required]
+
+
+def rest_resource(resource_cls):
+    """Decorator for adding resources to Api App"""
+    api_rest.add_resource(resource_cls, *resource_cls.endpoints)

cryptoadvance/specter/api/rest/resource_healthz.py

@@ -0,0 +1,42 @@
+"""
+liveness and readiness probes are a semi-standard way of health-checking.
+See e.g. here:
+https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/
+"""
+import json
+import logging
+from os import abort
+
+from cryptoadvance.specter.api.rest.base import BaseResource, rest_resource
+from flask import current_app as app
+
+logger = logging.getLogger(__name__)
+
+
+@rest_resource
+class ResourceLiveness(BaseResource):
+    """/api/healthz/liveness
+    Whether the app is up and running although it might not have connection to DB/nodes etc.
+    """
+
+    endpoints = ["/healthz/liveness"]
+
+    def get(self):
+        return {"message": "i am alive"}
+
+
+@rest_resource
+class ResourceReadyness(BaseResource):
+    """/api/healthz/readyness
+    Whether the app is up and running AND ALL its dependent services (in our case nodes) are properly functioning as well.
+    """
+
+    endpoints = ["/healthz/readyness"]
+
+    def get(self):
+        try:
+            # Not sure whether that's enough. Probably improvable:
+            app.specter.check()
+        except Exception as e:
+            abort(500, message="Readyness probe failed")
+        return {"message": "i am ready"}

cryptoadvance/specter/api/rest/resource_jwt.py

@@ -0,0 +1,135 @@
+import jwt
+from flask import current_app as app
+from flask_restful import Api, abort, reqparse
+from cryptoadvance.specter.api.rest.base import (
+    BaseResource,
+    BasicAuthResource,
+    SecureResource,
+    rest_resource,
+    AdminResource,
+)
+import uuid
+import datetime
+import logging
+from ...user import *
+from .base import *
+from pytimeparse import parse
+
+from .. import auth
+
+logger = logging.getLogger(__name__)
+
+# Initialize the parser
+parser = reqparse.RequestParser()
+parser.add_argument(
+    "jwt_token_description", type=str, help="JWT token description", required=True
+)
+parser.add_argument("jwt_token_life", type=str, help="JWT token life", required=True)
+
+
+@rest_resource
+class JWTResource(BasicAuthResource):
+    """
+    A Resource to manage JWT tokens in order to authenticate against the REST-API
+    Other then the other Resources, this endpoint uses BasicAuth to avoid the chicken egg problem
+    This one is only to create a token. The other Resource for getting and deleting.
+    This violates the REST principles but only on the implementation-side. Happy for improvements here.
+    """
+
+    endpoints = ["/v1alpha/token/"]
+
+    def get(self):
+        # An endpoint to get all JWT tokens' information created by the user
+        user = auth.current_user()
+        user_details = app.specter.user_manager.get_user(user)
+        jwt_tokens = user_details.get_all_jwt_tokens_info()
+        if len(jwt_tokens) == 0:
+            return {"message": "Tokens does not exist"}, 404
+        return {"message": "Tokens exist", "jwt_tokens": jwt_tokens}, 200
+
+    def post(self):
+        # An endpoint to create a JWT token
+        user = auth.current_user()
+        data = parser.parse_args()
+        user_details = app.specter.user_manager.get_user(user)
+        jwt_token_id = user_details.generate_token_id()
+        jwt_token_description = data["jwt_token_description"]
+
+        # pytimeparse has been used to parse different time units to seconds
+        # For eg: "jwt_token_life_unit": "1 hour" will be parsed to 3600 seconds
+        # For more information visit: https://pypi.org/project/pytimeparse/
+        jwt_token_life = parse(data["jwt_token_life"])
+        jwt_token = user_details.generate_jwt_token(
+            user_details.username,
+            jwt_token_id,
+            jwt_token_description,
+            jwt_token_life,
+        )
+        if user_details.validate_jwt_token_description(jwt_token_description):
+            user_details.add_jwt_token(
+                jwt_token_id,
+                jwt_token,
+                jwt_token_description,
+                jwt_token_life,
+            )
+            return {
+                "message": "Token generated",
+                "jwt_token_id": jwt_token_id,
+                "jwt_token": jwt_token,
+                "jwt_token_description": jwt_token_description,
+                "jwt_token_life": jwt_token_life,
+            }, 201
+        else:
+            return {"message": "Token description already exists or is blank"}, 400
+
+
+@rest_resource
+class JWTResourceById(BasicAuthResource):
+    """
+    A Resource to manage individual JWT token
+    """
+
+    endpoints = ["/v1alpha/token/<jwt_token_id>/"]
+
+    def get(self, jwt_token_id):
+        # An endpoint to get a JWT token by id
+        user = auth.current_user()
+        user_details = app.specter.user_manager.get_user(user)
+        jwt_tokens = user_details.jwt_tokens
+        jwt_token = user_details.get_jwt_token(jwt_token_id)
+        jwt_token_life_remaining = user_details.jwt_token_life_remaining(jwt_token_id)
+        expiry_status = f"Valid"
+        if jwt_token_life_remaining == 0:
+            expiry_status = f"Expired"
+        if (
+            not user_details.verify_jwt_token_id_and_jwt_token(jwt_token_id, jwt_token)
+            and jwt_tokens[jwt_token_id] is None
+        ):
+            return {
+                "message": "Token does not exist, make sure to enter correct token id"
+            }, 404
+        return {
+            "message": "Token exists",
+            "jwt_token_description": jwt_token["jwt_token_description"],
+            "jwt_token_life": jwt_token["jwt_token_life"],
+            "jwt_token_life_remaining": jwt_token_life_remaining,
+            "expiry_status": expiry_status,
+        }, 200
+
+    def delete(self, jwt_token_id):
+        # An endpoint to delete a JWT token by id
+        user = auth.current_user()
+        user_details = app.specter.user_manager.get_user(user)
+        jwt_tokens = user_details.jwt_tokens
+        jwt_token = user_details.get_jwt_token(jwt_token_id)
+
+        if (
+            not user_details.verify_jwt_token_id_and_jwt_token(jwt_token_id, jwt_token)
+            and jwt_tokens[jwt_token_id] is None
+        ):
+            return {
+                "message": "Token does not exist, make sure to enter correct token id"
+            }, 404
+
+        user_details.delete_jwt_token(jwt_token_id)
+        return {"message": "Token deleted"}, 200

cryptoadvance/specter/api/rest/resource_psbt.py

@@ -0,0 +1,53 @@
+import logging
+import base64
+from json import dumps
+
+from .base import (
+    SecureResource,
+    rest_resource,
+)
+
+from flask import current_app as app, request, Response
+from ...wallet import Wallet
+from ...commands.psbt_creator import PsbtCreator
+from ...specter_error import SpecterError
+from .. import token_auth
+
+logger = logging.getLogger(__name__)
+
+
+@rest_resource
+class ResourcePsbt(SecureResource):
+    """/api/v1alpha/specter"""
+
+    endpoints = ["/v1alpha/wallets/<wallet_alias>/psbt"]
+
+    def get(self, wallet_alias):
+        user = token_auth.current_user()
+        wallet_manager = app.specter.user_manager.get_user(user).wallet_manager
+        # Check that the wallet belongs to the user from Basic Auth
+        try:
+            wallet = wallet_manager.get_by_alias(wallet_alias)
+        except SpecterError as se:
+            # ToDo: Be more specific here. How do we know that this SpecterError is a fit to that message?
+            logger.warning(
+                f"User user {user} denied access to {wallet_alias} because of {se}"
+            )
+            error_message = dumps(
+                {"message": "The wallet does not belong to the user in the request."}
+            )
+            return Response(error_message, 403)
+        pending_psbts = wallet.pending_psbts_dict()
+        return {"result": pending_psbts or {}}
+
+    def post(self, wallet_alias):
+        user = token_auth.current_user()
+        wallet: Wallet = app.specter.user_manager.get_user(
+            user
+        ).wallet_manager.get_by_alias(wallet_alias)
+        logger.debug(f"Got a post request for creating a psbt: {request.json}")
+        psbt_creator = PsbtCreator(
+            app.specter, wallet, "json", request_json=request.json
+        )
+        psbt = psbt_creator.create_psbt(wallet)
+        return {"result": psbt}

cryptoadvance/specter/api/rest/resource_specter.py

@@ -0,0 +1,46 @@
+import logging
+
+from cryptoadvance.specter.api.rest.base import (
+    AdminResource,
+    rest_resource,
+)
+from flask import current_app as app
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+@rest_resource
+class ResourceSpecter(AdminResource):
+    """/api/v1alpha/specter"""
+
+    endpoints = ["/v1alpha/specter"]
+
+    def get(self):
+        specter_data = app.specter
+
+        return_dict = {
+            "data_folder": specter_data.data_folder,
+            "config": specter_data.config,
+            "info": specter_data.info,
+            "network_info": specter_data.network_info,
+            "device_manager_datafolder": specter_data.device_manager.data_folder,
+            "devices_names": specter_data.device_manager.devices_names,
+            "wallets_names": specter_data.wallet_manager.wallets_names,
+            "last_update": datetime.now().strftime("%m/%d/%Y, %H:%M:%S"),
+        }
+
+        # Include alias list for easy lookup between names and alias
+        # Maybe there's a better way to create this
+        wallets_alias = []
+        alias_name = {}
+        name_alias = {}
+        for wallet in return_dict["wallets_names"]:
+            alias = specter_data.wallet_manager.wallets[wallet].alias
+            wallets_alias.append(alias)
+            alias_name[alias] = wallet
+            name_alias[wallet] = alias
+        return_dict["alias_name"] = alias_name
+        return_dict["name_alias"] = name_alias
+        return_dict["wallets_alias"] = wallets_alias
+        return return_dict

cryptoadvance/specter/api/rest/resource_txlist.py

@@ -0,0 +1,34 @@
+import json
+import logging
+
+from cryptoadvance.specter.api.rest.base import AdminResource, rest_resource
+from flask import current_app as app
+
+from .. import token_auth
+
+logger = logging.getLogger(__name__)
+
+
+@rest_resource
+class ResourceTXlist(AdminResource):
+    """/api/v1alpha/full_txlist"""
+
+    endpoints = ["/v1alpha/specter/full_txlist/"]
+
+    def get(self):
+        user = token_auth.current_user()
+        wallet_manager = app.specter.user_manager.get_user(user).wallet_manager
+        validate_merkle_proofs = app.specter.config.get("validate_merkle_proofs")
+        idx = 0
+        tx_len = 1
+        tx_list = []
+        transactions = wallet_manager.full_txlist(
+            fetch_transactions=False, validate_merkle_proofs=validate_merkle_proofs
+        )
+        tx_list.append(transactions)
+        # Flatten the list
+        flat_list = []
+        for element in tx_list:
+            for dic_item in element:
+                flat_list.append(dic_item)
+        return flat_list

cryptoadvance/specter/api/security.py

@@ -0,0 +1,73 @@
+""" Security Related things for the REST-API """
+import logging, jwt
+from functools import wraps
+
+from cryptoadvance.specter.user import User, verify_password as user_verify_password
+from flask import current_app as app
+from flask import g
+from flask_restful import abort
+from . import auth, token_auth
+from ..user import *
+from . import auth
+from flask import current_app as app
+
+logger = logging.getLogger(__name__)
+
+
+@auth.verify_password
+def verify_password(username, password):
+    """Validate user passwords and store user in the 'g' object"""
+    if not username or not password:
+        return abort(401)
+    the_user = app.specter.user_manager.get_user_by_username(username)
+    if not the_user:
+        return abort(401)
+    g.user = app.specter.user_manager.get_user_by_username(username)
+    if user_verify_password(g.user.password_hash, password):
+        logger.info(f"Rest-Request for user {username} PASSED password-test")
+        return username
+    else:
+        logger.info(f"Rest-Request for user {username} FAILED password-test")
+        return abort(401)
+
+    return g.user is not None and verify_password(g.user.password_hash, password)
+
+
+@token_auth.verify_token
+def verify_token(jwt_token):
+    """Validate JWT token and store user in the 'g' object"""
+    if not jwt_token:
+        return abort(401)
+    try:
+        payload = jwt.decode(jwt_token, app.config["SECRET_KEY"], algorithms=["HS256"])
+        username = payload["username"]
+        the_user = app.specter.user_manager.get_user_by_username(username)
+        if not the_user:
+            return abort(401)
+        g.user = app.specter.user_manager.get_user_by_username(username)
+        logger.info({"payload": payload})
+        logger.info(f"Rest-Request for user {username} PASSED JWT-test")
+        return username
+    except jwt.ExpiredSignatureError:
+        logger.info(f"Token expired. Please create a new one")
+        return abort(401)
+    except jwt.InvalidTokenError:
+        logger.info(f"Invalid token. Please create a new one")
+        return abort(401)
+
+
+def require_admin(func):
+    """User needs Admin-rights method decorator"""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        """this needs to get implemented properly"""
+        # Verify if User is Admin
+        if g.user == None:
+            return abort(401)
+        if g.user.is_admin:
+            return func(*args, **kwargs)
+        else:
+            return abort(401)
+
+    return wrapper

cryptoadvance/specter/api/templates/api.html

@@ -0,0 +1,18 @@
+<html>
+
+<body>
+The documentation for the API FOR THE MASTER BRANCH can be found here:
+<a href="https://github.com/cryptoadvance/specter-desktop/blob/master/docs/api/README.md">https://github.com/cryptoadvance/specter-desktop/blob/master/docs/api/api.md</a>
+
+<br><br>
+Make sure to choose the right version for the version you're currently using: {{version}}
+
+<br><br>
+{% if version != "custom" %}
+So assuming that, please use this url:
+<a href="https://github.com/cryptoadvance/specter-desktop/blob/v{{version}}/docs/api/README.md">https://github.com/cryptoadvance/specter-desktop/blob/v{{version}}/docs/api/api.md</a>
+{% endif %}
+
+</body>
+
+</html>

cryptoadvance/specter/api/views.py

@@ -0,0 +1,11 @@
+from flask import render_template
+from cryptoadvance.specter.api import api_bp
+from flask import current_app as app
+
+
+@api_bp.route("/")
+def api():
+    """rendering the documentation for the api"""
+    return render_template(
+        "api.html", version=app.specter.version._get_current_version()
+    )