sgx.py 0.9.dev5__tar.gz → 0.9.dev6__tar.gz

{sgx.py-0.9.dev5/sgx.py.egg-info → sgx.py-0.9.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgx.py
-Version: 0.9.dev5
+Version: 0.9.dev6
 Summary: SGX
 Home-page: http://github.com/skalenetwork/sgx.py
 Author: SKALE Labs

sgx.py-0.9.dev6/setup.py

@@ -0,0 +1,39 @@
+from setuptools import (
+    find_packages,
+    setup,
+)
+
+extras_require = {
+    'linter': [
+        'flake8==3.8.3',
+    ],
+    'dev': [
+        'coincurve==13.0.0',
+        'python-dotenv==0.13.0',
+        'twine==3.1.1',
+        'pytest==7.3.1',
+        'mock==4.0.2',
+    ],
+}
+
+extras_require['dev'] = extras_require['linter'] + extras_require['dev']
+
+setup(
+    name='sgx.py',
+    version='0.9dev6',
+    description='SGX',
+    url='http://github.com/skalenetwork/sgx.py',
+    author='SKALE Labs',
+    author_email='support@skalelabs.com',
+    install_requires=[
+        'web3>=6.20.2,<8.0.0',
+        'pyzmq==25.0.2',
+        'pem==21.2.0',
+        'M2Crypto>=0.40.1,<1.0.0',
+        'urllib3==1.26.0',
+    ],
+    packages=find_packages(exclude=['tests']),
+    python_requires='>=3.7,<4',
+    extras_require=extras_require,
+    package_data={'sgx': ['generate.sh']},
+)

{sgx.py-0.9.dev5 → sgx.py-0.9.dev6}/sgx/sgx.py

@@ -29,7 +29,7 @@ from sgx.sgx_zmq import SgxZmq
 from sgx.utils import public_key_to_address
 from eth_account._utils import signing
 from eth_account._utils.legacy_transactions import encode_transaction
-from eth_account._utils.typed_transactions import TypedTransaction
+from eth_account.typed_transactions.typed_transaction import TypedTransaction
 from eth_utils.encoding import big_endian_to_int
 from eth_utils.conversions import add_0x_prefix, remove_0x_prefix
 
@@ -67,25 +67,17 @@ class SgxClient:
         key_name, public_key = self.sgx_rpc_server.generate_key()
         public_key = add_0x_prefix(public_key)
         address = public_key_to_address(public_key)
-        return Account(
-            name=key_name,
-            address=address,
-            public_key=public_key
-        )
+        return Account(name=key_name, address=address, public_key=public_key)
 
     def get_account(self, key_name):
         key = self.sgx_rpc_server.get_public_key(key_name)
         key = add_0x_prefix(key)
         address = public_key_to_address(key)
-        return Account(
-            name=key_name,
-            address=address,
-            public_key=key
-        )
+        return Account(name=key_name, address=address, public_key=key)
 
     def sign(self, transaction_dict, key_name):
         if not isinstance(transaction_dict, Mapping):
-            raise TypeError("transaction_dict must be dict-like, got %r" % transaction_dict)
+            raise TypeError('transaction_dict must be dict-like, got %r' % transaction_dict)
 
         address = self.get_account(key_name).address
 
@@ -94,10 +86,13 @@ class SgxClient:
             if transaction_dict['from'] == address:
                 sanitized_transaction = dissoc(transaction_dict, 'from')
             else:
-                raise TypeError("from field must match key's %s, but it was %s" % (
-                    address,
-                    transaction_dict['from'],
-                ))
+                raise TypeError(
+                    "from field must match key's %s, but it was %s"
+                    % (
+                        address,
+                        transaction_dict['from'],
+                    )
+                )
         else:
             sanitized_transaction = transaction_dict
 
@@ -111,31 +106,18 @@ class SgxClient:
 
         transaction_hash = keccak(rlp_encoded)
         return SignedTransaction(
-            rawTransaction=HexBytes(rlp_encoded),
-            hash=HexBytes(transaction_hash),
-            r=r,
-            s=s,
-            v=v
+            raw_transaction=HexBytes(rlp_encoded), hash=HexBytes(transaction_hash), r=r, s=s, v=v
         )
 
     def sign_hash(self, message, key_name, chain_id):
         msg_hash_bytes = HexBytes(message)
         if len(msg_hash_bytes) != 32:
-            raise ValueError("The message hash must be exactly 32-bytes")
+            raise ValueError('The message hash must be exactly 32-bytes')
 
-        (v, r, s) = self._sign_hash(
-            key_name,
-            msg_hash_bytes,
-            chain_id,
-            eip_1559_identifier=False
-        )
+        (v, r, s) = self._sign_hash(key_name, msg_hash_bytes, chain_id, eip_1559_identifier=False)
         signature_bytes = signing.to_bytes32(r) + signing.to_bytes32(s) + signing.to_bytes(v)
         return SignedMessage(
-            messageHash=msg_hash_bytes,
-            r=r,
-            s=s,
-            v=v,
-            signature=HexBytes(signature_bytes)
+            message_hash=msg_hash_bytes, r=r, s=s, v=v, signature=HexBytes(signature_bytes)
         )
 
     def generate_dkg_poly(self, poly_name):
@@ -164,39 +146,23 @@ class SgxClient:
 
     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)
+            public_shares, eth_key_name, secret_share, self.n, self.t, index
+        )
 
     def verify_secret_share_v2(self, public_shares, eth_key_name, secret_share, index):
         return self.sgx_rpc_server.verify_secret_share_v2(
-            public_shares,
-            eth_key_name,
-            secret_share,
-            self.n,
-            self.t,
-            index)
+            public_shares, eth_key_name, secret_share, self.n, self.t, index
+        )
 
     def create_bls_private_key(self, poly_name, bls_key_name, eth_key_name, secret_shares):
         return self.sgx_rpc_server.create_bls_private_key(
-            poly_name,
-            bls_key_name,
-            eth_key_name,
-            secret_shares,
-            self.n,
-            self.t)
+            poly_name, bls_key_name, eth_key_name, secret_shares, self.n, self.t
+        )
 
     def create_bls_private_key_v2(self, poly_name, bls_key_name, eth_key_name, secret_shares):
         return self.sgx_rpc_server.create_bls_private_key_v2(
-            poly_name,
-            bls_key_name,
-            eth_key_name,
-            secret_shares,
-            self.n,
-            self.t)
+            poly_name, bls_key_name, eth_key_name, secret_shares, self.n, self.t
+        )
 
     def get_bls_public_key(self, bls_key_name):
         return self.sgx_rpc_server.get_bls_public_key(bls_key_name)
@@ -206,9 +172,7 @@ class SgxClient:
             poly_name, self.n, self.t, idx
         )
         return ComplaintResponse(
-            share=share,
-            dh_key=dh_key,
-            verification_vector_mult=verification_vector_mult
+            share=share, dh_key=dh_key, verification_vector_mult=verification_vector_mult
         )
 
     def mult_g2(self, to_mult):
@@ -236,9 +200,7 @@ class SgxClient:
 
     def _sign_transaction_dict(self, eth_key, transaction_dict):
         # generate RLP-serializable transaction, with defaults filled
-        unsigned_tx = signing.serializable_unsigned_transaction_from_dict(
-            transaction_dict
-        )
+        unsigned_tx = signing.serializable_unsigned_transaction_from_dict(transaction_dict)
 
         transaction_hash = unsigned_tx.hash()
 
@@ -249,27 +211,14 @@ class SgxClient:
         if isinstance(unsigned_tx, TypedTransaction):
             eip_1559_identifier = True
 
-        (v, r, s) = self._sign_hash(
-            eth_key,
-            transaction_hash,
-            chain_id,
-            eip_1559_identifier
-        )
+        (v, r, s) = self._sign_hash(eth_key, transaction_hash, chain_id, eip_1559_identifier)
 
         # serialize transaction with rlp
-        encoded_tx = encode_transaction(
-            unsigned_tx,
-            vrs=(v, r, s))
+        encoded_tx = encode_transaction(unsigned_tx, vrs=(v, r, s))
 
         return v, r, s, encoded_tx
 
-    def _sign_hash(
-        self,
-        eth_key,
-        transaction_hash,
-        chain_id,
-        eip_1559_identifier=False
-    ):
+    def _sign_hash(self, eth_key, transaction_hash, chain_id, eip_1559_identifier=False):
         hash_in_hex = hex(big_endian_to_int(transaction_hash))
         (v_raw, r_raw, s_raw) = self.sgx_rpc_server.ecdsa_sign(eth_key, hash_in_hex)
         if eip_1559_identifier:

{sgx.py-0.9.dev5 → sgx.py-0.9.dev6/sgx.py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgx.py
-Version: 0.9.dev5
+Version: 0.9.dev6
 Summary: SGX
 Home-page: http://github.com/skalenetwork/sgx.py
 Author: SKALE Labs

{sgx.py-0.9.dev5 → sgx.py-0.9.dev6}/sgx.py.egg-info/requires.txt

@@ -1,7 +1,7 @@
-web3==6.20.2
+web3<8.0.0,>=6.20.2
 pyzmq==25.0.2
 pem==21.2.0
-M2Crypto==0.40.1
+M2Crypto<1.0.0,>=0.40.1
 urllib3==1.26.0
 
 [dev]

{sgx.py-0.9.dev5 → sgx.py-0.9.dev6}/tests/test_core.py

@@ -23,7 +23,7 @@ SGX_URL = os.getenv('SERVER')
 GETH_URL = os.getenv('GETH')
 ETH_PRIVATE_KEY = os.getenv('ETH_PRIVATE_KEY')
 
-ETH_VALUE_FOR_TESTS = 5 * 10 ** 18
+ETH_VALUE_FOR_TESTS = 5 * 10**18
 
 
 def private_key_to_public(pr):
@@ -55,13 +55,13 @@ def send_eth_w3(web3, to, value):
         'to': to,
         'value': value,
         'gas': 21000,
-        'maxFeePerGas': 10 ** 9,
+        'maxFeePerGas': 10**9,
         'maxPriorityFeePerGas': 10,
         'nonce': nonce,
-        'chainId': web3.eth.chain_id
+        'chainId': web3.eth.chain_id,
     }
     signed = web3.eth.account.sign_transaction(tx, private_key=ETH_PRIVATE_KEY)
-    tx_hash = web3.eth.send_raw_transaction(signed.rawTransaction)
+    tx_hash = web3.eth.send_raw_transaction(signed.raw_transaction)
     web3.eth.wait_for_transaction_receipt(tx_hash)
 
 
@@ -86,16 +86,13 @@ def generate_tx(web3, tx_type=None, no_fee=False):
         'value': 0,
         'gas': 200000,
         'gasPrice': web3.eth.gas_price,
-        'chainId': web3.eth.chain_id
+        'chainId': web3.eth.chain_id,
     }
     if tx_type:
         txn['type'] = tx_type
         if tx_type == 2:
             txn.pop('gasPrice', None)
-            txn.update({
-                'maxFeePerGas': 10 ** 9,
-                'maxPriorityFeePerGas': 10
-            })
+            txn.update({'maxFeePerGas': 10**9, 'maxPriorityFeePerGas': 10})
 
     return txn
 
@@ -111,7 +108,7 @@ def test_sign_and_send(sgx, account, w3):
     txn = generate_tx(w3)
     txn['nonce'] = w3.eth.get_transaction_count(address)
     signed_txn = sgx.sign(txn, key)
-    tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
+    tx_hash = w3.eth.send_raw_transaction(signed_txn.raw_transaction)
     w3.eth.wait_for_transaction_receipt(tx_hash)
     assert isinstance(tx_hash, HexBytes)
     assert tx_hash != HexBytes('0x')
@@ -119,7 +116,7 @@ def test_sign_and_send(sgx, account, w3):
     txn_v1 = generate_tx(w3, 1)
     txn_v1['nonce'] = w3.eth.get_transaction_count(address)
     signed_txn = sgx.sign(txn_v1, key)
-    tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
+    tx_hash = w3.eth.send_raw_transaction(signed_txn.raw_transaction)
     w3.eth.wait_for_transaction_receipt(tx_hash)
     assert isinstance(tx_hash, HexBytes)
     assert tx_hash != HexBytes('0x')
@@ -130,14 +127,14 @@ def test_sign_and_send_second_type(sgx, account, w3):
     txn_v2 = generate_tx(w3, 2)
     txn_v2['nonce'] = w3.eth.get_transaction_count(address)
     signed_txn = sgx.sign(txn_v2, key)
-    tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
+    tx_hash = w3.eth.send_raw_transaction(signed_txn.raw_transaction)
     assert isinstance(tx_hash, HexBytes)
     assert tx_hash != HexBytes('0x')
 
 
 def test_get_info(sgx):
     generated_key = sgx.generate_key()
-    assert generated_key.name and generated_key.name[:3] == "NEK"
+    assert generated_key.name and generated_key.name[:3] == 'NEK'
     assert generated_key.address and len(generated_key.address) == 42
     assert generated_key.public_key and len(generated_key.public_key) == 130
     key = generated_key.name
@@ -164,25 +161,23 @@ def test_sign_message(sgx, account, w3):
 
     message = defunct_hash_message(transaction_hash).hex()
     signed_message = sgx.sign_hash(message, key, None)
-    assert signed_message.messageHash == HexBytes(message)
+    assert signed_message.message_hash == HexBytes(message)
     assert len(signed_message.signature) > 2
     assert type(signed_message.signature) == HexBytes
 
     recover_account = w3.eth.account.recover_message(
-        encode_defunct(transaction_hash),
-        signature=signed_message.signature
+        encode_defunct(transaction_hash), signature=signed_message.signature
     )
 
     assert recover_account == address
 
 
 def test_import_ecdsa(sgx, w3):
-
     random_key_name = secrets.token_hex(32)
 
-    ecdsa_key_name = "NEK:" + random_key_name
+    ecdsa_key_name = 'NEK:' + random_key_name
 
-    insecure_ecdsa_private_key = "f253bad7b1f62b8ff60bbf451cf2e8e9ebb5d6e9bff450c55b8d5504b8c63d3"
+    insecure_ecdsa_private_key = 'f253bad7b1f62b8ff60bbf451cf2e8e9ebb5d6e9bff450c55b8d5504b8c63d3'
 
     public_key = sgx.import_ecdsa_private_key(ecdsa_key_name, insecure_ecdsa_private_key)
 
@@ -201,12 +196,11 @@ def test_import_ecdsa(sgx, w3):
     message = defunct_hash_message(transaction_hash).hex()
 
     signed_message = sgx.sign_hash(message, ecdsa_key_name, None)
-    assert signed_message.messageHash == HexBytes(message)
+    assert signed_message.message_hash == HexBytes(message)
     assert len(signed_message.signature) > 2
     assert type(signed_message.signature) == HexBytes
 
     recover_account = w3.eth.account.recover_message(
-        encode_defunct(transaction_hash),
-        signature=signed_message.signature
+        encode_defunct(transaction_hash), signature=signed_message.signature
     )
     assert recover_account == account

sgx.py-0.9.dev5/setup.py

@@ -1,43 +0,0 @@
-from setuptools import (
-    find_packages,
-    setup,
-)
-
-extras_require = {
-    'linter': [
-        "flake8==3.8.3",
-    ],
-    'dev': [
-        "coincurve==13.0.0",
-        "python-dotenv==0.13.0",
-        "twine==3.1.1",
-        "pytest==7.3.1",
-        "mock==4.0.2"
-    ]
-}
-
-extras_require['dev'] = (
-    extras_require['linter'] + extras_require['dev']
-)
-
-setup(
-    name='sgx.py',
-    version='0.9dev5',
-    description='SGX',
-    url='http://github.com/skalenetwork/sgx.py',
-    author='SKALE Labs',
-    author_email='support@skalelabs.com',
-    install_requires=[
-      'web3==6.20.2',
-      'pyzmq==25.0.2',
-      'pem==21.2.0',
-      'M2Crypto==0.40.1',
-      'urllib3==1.26.0'
-    ],
-    packages=find_packages(exclude=['tests']),
-    python_requires='>=3.7,<4',
-    extras_require=extras_require,
-    package_data={
-        'sgx': ['generate.sh']
-    }
-)