Merge pull request #210 from InjectiveLabs/fix/remove_pysha3_dependency

Fix/remove pysha3 dependency

Author: aarmoa

Pipfile

@@ -4,26 +4,28 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
-protobuf = "*"
-grpcio-tools = "*"
-grpcio = "*"
-asyncio = "*"
+aiocron = "*"
 aiohttp = "*"
-ecdsa = "*"
+asyncio = "*"
 bech32 = "*"
-mnemonic = "*"
-hdwallets = "*"
 bip32 = "*"
-requests = "*"
-eip712_structs = "*"
 coincurve = "*"
-aiocron = "*"
-websockets = "*"
+ecdsa = "*"
+eip712 = "*"
+grpcio = "*"
+grpcio-tools = "*"
+hdwallets = "*"
+mnemonic = "*"
+protobuf = "*"
+requests = "*"
+safe-pysha3 = "*"
 urllib3 = "<2"
+websockets = "*"
 
 [dev-packages]
 pytest = "*"
 pytest-asyncio = "*"
+requests-mock = "*"
 
 [requires]
-python_version = "3.9"
+python_version = "3"

Pipfile.lock

@@ -87,6 +87,9 @@ make tests
 ```
 
 ### Changelogs
+**0.7**
+* Removed references to pysha3 library (and also eip712-struct that required it) and replaced it with other implementation to allow the project to work with Python 3.11
+
 **0.6.5**
 * Removed `k8s` from the list of supported mainnet nodes (`lb` should be used instead)
 

README.md

@@ -1,38 +1,48 @@
-import sha3
 import requests
 from decimal import Decimal
-from eip712_structs import make_domain, EIP712Struct, String
-
-class OrderInfo(EIP712Struct):
-    SubaccountId = String()
-    FeeRecipient = String()
-    Price = String()
-    Quantity = String()
-
-class SpotOrder(EIP712Struct):
-    MarketId = String()
-    OrderInfo = OrderInfo
-    Salt = String()
-    OrderType = String()
-    TriggerPrice = String()
-
-class DerivativeOrder(EIP712Struct):
-    MarketId = String()
-    OrderInfo = OrderInfo
-    OrderType = String()
-    Margin = String()
-    TriggerPrice = String()
-    Salt = String()
-
-EIP712_domain = make_domain(
-    name='Injective Protocol',
-    version='2.0.0',
-    chainId=888,
-    verifyingContract='0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
-    salt='0x0000000000000000000000000000000000000000000000000000000000000000'
-)
-
-domain_separator = EIP712_domain.hash_struct()
+
+from eip712.messages import EIP712Message, EIP712Type
+from eth_account.messages import _hash_eip191_message as hash_eip191_message
+from hexbytes import HexBytes
+
+
+class OrderInfo(EIP712Type):
+    SubaccountId: "string"
+    FeeRecipient: "string"
+    Price: "string"
+    Quantity: "string"
+
+
+class SpotOrder(EIP712Message):
+    _name_ = "Injective Protocol"
+    _version_ = "2.0.0"
+    _chainId_ = 888
+    _verifyingContract_ = "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
+    _salt_ = HexBytes("0x0000000000000000000000000000000000000000000000000000000000000000")
+
+    MarketId: "string"
+    OrderInfo: OrderInfo
+    Salt: "string"
+    OrderType: "string"
+    TriggerPrice: "string"
+
+
+class DerivativeOrder(EIP712Message):
+    _name_ = "Injective Protocol"
+    _version_ = "2.0.0"
+    _chainId_ = 888
+    _verifyingContract_ = "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
+    _salt_ = HexBytes("0x0000000000000000000000000000000000000000000000000000000000000000")
+
+    MarketId: "string"
+    OrderInfo: OrderInfo
+    OrderType: "string"
+    Margin: "string"
+    TriggerPrice: "string"
+    Salt: "string"
+
+
+# domain_separator = EIP712_domain.hash_struct()
 order_type_dict = {0: '\x00', 1: '\x01', 2: '\x02', 3: '\x03', 4: '\x04', 5: '\x05', 6: '\x06', 7: '\x07', 8: '\x08'}
 
 class OrderHashResponse:
@@ -127,8 +137,6 @@ def build_eip712_msg(order, nonce):
         )
 
 def hash_order(msg):
-    typed_data_hash = msg.hash_struct()
-    typed_bytes = b'\x19\x01' + domain_separator + typed_data_hash
-    keccak256 = sha3.keccak_256()
-    keccak256.update(typed_bytes)
-    return '0x' + keccak256.hexdigest()
+    signable_message = msg.signable_message
+    hex_digest = hash_eip191_message(signable_message=signable_message).hex()
+    return "0x" + hex_digest

pyinjective/orderhash.py

@@ -1,11 +1,10 @@
-import sys
 import sha3
 import hashlib
-import bech32
 import aiohttp
 import json
 import requests
 from typing import Tuple
+
 from bech32 import bech32_encode, bech32_decode, convertbits
 from bip32 import BIP32
 from ecdsa import SigningKey, VerifyingKey, SECP256k1, BadSignatureError
@@ -25,6 +24,7 @@
 
 DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/0"
 
+
 class PrivateKey:
     """
     Class for wrapping SigningKey that is used for signature creation and public key derivation.
@@ -99,9 +99,8 @@ def sign(self, msg: bytes) -> bytes:
 
         :return: a signature of this private key over the given message
         """
-        # return self.signing_key.sign_deterministic(msg, hashfunc=hashlib.sha256, sigencode=sigencode_string_canonize)
-        return self.signing_key.sign_deterministic(msg, hashfunc=sha3.keccak_256, sigencode=sigencode_string_canonize)
 
+        return self.signing_key.sign_deterministic(msg, hashfunc=sha3.keccak_256, sigencode=sigencode_string_canonize)
 
 class PublicKey:
     """
@@ -174,15 +173,10 @@ def to_cons_bech32(self) -> str:
 
     def to_address(self) -> "Address":
         """Return address instance from this public key"""
-        # pubkey = self.verify_key.to_string("compressed")
-        # s = hashlib.new("sha256", pubkey).digest()
-        # r = hashlib.new("ripemd160", s).digest()
-        # return Address(r)
-
         pubkey = self.verify_key.to_string("uncompressed")
-        k = sha3.keccak_256()
-        k.update(pubkey[1:])
-        addr = k.digest()[12:]
+        keccak_hash = sha3.keccak_256()
+        keccak_hash.update(pubkey[1:])
+        addr = keccak_hash.digest()[12:]
         return Address(addr)
 
     def verify(self, msg: bytes, sig: bytes) -> bool:

pyinjective/wallet.py

@@ -16,30 +16,33 @@
 URL = "https://github.com/InjectiveLabs/sdk-python"
 EMAIL = "[email protected]"
 AUTHOR = "Injective Labs"
-REQUIRES_PYTHON = ">=3.7, <3.11"
-VERSION = "0.6.5"
+REQUIRES_PYTHON = ">=3.9"
+VERSION = "0.7"
 
 REQUIRED = [
-    "protobuf",
-    "grpcio-tools",
-    "grpcio",
-    "asyncio",
     "aiohttp",
-    "ecdsa",
+    "aiocron",
+    "asyncio",
     "bech32",
-    "mnemonic",
-    "hdwallets",
     "bip32",
-    "requests",
-    "eip712_structs",
     "coincurve",
-    "aiocron",
-    "websockets"
+    "ecdsa",
+    "eip712",
+    "grpcio",
+    "grpcio-tools",
+    "hdwallets",
+    "mnemonic",
+    "protobuf",
+    "requests",
+    "safe-pysha3",
+    "urllib3",
+    "websockets",
 ]
 
 DEV_REQUIRED = [
     "pytest",
     "pytest-asyncio",
+    "request-mock",
 ]
 
 # The rest you shouldn't have to touch too much :)

setup.py

@@ -0,0 +1,59 @@
+from pyinjective import PrivateKey
+from pyinjective.composer import Composer
+from pyinjective.constant import Network
+from pyinjective.orderhash import OrderHashManager
+
+
+class TestOrderHashManager:
+
+    def test_spot_order_hash(self, requests_mock):
+        network = Network.devnet()
+        composer = Composer(network=network.string())
+        priv_key = PrivateKey.from_mnemonic("test one few words")
+        pub_key = priv_key.to_public_key()
+        address = pub_key.to_address()
+
+        subaccount_id = address.get_subaccount_id(index=0)
+
+        url = network.lcd_endpoint + "/injective/exchange/v1beta1/exchange/" + subaccount_id
+        requests_mock.get(url, json={"nonce": 0})
+        order_hash_manager = OrderHashManager(
+            address=address,
+            network=network,
+            subaccount_indexes=[0]
+        )
+
+        spot_market_id = "0xa508cb32923323679f29a032c70342c147c17d0145625922b0ef22e955c844c0"
+        fee_recipient = "inj1hkhdaj2a2clmq5jq6mspsggqs32vynpk228q3r"
+
+        spot_orders = [
+            composer.SpotOrder(
+                market_id=spot_market_id,
+                subaccount_id=subaccount_id,
+                fee_recipient=fee_recipient,
+                price=0.524,
+                quantity=0.01,
+                is_buy=True,
+                is_po=False
+            ),
+            composer.SpotOrder(
+                market_id=spot_market_id,
+                subaccount_id=subaccount_id,
+                fee_recipient=fee_recipient,
+                price=27.92,
+                quantity=0.01,
+                is_buy=False,
+                is_po=False
+            ),
+        ]
+
+        order_hashes_response = order_hash_manager.compute_order_hashes(
+            spot_orders=spot_orders,
+            derivative_orders=[],
+            subaccount_index=0
+        )
+
+        assert (len(order_hashes_response.spot) == 2)
+        assert (len(order_hashes_response.derivative) == 0)
+        assert (order_hashes_response.spot[0] == "0x6b1e4d1fb3012735dd5e386175eb4541c024e0d8dbfeb452767b973d70ae0924")
+        assert (order_hashes_response.spot[1] == "0xb36146f913955d989269732d167ec554e6d0d544411d82d7f86aef18350b252b")

tests/test_orderhash.py

@@ -0,0 +1,29 @@
+from eth_hash.auto import keccak
+
+from pyinjective import PrivateKey, Address
+
+
+class TestPrivateKey:
+
+    def test_private_key_signature_generation(self):
+        private_key = PrivateKey.from_mnemonic("test mnemonic never use other places")
+
+        signature = private_key.sign(msg="test message".encode())
+        expected_signature = b'\x8f\xae\xcb#z\x9a+\x12\x88\xea\xb5xZ"\x8f\x98y\xb8\x97\xa7F\xd5\xdd\x15s\x05;\x04\x1d\xbaY|rw\x8b\xbb\x19\xfc\x8e\x15\x8b\xf1\x18\x08\xba\xc7\x15\xed\xb0\xee\x95\x0e|Ch\x7f\xaf\x9cH\xc6\x9f\xbf\x14\xa5'
+
+        assert (expected_signature == signature)
+
+
+class TestPublicKey:
+
+    def test_convert_public_key_to_address(self):
+        private_key = PrivateKey.from_mnemonic("test mnemonic never use other places")
+        public_key = private_key.to_public_key()
+        address = public_key.to_address()
+
+        key = public_key.verify_key.to_string("uncompressed")
+        hashed_value = keccak(key[1:])
+        expected_address = Address(hashed_value[12:])
+
+        assert (expected_address == address)
+