sgx.py 0.12.dev1__tar.gz → 0.12.dev2__tar.gz

{sgx_py-0.12.dev1/sgx.py.egg-info → sgx_py-0.12.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sgx.py
-Version: 0.12.dev1
+Version: 0.12.dev2
 Summary: SGX
 Home-page: http://github.com/skalenetwork/sgx.py
 Author: SKALE Labs

sgx_py-0.12.dev2/README.md

@@ -0,0 +1,112 @@
+# sgx.py
+[![Discord](https://img.shields.io/discord/534485763354787851.svg)](https://discord.gg/vvUtWJB)
+
+## Requirements
+
+|**Tool**|**Minimum Supported Version**|
+|--------|-----------|
+| Python |    3.11    |
+
+---
+
+## Installation
+
+### Install Python 3.11
+
+```bash
+# confirm prerequisites are isntalled
+sudo apt update
+sudo apt install software-properties-common
+# Add deadsnakes PPA - widely used for Python versions
+sudo add-apt-repository ppa:deadsnakes/ppa
+# update again & install python 3.11
+sudo apt update
+sudo apt install python3.11
+# Check if it was installed
+python3.11 --version 
+
+pip install sgx.py
+```
+--- 
+
+## Developers
+### Install all python libraries
+```bash
+sudo apt-get update --fix-missing
+sudo apt-get install libudev-dev
+sudo apt-get install swig
+
+# create virtual environment - install dependencies locally
+python3.11 -m venv venv
+source venv/bin/activate
+pip install -e .
+pip install -e .[dev]
+```
+
+### Running Tests
+
+Create a `.env` file in source directory, like the following:
+```bash
+# SGXWallet listening point (1026 uses https w/ certificates)
+SERVER=https://127.0.0.1:1026
+# path where you want tests to store the auto-generated certificates
+CERT_PATH=.
+# private key for the funded test account used by transaction tests
+ETH_PRIVATE_KEY=
+# Ethereum JSON-RPC endpoint used by transaction tests
+GETH=
+# 1 when sgxwallet runs with -e (ZMQ key ownership)
+SGX_EXPECT_ZMQ_OWNERSHIP=0
+```
+You may alter the fields as needed.
+
+Run the tests:
+```bash
+# Run all tests
+pytest
+
+# Run specific test file
+pytest ./tests/<test-file-name>.py
+
+```
+
+## Checking the wallet
+
+Available from sgxwallet 1.11.0. Older servers raise `SgxMethodNotFoundError`, a subclass of `SgxServerError`.
+
+### Client certificate
+
+```python
+from sgx import CertificateMatch, SgxClient
+
+client = SgxClient(endpoint, cert_dir, allow_registration=False)
+check = client.check_local_certificate(expected_number=1)
+if check.outcome is not CertificateMatch.MATCH:
+    print(check.outcome, check.newer_issued_at)
+```
+
+| `check.outcome` | Meaning |
+|---|---|
+| `MATCH` | `sgx.crt` is the newest certificate the wallet issued, and the wallet issued `expected_number` client certificates |
+| `UNEXPECTED_NUMBER` | `sgx.crt` is the newest, but the number of issued certificates differs |
+| `NOT_LATEST` | the wallet issued a newer certificate, at `check.newer_issued_at` |
+| `NOT_ISSUED` | unknown to the wallet's CA: wrong endpoint, or its CA database was recreated |
+
+`check.info` holds both counts and the newest certificate with its status: `V`, `R` or `E`. The check relies on the server verifying client certificates; otherwise `NOT_LATEST` can also mean a certificate from another CA.
+
+Unless `allow_registration=False` is passed, any request registers a new certificate when `sgx.crt` or `sgx.key` is missing, and the constructor makes such a request when the directory does not hold exactly three files. `check_local_certificate` never registers.
+
+### Server options
+
+```python
+options = client.get_server_options()
+options.effective.zmq_key_ownership_enforced  # -e is in effect; applies to ZMQ only
+```
+
+The server reports these values itself; they are not attested. `options.build` is `None` unless the server verifies the caller's certificate. While sgxwallet starts or stops, the call raises `SgxServerError`; retry.
+
+## License
+
+[![License](https://img.shields.io/github/license/skalenetwork/sgx.py.svg)](LICENSE)
+
+Copyright (C) 2019-present SKALE Labs

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/setup.py

@@ -22,7 +22,7 @@ extras_require['dev'] = extras_require['linter'] + extras_require['dev']
 
 setup(
     name='sgx.py',
-    version='0.12dev1',
+    version='0.12dev2',
     description='SGX',
     url='http://github.com/skalenetwork/sgx.py',
     author='SKALE Labs',

sgx_py-0.12.dev2/sgx/__init__.py

@@ -0,0 +1,5 @@
+# flake8: noqa: F401
+from sgx.certificates import CertificateMatch, IssuedCertificatesInfo, SgxCertificateError
+from sgx.options import LogLevel, ServerOptions, SgxServerOptionsError
+from sgx.sgx import SgxClient
+from sgx.sgx_rpc_handler import SgxMethodNotFoundError

sgx_py-0.12.dev2/sgx/certificates.py

@@ -0,0 +1,134 @@
+#    -*- coding: utf-8 -*-
+#
+#     This file is part of sgx.py
+#
+#     Copyright (C) 2026 SKALE Labs
+#
+#     sgx.py is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU Affero General Public License as published
+#     by the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     sgx.py is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU Affero General Public License for more details.
+#
+#     You should have received a copy of the GNU Affero General Public License
+#     along with sgx.py.  If not, see <https://www.gnu.org/licenses/>.
+
+import os
+import re
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from enum import Enum
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes
+
+from sgx.constants import CRT_FILENAME
+from sgx.utils import SgxError
+
+
+class SgxCertificateError(SgxError):
+    pass
+
+
+class CertificateMatch(Enum):
+    MATCH = 'match'  # the local certificate is the newest issued
+    UNEXPECTED_NUMBER = 'unexpected_number'  # as MATCH, but the count differs from the expected
+    NOT_LATEST = 'not_latest'  # a newer certificate was issued after it
+    NOT_ISSUED = 'not_issued'  # unknown to this wallet's CA database
+
+
+@dataclass(frozen=True)
+class NewestCertificate:
+    serial: int
+    sha256: bytes
+    not_before: datetime
+    not_after: datetime
+    status: str  # V valid, R revoked, E expired
+
+
+@dataclass(frozen=True)
+class IssuedCertificatesInfo:
+    """Client certificates issued by the wallet's CA, from getIssuedCertificatesInfo."""
+
+    certificates_number: int
+    server_certificates_number: int
+    newest_certificate: NewestCertificate | None
+
+    @classmethod
+    def from_result(cls, result):
+        """Parses a result in the format sgxwallet documents and rejects anything else."""
+        try:
+            number = _count(result['certificatesNumber'])
+            newest = result['newestCertificate']
+            # sgxwallet sends a newest certificate exactly when it has issued any
+            if (newest is None) != (number == 0):
+                raise ValueError('newestCertificate does not match certificatesNumber')
+            if newest is not None:
+                newest = NewestCertificate(
+                    serial=int(_text('[0-9A-F]+', newest['serial']), 16),
+                    sha256=bytes.fromhex(_text('[0-9a-f]{64}', newest['sha256'])),
+                    not_before=_utc(newest['notBefore']),
+                    not_after=_utc(newest['notAfter']),
+                    status=_text('[VRE]', newest['status']),
+                )
+            return cls(number, _count(result['serverCertificatesNumber']), newest)
+        except (KeyError, TypeError, ValueError) as err:
+            raise SgxCertificateError(
+                f'Malformed getIssuedCertificatesInfo result: {result!r}'
+            ) from err
+
+    def check(self, certificate, expected_number=None):
+        """Compares an x509.Certificate with the newest certificate the wallet issued. If the
+        server does not verify client certificates, NOT_LATEST may be another CA's certificate."""
+        newest = self.newest_certificate
+        if newest is not None and newest.sha256 == certificate.fingerprint(hashes.SHA256()):
+            if expected_number is None or expected_number == self.certificates_number:
+                outcome = CertificateMatch.MATCH
+            else:
+                outcome = CertificateMatch.UNEXPECTED_NUMBER
+        elif newest is not None and newest.serial > certificate.serial_number:
+            outcome = CertificateMatch.NOT_LATEST
+        else:
+            outcome = CertificateMatch.NOT_ISSUED
+        return CertificateCheck(outcome, self)
+
+
+@dataclass(frozen=True)
+class CertificateCheck:
+    outcome: CertificateMatch
+    info: IssuedCertificatesInfo
+
+    @property
+    def newer_issued_at(self):
+        if self.outcome is CertificateMatch.NOT_LATEST:
+            return self.info.newest_certificate.not_before
+        return None
+
+
+def load_local_certificate(cert_dir):
+    try:
+        with open(os.path.join(cert_dir, CRT_FILENAME), 'rb') as crt_file:
+            return x509.load_pem_x509_certificate(crt_file.read())
+    except (OSError, TypeError, ValueError) as err:  # TypeError: no cert_dir
+        raise SgxCertificateError(f'Cannot load {CRT_FILENAME} from {cert_dir!r}') from err
+
+
+def _count(value):
+    # Exact type, because bool is a subclass of int
+    if type(value) is not int or value < 0:
+        raise ValueError(f'Invalid count {value!r}')
+    return value
+
+
+def _text(pattern, value):
+    if not re.fullmatch(pattern, value):
+        raise ValueError(f'Invalid value {value!r}')
+    return value
+
+
+def _utc(value):
+    return datetime.strptime(value, '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=timezone.utc)

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/sgx/http.py

@@ -11,6 +11,7 @@ import requests
 import urllib3
 from requests.packages.urllib3.exceptions import InsecureRequestWarning
 
+from sgx.certificates import SgxCertificateError
 from sgx.constants import (
     CRT_FILENAME,
     CSR_FILENAME,
@@ -56,11 +57,15 @@ def enrollment_lock(crt_dir_path: str):
         os.close(fd)
 
 
-def get_certificate_credentials(crt_dir_path, csr_server):
+def get_certificate_credentials(crt_dir_path, csr_server, allow_registration=True):
     key_path = os.path.join(crt_dir_path, KEY_FILENAME)
     crt_path = os.path.join(crt_dir_path, CRT_FILENAME)
     if certificate_exists(crt_dir_path):
         return crt_path, key_path
+    if not allow_registration:
+        raise SgxCertificateError(
+            f'{crt_path} or {key_path} is missing and registration is disabled'
+        )
     with enrollment_lock(crt_dir_path):
         if not certificate_exists(crt_dir_path):
             csr_path = os.path.join(crt_dir_path, CSR_FILENAME)
@@ -104,7 +109,7 @@ def sign_certificate(csr_server, csr_path):
     return csr_hash
 
 
-def send_request(url, method, params, path_to_cert=None):
+def send_request(url, method, params, path_to_cert=None, allow_registration=True):
     headers = {'content-type': 'application/json'}
     call_data = {
         "id": 0,
@@ -117,7 +122,8 @@ def send_request(url, method, params, path_to_cert=None):
     if path_to_cert:
         cert = get_certificate_credentials(
             path_to_cert,
-            get_cert_provider(url)
+            get_cert_provider(url),
+            allow_registration
         )
 
     try:

sgx_py-0.12.dev2/sgx/options.py

@@ -0,0 +1,104 @@
+#    -*- coding: utf-8 -*-
+#
+#     This file is part of sgx.py
+#
+#     Copyright (C) 2026 SKALE Labs
+#
+#     sgx.py is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU Affero General Public License as published
+#     by the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     sgx.py is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU Affero General Public License for more details.
+#
+#     You should have received a copy of the GNU Affero General Public License
+#     along with sgx.py.  If not, see <https://www.gnu.org/licenses/>.
+
+from dataclasses import dataclass, fields
+from enum import IntEnum
+
+from sgx.utils import SgxError
+
+
+class SgxServerOptionsError(SgxError):
+    pass
+
+
+class LogLevel(IntEnum):
+    TRACE = 0
+    DEBUG = 1
+    INFO = 2
+    WARNING = 3
+    ERROR = 4
+
+
+@dataclass(frozen=True)
+class ServerFlags:
+    log_level: LogLevel
+    enclave_log_level: LogLevel
+    use_https: bool
+    autoconfirm: bool
+    enter_backup_key: bool
+    reencrypt_database_with_new_sek: bool
+    check_cert: bool
+    check_zmq_sig: bool
+    auto_sign: bool
+    generate_test_keys: bool
+    check_key_ownership: bool
+    thread_pool_size: int
+
+
+@dataclass(frozen=True)
+class EffectiveOptions:
+    rpc_port: int  # as bound inside the server, before any port mapping
+    rpc_client_certificate_required: bool
+    zmq_key_ownership_enforced: bool  # -e is in effect; applies to ZMQ only
+    json_rpc_key_ownership_enforced: bool
+    sgx_thread_pool_size: int
+
+
+@dataclass(frozen=True)
+class BuildInfo:
+    sgx_simulation: bool
+    sgx_debug_launch: bool
+
+
+@dataclass(frozen=True)
+class ServerOptions:
+    """Options sgxwallet reports about itself, from getServerOptions; they are not attested.
+    build is sent only to authenticated callers: HTTPS with the client certificate check."""
+
+    flags: ServerFlags
+    effective: EffectiveOptions
+    build: BuildInfo | None = None
+
+    @classmethod
+    def from_result(cls, result):
+        if not isinstance(result, dict):
+            raise SgxServerOptionsError(f'Malformed getServerOptions result: {result!r}')
+        build = result.get('build')
+        return cls(
+            _load(ServerFlags, result.get('flags')),
+            _load(EffectiveOptions, result.get('effective')),
+            None if build is None else _load(BuildInfo, build),
+        )
+
+
+def _load(cls, data):
+    # Fields match the camelCase keys ignoring case and underscores: use_https is useHTTPS
+    try:
+        values = {key.lower(): value for key, value in data.items()}
+        kwargs = {f.name: _typed(f.type, values[f.name.replace('_', '')]) for f in fields(cls)}
+    except (AttributeError, KeyError, TypeError, ValueError) as err:
+        raise SgxServerOptionsError(f'Malformed {cls.__name__}: {data!r}') from err
+    return cls(**kwargs)
+
+
+def _typed(kind, value):
+    # Exact types, because bool is a subclass of int
+    if type(value) is not (int if kind is LogLevel else kind):
+        raise TypeError(f'{value!r} is not {kind.__name__}')
+    return kind(value)

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/sgx/sgx.py

@@ -53,9 +53,11 @@ class ComplaintResponse:
 
 
 class SgxClient:
-    def __init__(self, sgx_endpoint, path_to_cert=None, n=None, t=None, zmq=False):
+    def __init__(
+        self, sgx_endpoint, path_to_cert=None, n=None, t=None, zmq=False, allow_registration=True
+    ):
         self.sgx_endpoint = sgx_endpoint
-        self.sgx_rpc_server = SgxRPCHandler(sgx_endpoint, path_to_cert)
+        self.sgx_rpc_server = SgxRPCHandler(sgx_endpoint, path_to_cert, allow_registration)
         if zmq:
             self.zmq = SgxZmq(sgx_endpoint, path_to_cert, n, t)
         if not path_to_cert:
@@ -151,6 +153,15 @@ class SgxClient:
     def get_server_version(self):
         return self.sgx_rpc_server.get_server_version()
 
+    def get_server_options(self):
+        return self.sgx_rpc_server.get_server_options()
+
+    def get_issued_certificates_info(self):
+        return self.sgx_rpc_server.get_issued_certificates_info()
+
+    def check_local_certificate(self, expected_number=None):
+        return self.sgx_rpc_server.check_local_certificate(expected_number)
+
     def verify_secret_share(self, public_shares, eth_key_name, secret_share, index):
         return self.sgx_rpc_server.verify_secret_share(
             public_shares, eth_key_name, secret_share, self.n, self.t, index

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/sgx/sgx_rpc_handler.py

@@ -21,16 +21,24 @@ import logging
 from enum import Enum
 from urllib.parse import urlparse
 
+from sgx.certificates import IssuedCertificatesInfo, load_local_certificate
 from sgx.http import certificate_exists, send_request
+from sgx.options import ServerOptions
 from sgx.utils import SgxError
 
 logger = logging.getLogger(__name__)
 
+METHOD_NOT_FOUND = -32601
+
 
 class SgxServerError(SgxError):
     pass
 
 
+class SgxMethodNotFoundError(SgxServerError):
+    """The server does not implement the method, e.g. an sgxwallet older than 1.10.4."""
+
+
 class DkgPolyStatus(Enum):
     FAIL = 0
     NEW_GENERATED = 1
@@ -38,10 +46,11 @@ class DkgPolyStatus(Enum):
 
 
 class SgxRPCHandler:
-    def __init__(self, sgx_endpoint, path_to_cert):
+    def __init__(self, sgx_endpoint, path_to_cert, allow_registration=True):
         self.sgx_endpoint = check_provider(sgx_endpoint)
         self.path_to_cert = path_to_cert
-        if path_to_cert and not certificate_exists(path_to_cert):
+        self.allow_registration = allow_registration
+        if allow_registration and path_to_cert and not certificate_exists(path_to_cert):
             self.get_server_status()
 
     def ecdsa_sign(self, key_name, transaction_hash):
@@ -130,6 +139,21 @@ class SgxRPCHandler:
         response = self.__send_request("getServerVersion")
         return response['result']['version']
 
+    def get_server_options(self):
+        response = self.__send_request('getServerOptions')
+        return ServerOptions.from_result(response['result'])
+
+    def get_issued_certificates_info(self):
+        response = self.__send_request('getIssuedCertificatesInfo')
+        return IssuedCertificatesInfo.from_result(response['result'])
+
+    def check_local_certificate(self, expected_number=None):
+        certificate = load_local_certificate(self.path_to_cert)
+        # Never registers: a new certificate would replace the one being checked
+        response = self.__send_request('getIssuedCertificatesInfo', allow_registration=False)
+        info = IssuedCertificatesInfo.from_result(response['result'])
+        return info.check(certificate, expected_number)
+
     def verify_secret_share(self, public_shares, eth_key_name, secret_share, n, t, index):
         params = dict()
         params['publicShares'] = public_shares
@@ -267,10 +291,14 @@ class SgxRPCHandler:
 
         return result
 
-    def __send_request(self, method, params=None):
-        response = send_request(self.sgx_endpoint, method, params, self.path_to_cert)
-        if response.get('error') is not None:
-            raise SgxServerError(response['error']['message'])
+    def __send_request(self, method, params=None, allow_registration=True):
+        registration = self.allow_registration and allow_registration
+        response = send_request(self.sgx_endpoint, method, params, self.path_to_cert, registration)
+        error = response.get('error')
+        if error is not None:
+            if error.get('code') == METHOD_NOT_FOUND:
+                raise SgxMethodNotFoundError(error['message'])
+            raise SgxServerError(error['message'])
         if response['result']['status']:
             raise SgxServerError(response['result']['errorMessage'])
         return response

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2/sgx.py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sgx.py
-Version: 0.12.dev1
+Version: 0.12.dev2
 Summary: SGX
 Home-page: http://github.com/skalenetwork/sgx.py
 Author: SKALE Labs

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/sgx.py.egg-info/SOURCES.txt

@@ -2,9 +2,11 @@ LICENSE
 README.md
 setup.py
 sgx/__init__.py
+sgx/certificates.py
 sgx/constants.py
 sgx/generate.sh
 sgx/http.py
+sgx/options.py
 sgx/sgx.py
 sgx/sgx_rpc_handler.py
 sgx/sgx_zmq.py

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/tests/test_core.py

@@ -11,13 +11,14 @@ from eth_keys import keys
 from hexbytes import HexBytes
 from web3 import Web3
 
-from sgx import SgxClient
+from sgx import CertificateMatch, SgxClient
 
 load_dotenv()
 
 SGX_URL = os.getenv('SERVER')
 GETH_URL = os.getenv('GETH')
 ETH_PRIVATE_KEY = os.getenv('ETH_PRIVATE_KEY')
+EXPECT_ZMQ_OWNERSHIP = os.getenv('SGX_EXPECT_ZMQ_OWNERSHIP') == '1'
 
 ETH_VALUE_FOR_TESTS = 5 * 10**18
 
@@ -147,6 +148,25 @@ def test_get_server_version(sgx):
     assert isinstance(sgx.get_server_version(), str)
 
 
+def test_get_server_options(sgx):
+    url = urllib.parse.urlparse(SGX_URL)
+    options = sgx.get_server_options()
+    assert options.effective.rpc_port == url.port
+    assert options.flags.use_https == (url.scheme == 'https')
+    assert options.flags.auto_sign and options.flags.autoconfirm
+    assert options.effective.zmq_key_ownership_enforced == EXPECT_ZMQ_OWNERSHIP
+    assert (options.build is not None) == options.effective.rpc_client_certificate_required
+    assert options.build is None or options.build.sgx_simulation
+
+
+def test_check_local_certificate(sgx):
+    # A fresh simulator, and every test shares CERT_PATH: one client certificate
+    check = sgx.check_local_certificate(expected_number=1)
+    assert check.outcome is CertificateMatch.MATCH
+    assert check.info.server_certificates_number == 1
+    assert check.info.newest_certificate.status == 'V'
+
+
 def test_sign_message(sgx, account, w3):
     key, address = account
     txn = generate_tx(w3, tx_type=None, no_fee=True)

{sgx_py-0.12.dev1 → sgx_py-0.12.dev2}/tests/test_http.py

@@ -1,3 +1,5 @@
+import logging
+
 import mock
 import pytest
 import requests
@@ -31,3 +33,13 @@ def test_send_request_failed_sgx_up():
     with mock.patch('requests.post', post_mock):
         with pytest.raises(SgxUnreachableError):
             send_request(URL, method, params)
+
+
+def test_send_request_logs_redacted_params(caplog):
+    response = mock.Mock(**{'json.return_value': {'result': {'status': 0}}})
+    with mock.patch('requests.post', return_value=response), caplog.at_level(logging.INFO):
+        send_request(URL, 'importBLSKeyShare', {'keyShare': 'a' * 64, 'keyShareName': 'b' * 64})
+    assert "'keyShare': '<redacted>'" in caplog.text
+    assert 'a' * 50 not in caplog.text
+    assert 'b' * 50 + '...' in caplog.text
+    assert 'b' * 51 not in caplog.text

sgx_py-0.12.dev1/README.md

@@ -1,75 +0,0 @@
-# sgx.py
-[![Discord](https://img.shields.io/discord/534485763354787851.svg)](https://discord.gg/vvUtWJB)
-
-## Requirements
-
-|**Tool**|**Minimum Supported Version**|
-|--------|-----------|
-| Python |    3.11    |
-
----
-
-## Installation
-
-### Install Python 3.11
-
-```bash
-# confirm prerequisites are isntalled
-sudo apt update
-sudo apt install software-properties-common
-# Add deadsnakes PPA - widely used for Python versions
-sudo add-apt-repository ppa:deadsnakes/ppa
-# update again & install python 3.11
-sudo apt update
-sudo apt install python3.11
-# Check if it was installed
-python3.11 --version 
-
-pip install sgx.py
-```
---- 
-
-## Developers
-### Install all python libraries
-```bash
-sudo apt-get update --fix-missing
-sudo apt-get install libudev-dev
-sudo apt-get install swig
-
-# create virtual environment - install dependencies locally
-python3.11 -m venv venv
-source venv/bin/activate
-pip install -e .
-pip install -e .[dev]
-```
-
-### Running Tests
-
-Create a `.env` file in source directory, like the following:
-```bash
-# SGXWallet listening point (1026 uses https w/ certificates)
-SERVER=https://127.0.0.1:1026
-# path where you want tests to store the auto-generated certificates
-CERT_PATH=.
-# private key for the funded test account used by transaction tests
-ETH_PRIVATE_KEY=
-# Ethereum JSON-RPC endpoint used by transaction tests
-GETH=
-```
-You may alter the fields as needed.
-
-Run the tests:
-```bash
-# Run all tests
-pytest
-
-# Run specific test file
-pytest ./tests/<test-file-name>.py
-
-```
-
-## License
-
-[![License](https://img.shields.io/github/license/skalenetwork/sgx.py.svg)](LICENSE)
-
-Copyright (C) 2019-present SKALE Labs

sgx_py-0.12.dev1/sgx/__init__.py

@@ -1,2 +0,0 @@
-# flake8: noqa: F401
-from sgx.sgx import SgxClient