py-near 1.1.50__tar.gz → 1.1.51__tar.gz

{py_near-1.1.50 → py_near-1.1.51}/PKG-INFO

@@ -1,20 +1,24 @@
 Metadata-Version: 2.1
 Name: py-near
-Version: 1.1.50
+Version: 1.1.51
 Summary: Pretty simple and fully asynchronous framework for working with NEAR blockchain
 Author: pvolnov
 Author-email: petr@herewallet.app
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8,<3.12
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: ed25519 (==1.5)
+Requires-Dist: base58 (>=2.1.1,<3.0.0)
+Requires-Dist: eth-keys (>=0.6.1,<0.7.0)
+Requires-Dist: eth-utils (>=5.2.0,<6.0.0)
+Requires-Dist: frozenlist (>=1.4.1,<2.0.0)
 Requires-Dist: httpx (==0.26.0)
+Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: py-near-primitives (==0.2.3)
+Requires-Dist: pydantic (>=2.6.2,<3.0.0)
+Requires-Dist: pynacl (>=1.5.0,<2.0.0)
 Description-Content-Type: text/markdown
 
 # py-near

{py_near-1.1.50 → py_near-1.1.51}/pyproject.toml

@@ -1,33 +1,38 @@
 [tool.poetry]
 name = "py-near"
-version = "1.1.50"
+version = "1.1.51"
 description="Pretty simple and fully asynchronous framework for working with NEAR blockchain"
 authors = ["pvolnov <petr@herewallet.app>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = "^3.7"
-ed25519 = "1.5"
+base58 = "^2.1.1"
+python = ">=3.8,<3.12"
 httpx = "0.26.0"
 py-near-primitives = "0.2.3"
+frozenlist = "^1.4.1"
+pynacl = "^1.5.0"
+loguru = "^0.7.2"
+pydantic = "^2.6.2"
+eth-utils = "^5.2.0"
+eth-keys = "^0.6.1"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 black = "^21.12b0"
 mypy = "^0.930"
-pytest = "^6.2.5"
+pytest = ">=7.0,<8.0"
 flake8 = "^4.0.1"
 Sphinx = "^4.3.2"
 sphinx-rtd-theme = "^1.0.0"
-base58 = "^2.1.1"
+pytest-asyncio = "^0.23.5"
 
 [project]
 name = "py-near"
 version = "1.1.50"
-description = "Pretty simple and fully asynchronous framework for working with NEAR blockchaink"
+description = "Pretty simple and fully asynchronous framework for working with NEAR blockchain"
 authors = [ {name = "pvolnov", email = "petr@herewallet.app"} ]
-requires-python = ">=3.7"
 license = {file = "LICENSE"}
-dependencies=["base58", "ed25519", "httpx", "py-near-primitives", "pydantic"]
+
 keywords = ["python", "near", "async"]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -53,4 +58,11 @@ documentation = "https://py-near.readthedocs.io/en/latest"
 repository = "https://github.com/pvolnov/py-near"
 changelog = "https://github.com/pvolnov/py-near/blob/main/CHANGELOG.md"
 funding = "https://opencollective.com/py-near"
-twitter = "https://twitter.com/p_volnov"
+twitter = "https://twitter.com/p_volnov"
+
+[tool.pytest.ini_options]
+addopts = "--capture=no --tb=native"
+testpaths = [
+    "tests",
+]
+asyncio_mode = "auto"

{py_near-1.1.50 → py_near-1.1.51}/src/py_near/account.py

@@ -13,7 +13,7 @@ else:
     from collections import MutableSet
 
 import base58
-import ed25519
+from nacl import signing, encoding
 from loguru import logger
 from py_near_primitives import DelegateAction
 
@@ -85,10 +85,8 @@ class Account(object):
                 except UnicodeEncodeError:
                     logger.error(f"Can't decode private key {pk[:10]}")
                     continue
-            private_key = ed25519.SigningKey(pk)
-            public_key = base58.b58encode(
-                private_key.get_verifying_key().to_bytes()
-            ).decode("utf-8")
+            private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
+            public_key = private_key.verify_key
             self._signer_by_pk[public_key] = pk
             self._free_signers.put_nowait(pk)
             self._signers.append(pk)
@@ -206,11 +204,12 @@ class Account(object):
         if pk is None:
             pk = self._signers[0]
 
-        private_key = ed25519.SigningKey(pk)
-        public_key = private_key.get_verifying_key()
+        private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
+        public_key = private_key.verify_key
+        public_key.to_curve25519_public_key()
 
         resp = await self._provider.get_access_key(
-            self.account_id, base58.b58encode(public_key.to_bytes()).decode("utf8")
+            self.account_id, base58.b58encode(public_key.encode()).decode("utf8")
         )
         if "error" in resp:
             raise ValueError(resp["error"])
@@ -449,8 +448,8 @@ class Account(object):
         access_key = await self.get_access_key(pk)
         await self._update_last_block_hash()
 
-        private_key = ed25519.SigningKey(pk)
-        verifying_key = private_key.get_verifying_key()
+        private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
+        verifying_key = private_key.verify_key
         return DelegateActionModel(
             sender_id=self.account_id,
             receiver_id=receiver_id,
@@ -479,7 +478,7 @@ class Account(object):
         if public_key not in self._signer_by_pk:
             raise ValueError(f"Public key {public_key} not found in signer list")
 
-        private_key = ed25519.SigningKey(self._signer_by_pk[public_key])
+        private_key = signing.SigningKey(self._signer_by_pk[public_key], encoder=encoding.RawEncoder)
         sign = private_key.sign(nep461_hash)
         return base58.b58encode(sign).decode("utf-8")
 

py_near-1.1.51/src/py_near/mpc/auth/auth_2fa.py

@@ -0,0 +1,97 @@
+import datetime
+from hashlib import sha256
+from typing import Optional
+
+import base58
+from nacl import signing
+from pydantic import BaseModel
+
+from py_near.account import Account
+from py_near.mpc.auth.base import AuthContract
+
+
+class Wallet2FA(BaseModel):
+    wallet_id: str
+    public_key: str
+    delay_to_remove: int
+    cancellation_at: int
+    conditions: Optional[str] = None
+
+    @classmethod
+    def build(cls, data: dict, wallet_id):
+        return cls(
+            wallet_id=wallet_id,
+            public_key=data["public_key"],
+            cancellation_at=data["cancellation_at"],
+            delay_to_remove=data["delay_to_remove"],
+            conditions=data.get("conditions"),
+        )
+
+
+class AuthContract2FA(AuthContract):
+    root_pk: signing.SigningKey
+    contract_id: str = "2fa.auth.hot.tg"
+
+    def __init__(self, root_pk: signing.SigningKey, near_account: Account = None):
+        self.root_pk = root_pk
+        self.near_account = near_account
+        super().__init__()
+
+    def generate_user_payload(self, msg_hash: bytes):
+        auth_signature = base58.b58encode(self.root_pk.sign(msg_hash).signature).decode(
+            "utf-8"
+        )
+        return auth_signature
+
+    async def get_2fa_for_wallet(self, wallet_id: str) -> Optional[Wallet2FA]:
+        if not self.near_account:
+            raise ValueError("Near account is required")
+        res = (
+            await self.near_account.view_function(
+                self.contract_id,
+                "get_wallet_2fa",
+                {
+                    "wallet_id": wallet_id,
+                },
+            )
+        ).result
+        if res:
+            return Wallet2FA.build(res, wallet_id)
+
+    async def cancel_2fa(
+        self, user_pk: signing.SigningKey, wallet_id: str, rule_id: int = 0
+    ):
+        if not self.near_account:
+            raise ValueError("Near account is required")
+        two_fa = await self.get_2fa_for_wallet(wallet_id)
+        ts = int(datetime.datetime.utcnow().timestamp() * 10**9)
+
+        if two_fa.cancellation_at == 0:
+            msg_hash = sha256(f"CANCEL_2FA:{wallet_id}:{ts}".encode("utf-8")).digest()
+            auth_signature = base58.b58encode(user_pk.sign(msg_hash).signature).decode(
+                "utf-8"
+            )
+            return await self.near_account.function_call(
+                self.contract_id,
+                "cancel_2fa",
+                {
+                    "wallet_id": wallet_id,
+                    "user_signature": auth_signature,
+                    "timestamp": ts,
+                },
+                included=True,
+            )
+        else:
+            if two_fa.cancellation_at < ts:
+                raise ValueError(
+                    f"2FA already cancelled at {datetime.datetime.fromtimestamp(two_fa.cancellation_at / 10**9)}"
+                )
+            return await self.near_account.function_call(
+                self.contract_id,
+                "complete_cancel_2fa",
+                {
+                    "wallet_id": wallet_id,
+                    "rule_id": rule_id,
+                },
+                included=True,
+            )

py_near-1.1.51/src/py_near/mpc/auth/base.py

@@ -0,0 +1,23 @@
+from py_near.account import Account
+from py_near.mpc.models import WalletAccessModel
+
+
+class AuthContract:
+    contract_id: str
+
+    def __init__(self, near_account: Account = None):
+        self.near_account = near_account
+
+    async def grant_access(
+        self,
+        wallet_id: str,
+        access: WalletAccessModel,
+        near_account,
+        wallet_auth_method=0,
+    ):
+        raise NotImplementedError("Grant access is not implemented")
+
+    async def revoke_assess(
+        self, wallet_id: str, near_account: Account, access_id: int
+    ):
+        raise NotImplementedError("Revoke access is not implemented")

py_near-1.1.51/src/py_near/mpc/auth/default_auth.py

@@ -0,0 +1,29 @@
+import json
+
+import base58
+from nacl import signing
+
+from py_near.mpc.auth.base import AuthContract
+
+
+class DefaultAuthContract(AuthContract):
+    root_pk: signing.SigningKey
+    contract_id: str = "default.auth.hot.tg"
+
+    def __init__(self, root_pk: signing.SigningKey):
+        self.root_pk = root_pk
+        super().__init__()
+
+    def generate_user_payload(self, msg_hash: bytes):
+        auth_signature = base58.b58encode(self.root_pk.sign(msg_hash).signature).decode(
+            "utf-8"
+        )
+        return json.dumps(
+            dict(
+                signature=auth_signature,
+                public_key=base58.b58encode(
+                    bytes(self.root_pk.verify_key.encode())
+                ).decode(),
+            )
+        )
+

py_near-1.1.51/src/py_near/mpc/auth/keys_auth.py

@@ -0,0 +1,83 @@
+import json
+from hashlib import sha256
+from typing import List
+
+import base58
+from nacl import signing
+
+from py_near.account import Account
+from py_near.mpc.auth.base import AuthContract
+from py_near.mpc.models import WalletAccessModel
+
+
+class KeysAuthContract(AuthContract):
+    auth_keys: List[signing.SigningKey]
+    auth_method: int
+    contract_id: str = "keys.auth.hot.tg"
+
+    def __init__(
+        self,
+        auth_keys: List[signing.SigningKey],
+        auth_method=0,
+        near_account: Account = None,
+    ):
+        self.auth_keys = auth_keys
+        self.auth_method = auth_method
+        super().__init__(near_account)
+
+    def generate_user_payload(self, msg_hash: bytes):
+        signatures = []
+        for key in self.auth_keys:
+            signatures.append(
+                base58.b58encode(key.sign(msg_hash).signature).decode("utf-8")
+            )
+        return json.dumps(
+            dict(
+                signatures=signatures,
+                auth_method=0,
+            )
+        )
+
+    async def grant_access(
+        self,
+        wallet_id: str,
+        access: WalletAccessModel,
+        near_account,
+        wallet_auth_method=0,
+    ):
+        access = access.model_dump()
+        proof_hash = sha256(
+            f"{json.dumps(access).replace(' ', '')}.{wallet_id}".encode("utf-8")
+        ).digest()
+        signatures = []
+        for pk in self.auth_keys:
+            signature = base58.b58encode(pk.sign(proof_hash).signature).decode("utf-8")
+            signatures.append(signature)
+
+        res = await near_account.function_call(
+            self.contract_id,
+            "add_wallet_auth_account_id",
+            {
+                "wallet_id": wallet_id,
+                "access": access,
+                "signatures": signatures,
+                "wallet_auth_method": wallet_auth_method,
+                "auth_method": self.auth_method,
+            },
+            included=True,
+        )
+        return res
+
+    async def get_rules(self, wallet_id: str):
+        if not self.near_account:
+            raise ValueError("Near account is required")
+        res = (
+            await self.near_account.view_function(
+                self.contract_id,
+                "get_wallet",
+                {
+                    "wallet_id": wallet_id,
+                },
+            )
+        ).result
+        return res

py_near-1.1.51/src/py_near/mpc/models.py

@@ -0,0 +1,32 @@
+from enum import Enum
+from typing import Optional, List
+
+from pydantic import BaseModel
+
+
+class CurveType(int, Enum):
+    SECP256K1 = 0
+    ED25519 = 1
+
+
+_WALLET_REGISTER = "mpc.hot.tg"
+
+
+class WalletAccessModel(BaseModel):
+    account_id: str
+    metadata: Optional[str] = None
+    chain_id: int
+    msg: Optional[str] = None
+
+
+class WalletModel(BaseModel):
+    access_list: List[WalletAccessModel]
+    key_gen: int = 0
+
+    @classmethod
+    def build(cls, data: dict):
+        return cls(
+            access_list=[WalletAccessModel(**x) for x in data["access_list"]],
+            block_height=data["block_height"],
+            key_gen=data["key_gen"],
+        )

py_near-1.1.51/src/py_near/mpc/wallet.py

@@ -0,0 +1,237 @@
+from hashlib import sha256
+from typing import List, Optional
+
+import base58
+import httpx
+from eth_keys.datatypes import Signature
+from eth_keys.exceptions import BadSignature
+from eth_utils import keccak
+from loguru import logger
+from nacl import encoding, signing
+
+from py_near.account import Account
+from py_near.mpc.auth.auth_2fa import AuthContract2FA
+from py_near.mpc.auth.base import AuthContract
+from py_near.mpc.auth.default_auth import DefaultAuthContract
+from py_near.mpc.auth.keys_auth import KeysAuthContract
+from py_near.mpc.models import WalletAccessModel, WalletModel, CurveType
+
+_WALLET_REGISTER = "mpc.hot.tg"
+
+AUTH_CLASS = {
+    "default.auth.hot.tg": DefaultAuthContract,
+    "keys.auth.hot.tg": KeysAuthContract,
+    "2fa.auth.hot.tg": AuthContract2FA,
+}
+
+
+class MPCWallet:
+    derive: bytes
+    near_account: Account
+    hot_rpc: str
+
+    def __init__(
+        self,
+        near_account: Account,
+        default_root_pk: Optional[bytes] = None,
+        hot_rpc: str = "https://rpc1.hotdao.ai",
+        derive: Optional[bytes] = None,
+    ):
+        """
+        :param near_account: Near account
+        :param derive: Derived key for wallet
+        :param hot_rpc: Hot RPC url
+        :param default_root_pk: Default auth key for HOT Protocol, if provided, derive = sha256(default_root_pk.public_key).digest()
+        """
+        self.near_account = near_account
+        if len(default_root_pk) != 32:
+            raise ValueError("Default root pk should be 32 bytes")
+        if default_root_pk:
+            self.default_root_pk = default_root_pk
+            private_key_obj = self.derive_private_key(0)
+            derive = sha256(private_key_obj.verify_key.encode()).digest()
+        elif derive is None:
+            logger.warning(
+                "Its recomended to use default_root_pk to generate derives, v0 wallets support will be deprecated"
+            )
+            raise ValueError("Derive is required")
+        self.derive = derive
+        self.hot_rpc = hot_rpc
+        self._client = httpx.AsyncClient()
+
+    def derive_private_key(self, gen=0):
+        private_key = self.default_root_pk
+        for _ in range(gen):
+            private_key = sha256(private_key).digest()
+        return signing.SigningKey(
+            private_key,
+            encoder=encoding.RawEncoder,
+        )
+
+    @property
+    def wallet_id(self):
+        return base58.b58encode(sha256(self.derive).digest()).decode("utf-8")
+
+    async def get_wallet(self):
+        wallet = await self.near_account.view_function(
+            _WALLET_REGISTER, "get_wallet", args={"wallet_id": self.wallet_id}
+        )
+        if wallet.result:
+            return WalletModel.build(wallet.result)
+
+    async def create_wallet_with_keys_auth(self, public_key: bytes, key_gen=1):
+        """
+        Create wallet with keys.auth.hot.tg auth method.
+        :param public_key: Public key for auth future signs on keys.auth.hot.tg
+        """
+        wallet = await self.get_wallet()
+        if wallet and wallet.access_list[0].account_id != "default.auth.hot.tg":
+            raise ValueError(
+                "MPCWallet already exists with different auth method, please use another wallet_id"
+            )
+        root_pk = self.derive_private_key(0)
+        proof_hash = sha256(f"CREATE_WALLET:{self.wallet_id}".encode("utf-8")).digest()
+        signature = base58.b58encode(root_pk.sign(proof_hash).signature).decode("utf-8")
+
+        s = await self._client.post(
+            f"{self.hot_rpc}/create_wallet",
+            json=dict(
+                public_key=base58.b58encode(public_key).decode(),
+                wallet_id=self.wallet_id,
+                key_gen=key_gen,
+                signature=signature,
+                wallet_derive_public_key=base58.b58encode(
+                    root_pk.verify_key.encode()
+                ).decode(),
+            ),
+            timeout=30,
+        )
+        return s.json()
+
+    async def get_ecdsa_public_key(self) -> bytes:
+        resp = (
+            await self._client.post(
+                f"{self.hot_rpc}/public_key",
+                json=dict(wallet_derive=base58.b58encode(self.derive).decode()),
+                timeout=10,
+                follow_redirects=True,
+            )
+        ).json()
+        return bytes.fromhex(resp["ecdsa"])
+
+    @property
+    def public_key(self):
+        # TODO Calculate with Rust Code
+        raise NotImplementedError("Public key calculation is not implemented yet")
+
+    async def sign_message(
+        self,
+        message_body: bytes,
+        curve_type: CurveType = CurveType.SECP256K1,
+        auth_methods: List[AuthContract] = None,
+    ):
+        if not self.default_root_pk:
+            raise ValueError("Default auth key is required")
+        wallet = await self.get_wallet()
+        user_payloads = []
+        msg_hash = keccak(message_body)
+        if len(auth_methods) != len(wallet.access_list):
+            raise ValueError("Auth methods count should be equal to wallet access list")
+
+        for auth_contract, auth_method in zip(auth_methods, wallet.access_list):
+            auth_class = AUTH_CLASS[auth_method.account_id]
+            if not isinstance(auth_contract, auth_class):
+                raise ValueError(
+                    f"Auth method {auth_method.account_id} is not supported for this auth class"
+                )
+            user_payloads.append(auth_contract.generate_user_payload(msg_hash))
+
+        proof = {
+            "auth_id": 0,
+            "curve_type": curve_type,
+            "user_payloads": user_payloads,
+            "message_body": message_body.hex(),
+        }
+
+        resp = (
+            await self._client.post(
+                f"{self.hot_rpc}/sign_raw",
+                json=dict(
+                    uid=self.derive.hex(),
+                    message=msg_hash.hex(),
+                    proof=proof,
+                    key_type=curve_type,
+                ),
+                timeout=10,
+                follow_redirects=True,
+            )
+        ).json()
+        resp = resp["Ecdsa"]
+        r = int(resp["big_r"][2:], 16)
+        s = int(resp["signature"], 16)
+
+        pk = await self.get_ecdsa_public_key()
+        for v in (0, 1):
+            sig = Signature(vrs=(v, r, s))
+            recovered = sig.recover_public_key_from_msg_hash(msg_hash)
+            if recovered.to_compressed_bytes() == pk:
+                return (
+                    r.to_bytes(32, "big") + s.to_bytes(32, "big") + bytes([v])
+                ).hex()
+
+        raise BadSignature("Cannot recover public key from signature")
+
+    async def add_new_access_rule(
+        self, access: WalletAccessModel, auth_contracts: List[AuthContract]
+    ):
+        wallet = await self.get_wallet()
+        access_json = access.model_dump_json()
+        message_body = f"ADD_AUTH_METHOD:{access_json}:{self.wallet_id}".encode("utf-8")
+        msg_hash = sha256(message_body).digest()
+        user_payloads = []
+        for auth_contract, auth_method in zip(auth_contracts, wallet.access_list):
+            auth_class = AUTH_CLASS[auth_method.account_id]
+            if not isinstance(auth_contract, auth_class):
+                raise ValueError(
+                    f"Auth method {auth_method.account_id} is not supported for this auth class"
+                )
+            user_payloads.append(auth_contract.generate_user_payload(msg_hash))
+        return await self.near_account.function_call(
+            _WALLET_REGISTER,
+            "add_access_rule",
+            {
+                "wallet_id": self.wallet_id,
+                "rule": access.model_dump(),
+                "user_payloads": user_payloads,
+            },
+            included=True,
+        )
+
+    async def remove_access_rule(
+        self, access_id: int, auth_contracts: List[AuthContract]
+    ):
+        wallet = await self.get_wallet()
+        message_body = f"REMOVE_AUTH_METHOD:{access_id}:{self.wallet_id}".encode(
+            "utf-8"
+        )
+        msg_hash = sha256(message_body).digest()
+        user_payloads = []
+        if len(auth_contracts) != len(wallet.access_list):
+            raise ValueError("Auth methods count should be equal to wallet access list")
+        for auth_contract, auth_method in zip(auth_contracts, wallet.access_list):
+            auth_class = AUTH_CLASS[auth_method.account_id]
+            if not isinstance(auth_contract, auth_class):
+                raise ValueError(
+                    f"Auth method {auth_method.account_id} is not supported for this auth class"
+                )
+            user_payloads.append(auth_contract.generate_user_payload(msg_hash))
+        return await self.near_account.function_call(
+            _WALLET_REGISTER,
+            "remove_access_rule",
+            {
+                "wallet_id": self.wallet_id,
+                "rule_id": access_id,
+                "user_payloads": user_payloads,
+            },
+            included=True,
+        )

{py_near-1.1.50 → py_near-1.1.51}/src/py_near/providers.py

@@ -220,8 +220,11 @@ class JsonProvider(object):
                     break
                 if not body:
                     return error
-                key, body = list(body.items())[0]
-                if key in ERROR_CODE_TO_EXCEPTION:
+                if len(body) == 1 and list(body.keys())[0] in ERROR_CODE_TO_EXCEPTION:
+                    key, body = list(body.items())[0]
+                    if isinstance(body, str) and body in ERROR_CODE_TO_EXCEPTION:
+                        key = body
+                        body = {}
                     error = ERROR_CODE_TO_EXCEPTION[key](
                         body, error_json=content["error"]
                     )
@@ -443,4 +446,4 @@ class JsonProvider(object):
         return await self.json_rpc("light_client_proof", params)
 
     async def get_next_light_client_block(self, last_block_hash):
-        return await self.json_rpc("next_light_client_block", [last_block_hash])
+        return await self.json_rpc("next_light_client_block", [last_block_hash])

{py_near-1.1.50 → py_near-1.1.51}/src/py_near/transactions.py

@@ -1,8 +1,7 @@
 import base64
 from typing import Union, List
-
+from nacl import signing, encoding
 import base58
-import ed25519
 from py_near_primitives import (
     CreateAccountAction,
     AddKeyAction,
@@ -34,11 +33,11 @@ def sign_and_serialize_transaction(
         pk = base58.b58decode(private_key.replace("ed25519:", ""))
     else:
         pk = private_key
-    private_key = ed25519.SigningKey(pk)
+    private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
 
     transaction = Transaction(
         account_id,
-        private_key.get_verifying_key().to_bytes(),
+        private_key.verify_key.encode(),
         nonce,
         receiver_id,
         block_hash,
@@ -61,11 +60,11 @@ def calc_trx_hash(
         pk = base58.b58decode(private_key.replace("ed25519:", ""))
     else:
         pk = private_key
-    private_key = ed25519.SigningKey(pk)
+    private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
 
     transaction = Transaction(
         account_id,
-        private_key.get_verifying_key().to_bytes(),
+        private_key.verify_key.encode(),
         nonce,
         receiver_id,
         block_hash,