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

py_near/account.py

@@ -4,6 +4,8 @@ import json
 import sys
 from typing import List, Union, Dict, Optional
 
+from nacl.signing import VerifyKey
+
 if sys.version_info.major == 3 and sys.version_info.minor >= 10:
     from collections.abc import MutableSet, MutableMapping
 
@@ -85,9 +87,11 @@ class Account(object):
                 except UnicodeEncodeError:
                     logger.error(f"Can't decode private key {pk[:10]}")
                     continue
-            private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
-            public_key = private_key.verify_key
-            self._signer_by_pk[public_key] = pk
+            if len(pk) > 32:
+                pk = pk[:32]
+            private_key = signing.SigningKey(pk, encoder=encoding.RawEncoder)
+            public_key_b58 = base58.b58encode(private_key.verify_key.encode()).decode("utf-8")
+            self._signer_by_pk[public_key_b58] = pk
             self._free_signers.put_nowait(pk)
             self._signers.append(pk)
 
@@ -206,8 +210,6 @@ class Account(object):
 
         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.encode()).decode("utf8")
         )
@@ -449,14 +451,14 @@ class Account(object):
         await self._update_last_block_hash()
 
         private_key = signing.SigningKey(pk[:32], encoder=encoding.RawEncoder)
-        verifying_key = private_key.verify_key
+        verifying_key: VerifyKey = private_key.verify_key
         return DelegateActionModel(
             sender_id=self.account_id,
             receiver_id=receiver_id,
             actions=actions,
             nonce=access_key.nonce + 1,
             max_block_height=self._latest_block_height + 1000,
-            public_key=base58.b58encode(verifying_key.to_bytes()).decode("utf-8"),
+            public_key=base58.b58encode(verifying_key.encode()).decode("utf-8"),
         )
 
     def sign_delegate_transaction(

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,261 @@
+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,
+        )

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

@@ -1,23 +1,45 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: py-near
-Version: 1.1.53
+Version: 1.1.55
 Summary: Pretty simple and fully asynchronous framework for working with NEAR blockchain
-Author: pvolnov
-Author-email: petr@herewallet.app
-Requires-Python: >=3.8,<3.12
+Author-email: pvolnov <petr@herewallet.app>
+License: Permission is hereby granted, free of charge, to any
+        person obtaining a copy of this software and associated
+        documentation files (the "Software"), to deal in the
+        Software without restriction, including without
+        limitation the rights to use, copy, modify, merge,
+        publish, distribute, sublicense, and/or sell copies of
+        the Software, and to permit persons to whom the Software
+        is furnished to do so, subject to the following
+        conditions:
+        
+        The above copyright notice and this permission notice
+        shall be included in all copies or substantial portions
+        of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+        ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+        TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+        PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+        SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+        CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+        IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+        DEALINGS IN THE SOFTWARE.
+        
+Project-URL: homepage, https://github.com/pvolnov/py-near
+Project-URL: documentation, https://py-near.readthedocs.io/en/latest
+Project-URL: repository, https://github.com/pvolnov/py-near
+Project-URL: changelog, https://github.com/pvolnov/py-near/blob/main/CHANGELOG.md
+Project-URL: funding, https://opencollective.com/py-near
+Project-URL: twitter, https://twitter.com/p_volnov
+Keywords: python,near,async
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-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: 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.4)
-Requires-Dist: pydantic (>=2.6.2,<3.0.0)
-Requires-Dist: pynacl (>=1.5.0,<2.0.0)
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
 
 # py-near
 
@@ -141,4 +163,3 @@ for t in task:
 
 This project exists thanks to all the people who contribute. [[Code of conduct](CODE_OF_CONDUCT.md)].
 <a href="https://github.com/pvolnov/py-near/graphs/contributors"><img src="https://opencollective.com/py-near/contributors.svg?width=890&button=false" /></a>
-

{py_near-1.1.53.dist-info → py_near-1.1.55.dist-info}/RECORD

@@ -1,13 +1,17 @@
 py_near/__init__.py,sha256=t5fAxjaU8dN8xpQR2vz0ZGhfTkdVy2RCbkhJhZFglk4,50
-py_near/account.py,sha256=ICLWOzRE7sfEU_ilLGPd0kyzhsMDmS1CWURFFCbk3Io,18200
+py_near/account.py,sha256=khay55bKlJ3x70TVpiYhhuH1ASm8zis2eN-FTYBWQ-E,18302
 py_near/constants.py,sha256=inaWIuwmF1EB5JSB0ynnZY5rKY_QsxhF9KuCOhPsM6k,164
+py_near/models.py,sha256=85ynmLVJnzWvFKq-Z8iIO0waU-2iP-CSkaOGX4mYoL0,11590
+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/dapps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_near/dapps/core.py,sha256=LtN9aW2gw2mvEdhzQcQJIidtjv-XL1xjb0LK8DzqtqE,231
+py_near/dapps/fts.py,sha256=MFe_wC96K_RfpFc7soeZr-ejuMWPl7SJqaX2mTbZHy0,959
 py_near/dapps/ft/__init__.py,sha256=hx8qh4yEs37Ul_JhDWn8LHd-9lzsaATivxKOJPaUqTE,29
 py_near/dapps/ft/async_client.py,sha256=Oir5EQOGueq0lsNn0ybe_1uvMnmV5K1m_mHFuFWIUu4,6717
 py_near/dapps/ft/exceptions.py,sha256=UjXLFsDQX0vDGS9CGO7HE9XpLD0vovFNUzCb11WKAtc,92
 py_near/dapps/ft/models.py,sha256=_URS8nXZvfuxjU7Ov2E-nteBak5qKtPKN3bLOR7sC9k,186
-py_near/dapps/fts.py,sha256=MFe_wC96K_RfpFc7soeZr-ejuMWPl7SJqaX2mTbZHy0,959
 py_near/dapps/keypom/__init__.py,sha256=6fWGxsVr_lb_wTf_MHrbwBl1fgf78b5ezmsVa3JeFjI,32
 py_near/dapps/keypom/async_client.py,sha256=DS594S00xhcyvVtD1W0PjmtmT3YhvXTZZ3hskbn1-1w,1422
 py_near/dapps/keypom/exceptions.py,sha256=pGz0w1Ubh2A1aHEWvUX4dVaCcO9r2Y-h2JwhBY5KJbU,45
@@ -19,11 +23,17 @@ 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=85ynmLVJnzWvFKq-Z8iIO0waU-2iP-CSkaOGX4mYoL0,11590
-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.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/mpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_near/mpc/models.py,sha256=9MSfBDqfqkaJu6eJxnwyjgihsexZboehbJ6vAGa4BTU,663
+py_near/mpc/wallet.py,sha256=sNr9UlcyVDPF_Zho_4iTupbUoZct3paQlxxDHlHK67k,9768
+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-1.1.55.dist-info/licenses/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
+py_near-1.1.55.dist-info/METADATA,sha256=e8ex0o1yHlb7ivf4FPTwxQy8cQEa87t4ib2k93ffu_A,6012
+py_near-1.1.55.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+py_near-1.1.55.dist-info/top_level.txt,sha256=p8CZgfKEVmXnRfVX5VHR0Ls7OVFC2ZVEwthvNB8Rb2Q,8
+py_near-1.1.55.dist-info/RECORD,,

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

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

py_near-1.1.55.dist-info/top_level.txt

@@ -0,0 +1 @@
+py_near