py-near 1.1.49__py3-none-any.whl → 1.1.51__py3-none-any.whl

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/models.py

@@ -48,8 +48,10 @@ class ReceiptOutcome:
     tokens_burnt: str
     executor_id: str
     gas_burnt: int
+    receipt_id: str
 
     def __init__(self, data):
+        self.receipt_id = data['id']
         self.logs = data["outcome"]["logs"]
         self.metadata = data["outcome"]["metadata"]
         self.receipt_ids = data["outcome"]["receipt_ids"]

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/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/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/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/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/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/providers.py

@@ -6,6 +6,7 @@ from collections import Counter
 from typing import Optional
 
 import httpx
+from httpx import Limits
 from loguru import logger
 
 from py_near.constants import TIMEOUT_WAIT_RPC
@@ -60,29 +61,13 @@ class JsonProvider(object):
         self._last_rpc_addr_check = 0
         self.allow_broadcast = allow_broadcast
         self._timeout = timeout
-        self._client: httpx.AsyncClient = httpx.AsyncClient()
+        self._client = httpx.AsyncClient(
+            limits=Limits(max_connections=1000, max_keepalive_connections=200)
+        )
 
     async def shutdown(self):
         pass
 
-    async def check_available_rpcs(self):
-        if (
-            self._last_rpc_addr_check < datetime.datetime.now().timestamp() - 30
-            or not self._available_rpcs
-        ):
-            self._last_rpc_addr_check = datetime.datetime.now().timestamp()
-            asyncio.create_task(self._check_available_rpcs())
-
-        for _ in range(5):
-            if self._available_rpcs:
-                break
-            await self._check_available_rpcs()
-            await asyncio.sleep(3)
-
-        if not self._available_rpcs:
-            self._available_rpcs = self._rpc_addresses.copy()
-            logger.error("All RPCs are async, reset to default list")
-
     async def _check_available_rpcs(self):
         available_rpcs = []
         for rpc_addr in self._rpc_addresses:
@@ -132,7 +117,7 @@ class JsonProvider(object):
             except Exception as e:
                 if rpc_addr in self._available_rpcs:
                     logger.error(f"Remove rpc: {e}")
-                logger.error(f"Rpc check error: {e}")
+                logger.exception(e)
         self._available_rpcs = available_rpcs
 
     @staticmethod
@@ -144,7 +129,6 @@ class JsonProvider(object):
     async def call_rpc_request(
         self, method, params, broadcast=False, threshold: int = 0
     ):
-        await self.check_available_rpcs()
         j = {"method": method, "params": params, "id": "dontcare", "jsonrpc": "2.0"}
 
         async def f(rpc_call_addr):
@@ -236,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"]
                     )
@@ -325,7 +312,6 @@ class JsonProvider(object):
                 return await self.wait_for_trx(trx_hash, receiver_id)
 
     async def get_status(self):
-        await self.check_available_rpcs()
         for rpc_addr in self._available_rpcs.copy():
             try:
                 data = {
@@ -340,9 +326,7 @@ class JsonProvider(object):
                 if "@" in rpc_addr:
                     auth_key = rpc_addr.split("//")[1].split("@")[0]
                     rpc_addr = rpc_addr.replace(auth_key + "@", "")
-                    headers = {
-                        "Authorization": f"Bearer {auth_key}"
-                    }
+                    headers = {"Authorization": f"Bearer {auth_key}"}
                 r = await self._client.post(rpc_addr, json=data, headers=headers)
                 if r.status_code == 200:
                     return json.loads(r.text)["result"]
@@ -462,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/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,

{py_near-1.1.49.dist-info → py_near-1.1.51.dist-info}/METADATA

@@ -1,20 +1,24 @@
 Metadata-Version: 2.1
 Name: py-near
-Version: 1.1.49
+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.49.dist-info → py_near-1.1.51.dist-info}/RECORD

@@ -1,5 +1,5 @@
 py_near/__init__.py,sha256=t5fAxjaU8dN8xpQR2vz0ZGhfTkdVy2RCbkhJhZFglk4,50
-py_near/account.py,sha256=77jCtVaGXK_ejQ0SyRYRgJ4Ez1DaWByfAX94Uuph-aw,18107
+py_near/account.py,sha256=ICLWOzRE7sfEU_ilLGPd0kyzhsMDmS1CWURFFCbk3Io,18200
 py_near/constants.py,sha256=inaWIuwmF1EB5JSB0ynnZY5rKY_QsxhF9KuCOhPsM6k,164
 py_near/dapps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_near/dapps/core.py,sha256=LtN9aW2gw2mvEdhzQcQJIidtjv-XL1xjb0LK8DzqtqE,231
@@ -19,11 +19,20 @@ py_near/dapps/staking/models.py,sha256=zC5M_pc1oMqHq4GaYif1uwFbW6acD2BsiA9rbyiaU
 py_near/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_near/exceptions/exceptions.py,sha256=DEFipaAHm0y7oCuN2QKzHsiQvUTUQVl-Ce36Ag7n7hs,5509
 py_near/exceptions/provider.py,sha256=K-wexgjPJ8sw42JePwaP7R5dJEIn9DoFJRvVcURsx6s,7718
-py_near/models.py,sha256=GZQD1TKGWlwqsJsKRXrVNBjCdAIpk7GQypU-QOtAPFs,11533
-py_near/providers.py,sha256=1eg9MFIYIKA09bZyTdSZ2Umrh0kX1SUFEhY_tN8Cqz4,16722
-py_near/transactions.py,sha256=QAXegv2JpKISk92NaChtIH6-QPHrcWbrwdKH_lH4TsU,3186
+py_near/models.py,sha256=85ynmLVJnzWvFKq-Z8iIO0waU-2iP-CSkaOGX4mYoL0,11590
+py_near/mpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_near/mpc/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_near/mpc/auth/auth_2fa.py,sha256=ZxO8mGO95ixb0qXnKrfmVxP7ivpDKerH4-udV_vUmbs,3124
+py_near/mpc/auth/base.py,sha256=IoFdRWUQcerYZq8TCkpjXJQRcENnzA9WwFbVPgmHgcs,629
+py_near/mpc/auth/core.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_near/mpc/auth/default_auth.py,sha256=i70412yXYx3MlFSsPxHLKbF0CXTjC39Qtl34et8kAEw,751
+py_near/mpc/auth/keys_auth.py,sha256=DJPi37DnV6r6cSskHEhHBiR_QiaAQJkg0AEsYp6cePA,2359
+py_near/mpc/models.py,sha256=9MSfBDqfqkaJu6eJxnwyjgihsexZboehbJ6vAGa4BTU,663
+py_near/mpc/wallet.py,sha256=Nihr4TR7MQURyI2wvoNIQ77Dx2_mR797RgyN91UHB8Q,8906
+py_near/providers.py,sha256=X_GfddFzmafBatqFJH41Dp_lYvTNcz1Q3Ko2tEnN0VU,16193
+py_near/transactions.py,sha256=QwEP3qOGxb8OB2vZA_rU20jvkPA0FmJowUKDxbuzOuI,3251
 py_near/utils.py,sha256=FirRH93ydH1cwjn0-sNrZeIn3BRD6QHedrP2VkAdJ6g,126
-py_near-1.1.49.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
-py_near-1.1.49.dist-info/METADATA,sha256=ERDv9zuuxRMfj4RzeF4Kvup_2QuTYueowDiP3tmc-EY,4693
-py_near-1.1.49.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-py_near-1.1.49.dist-info/RECORD,,
+py_near-1.1.51.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
+py_near-1.1.51.dist-info/METADATA,sha256=0Tcfm023KquhJIWBY5JWhcBb_cyHQsmmIpv3eqloP6A,4846
+py_near-1.1.51.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+py_near-1.1.51.dist-info/RECORD,,