py-near 1.1.52__py3-none-any.whl → 1.1.53__py3-none-any.whl

{py_near-1.1.52.dist-info → py_near-1.1.53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-near
-Version: 1.1.52
+Version: 1.1.53
 Summary: Pretty simple and fully asynchronous framework for working with NEAR blockchain
 Author: pvolnov
 Author-email: petr@herewallet.app
@@ -11,12 +11,10 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 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: httpx (>=0.26.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
-Requires-Dist: py-near-primitives (==0.2.3)
+Requires-Dist: py-near-primitives (==0.2.4)
 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-1.1.52.dist-info → py_near-1.1.53.dist-info}/RECORD

@@ -20,19 +20,10 @@ py_near/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 py_near/exceptions/exceptions.py,sha256=DEFipaAHm0y7oCuN2QKzHsiQvUTUQVl-Ce36Ag7n7hs,5509
 py_near/exceptions/provider.py,sha256=K-wexgjPJ8sw42JePwaP7R5dJEIn9DoFJRvVcURsx6s,7718
 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=sNr9UlcyVDPF_Zho_4iTupbUoZct3paQlxxDHlHK67k,9768
 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.52.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
-py_near-1.1.52.dist-info/METADATA,sha256=A_pG9PjBofHZQSJFoimIFb33ljVJgC7qT1OCnhlDR9U,4846
-py_near-1.1.52.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-py_near-1.1.52.dist-info/RECORD,,
+py_near-1.1.53.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
+py_near-1.1.53.dist-info/METADATA,sha256=aE8cvfs6Axphip2sszcwmHLdd1cXmXq1d3W54CjgMe4,4763
+py_near-1.1.53.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+py_near-1.1.53.dist-info/RECORD,,

{py_near-1.1.52.dist-info → py_near-1.1.53.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

py_near/mpc/auth/auth_2fa.py

@@ -1,97 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,261 +0,0 @@
-import json
-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"
-            )
-        auth_to_add_msg = json.dumps(
-            dict(public_keys=[base58.b58encode(public_key).decode()], rules=[])
-        ).replace(" ", "")
-        return await self.create_wallet(
-            "keys.auth.hot.tg", None, auth_to_add_msg, key_gen
-        )
-
-    async def create_wallet(
-        self, auth_account_id: str, metadata: str = "", auth_to_add_msg="", 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}:{auth_account_id}:{metadata}:{auth_to_add_msg}".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(
-                wallet_id=self.wallet_id,
-                key_gen=key_gen,
-                signature=signature,
-                wallet_derive_public_key=base58.b58encode(
-                    root_pk.verify_key.encode()
-                ).decode(),
-                auth={
-                    "auth_account_id": auth_account_id,
-                    "msg": auth_to_add_msg,
-                    "metadata": metadata or None,
-                },
-            ),
-            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,
-        msg_hash: bytes,
-        message_body: Optional[bytes] = None,
-        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 = []
-        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):
-            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() if message_body else "",
-        }
-
-        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,
-        )
-        resp = resp.json()
-        if "Ecdsa" not in resp:
-            raise ValueError(f"Invalid response from server: {resp}")
-        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,
-        )