py-near 1.1.12__py3-none-any.whl → 1.1.14__py3-none-any.whl

py_near/account.py

@@ -1,9 +1,6 @@
 import asyncio
-import base64
 import collections
-import hashlib
 import json
-import logging
 from typing import List, Union, Dict, Optional
 
 import base58
@@ -15,12 +12,8 @@ from py_near import constants
 from py_near import transactions
 from py_near import utils
 from py_near.dapps.ft.async_client import FT
-from py_near.dapps.phone.async_client import Phone
 from py_near.dapps.staking.async_client import Staking
 from py_near.exceptions.provider import (
-    RPCTimeoutError,
-    InternalError,
-    TransactionError,
     JsonProviderError,
 )
 from py_near.models import (
@@ -150,9 +143,11 @@ class Account(object):
             result = await self._provider.send_tx_and_wait(
                 serialized_tx, trx_hash=trx_hash, receiver_id=receiver_id
             )
-            if isinstance(result, str):
+            if isinstance(result, TransactionResult):
                 return result
-            return TransactionResult(**result)
+            if isinstance(result, dict):
+                return TransactionResult(**result)
+            return result
 
         except JsonProviderError as e:
             e.trx_hash = trx_hash
@@ -453,14 +448,6 @@ class Account(object):
             return 0
         return int(data["amount"])
 
-    @property
-    def phone(self):
-        """
-        Get client for phone.herewallet.near
-        :return: Phone(self)
-        """
-        return Phone(self)
-
     @property
     def ft(self):
         """

py_near/dapps/fts.py

@@ -9,9 +9,8 @@ class FtModel:
 
 class FTS:
     USDTe = FtModel("dac17f958d2ee523a2206206994597c13d831ec7.factory.bridge.near", 6)
-    DAIe = FtModel("6b175474e89094c44da98b954eedeac495271d0f.factory.bridge.near", 18)
     USDCe = FtModel("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.factory.bridge.near", 6)
-    USDC = FtModel("17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1", 6)
+    DAIe = FtModel("6b175474e89094c44da98b954eedeac495271d0f.factory.bridge.near", 18)
     AURORA = FtModel("aaaaaa20d9e0e2461697782ef11675f668207961.factory.bridge.near", 18)
     WBTCe = FtModel("2260fac5e5542a773aa44fbcfedf7c193bc2c599.factory.bridge.near", 8)
     ETH = FtModel("aurora", 18)
@@ -20,7 +19,9 @@ class FTS:
     stNEAR = FtModel("meta-pool.near", 24)
     LINEAR = FtModel("linear-protocol.near", 24)
     wNEAR = FtModel("wrap.near", 24)
-
     META = FtModel("meta-token.near", 24)
-    USDT = FtModel("usdt.tether-token.near", 6)
 
+    USDT = FtModel("usdt.tether-token.near", 6)
+    USDC = FtModel(
+        "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1", 6
+    )

py_near/exceptions/exceptions.py

@@ -183,6 +183,20 @@ class DelegateActionExpired(ActionErrorKind):
     pass
 
 
+class DelegateActionInvalidNonce(ActionErrorKind):
+    """
+     Nonce must be greater sender[public_key].nonce
+    """
+    pass
+
+
+class DelegateActionInvalidSignature(ActionErrorKind):
+    """
+    Signature does not match the provided actions and given signer public key
+    """
+    pass
+
+
 _ERROR_TYPE_TO_EXCEPTION = {
     "AccountAlreadyExists": AccountAlreadyExistsError,
     "AccountDoesNotExist": AccountDoesNotExistError,
@@ -200,6 +214,8 @@ _ERROR_TYPE_TO_EXCEPTION = {
     "NewReceiptValidationError": NewReceiptValidationError,
     "DelegateActionExpired": DelegateActionExpired,
     "LackBalanceForState": LackBalanceForState,
+    "DelegateActionInvalidNonce": DelegateActionInvalidNonce,
+    "DelegateActionInvalidSignature": DelegateActionInvalidSignature,
 }
 
 

py_near/exceptions/provider.py

@@ -119,10 +119,11 @@ class InvalidTransactionError(TransactionError):
 
 
 class TxExecutionError(InvalidTransactionError):
-    def __init__(self, data, error_json=None):
+    def __init__(self, data, error_json=None, **kwargs):
         super().__init__(error_json=error_json)
         if isinstance(data, str):
             data = json.loads(data)
+        data.update(kwargs)
         for key, value in data.items():
             setattr(self, key, value)
 

py_near/models.py

@@ -264,7 +264,7 @@ class TransactionData:
 
     @property
     def url(self):
-        return f"https://explorer.near.org/transactions/{self.hash}"
+        return f"https://nearblocks.io/ru/txns/{self.hash}"
 
 
 class TransactionResult:

py_near/providers.py

@@ -1,19 +1,14 @@
 import asyncio
 import base64
-import hashlib
 import json
 from typing import Optional
 
 import aiohttp
-import base58
 from aiohttp import ClientResponseError, ClientConnectorError, ServerDisconnectedError
 from loguru import logger
 
-from py_near.constants import TIMEOUT_WAIT_RPC
-
-from py_near.models import TransactionResult
-
 from py_near import constants
+from py_near.constants import TIMEOUT_WAIT_RPC
 from py_near.exceptions.exceptions import RpcNotAvailableError
 from py_near.exceptions.provider import (
     UnknownBlockError,
@@ -30,7 +25,7 @@ from py_near.exceptions.provider import (
     UnknownAccessKeyError,
     ERROR_CODE_TO_EXCEPTION,
 )
-
+from py_near.models import TransactionResult
 
 PROVIDER_CODE_TO_EXCEPTION = {
     "UNKNOWN_BLOCK": UnknownBlockError,
@@ -159,12 +154,31 @@ class JsonProvider(object):
             raise
 
     async def get_status(self):
-        async with aiohttp.ClientSession() as session:
-            r = await session.get(
-                "%s/status" % self._rpc_addresses[0], timeout=TIMEOUT_WAIT_RPC
-            )
-            r.raise_for_status()
-            return json.loads(await r.text())
+        for rpc_addr in self._rpc_addresses:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    r = await session.get(
+                        "%s/status" % rpc_addr, timeout=TIMEOUT_WAIT_RPC
+                    )
+                    if r.status == 200:
+                        data = json.loads(await r.text())
+                        if not data["sync_info"][
+                            "syncing"
+                        ]:  # RPC is not in syncing process
+                            self._rpc_addresses.remove(rpc_addr)
+                            self._rpc_addresses.insert(0, rpc_addr)
+                            return data
+            except (
+                ClientResponseError,
+                ClientConnectorError,
+                ServerDisconnectedError,
+                ConnectionError,
+            ) as e:
+                logger.error(f"Rpc error: {e}")
+            except Exception as e:
+                logger.exception(e)
+
+        raise RpcNotAvailableError("RPC not available")
 
     async def get_validators(self):
         return await self.json_rpc("validators", [None])

{py_near-1.1.12.dist-info → py_near-1.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-near
-Version: 1.1.12
+Version: 1.1.14
 Summary: Pretty simple and fully asynchronous framework for working with NEAR blockchain
 Author: pvolnov
 Author-email: petr@herewallet.app

{py_near-1.1.12.dist-info → py_near-1.1.14.dist-info}/RECORD

@@ -1,5 +1,5 @@
 py_near/__init__.py,sha256=t5fAxjaU8dN8xpQR2vz0ZGhfTkdVy2RCbkhJhZFglk4,50
-py_near/account.py,sha256=QPBmFMxpGDgCUnAsN7Pd211cWMu8naPLV8tpvRD4XUg,16558
+py_near/account.py,sha256=k-bgn-VV6UIvqTuJpz-hnfn4uFXaabJRNgX--y_25kY,16325
 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
@@ -7,27 +7,23 @@ py_near/dapps/ft/__init__.py,sha256=hx8qh4yEs37Ul_JhDWn8LHd-9lzsaATivxKOJPaUqTE,
 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=ViMoQx0h-sgVTozr-JZk3hUGdGxsVP3oP3sAY8i8g5Q,946
+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
 py_near/dapps/keypom/models.py,sha256=NYcKnQw8X4HkvzAwS8qOmPrChT4-8UIM-eMY1r9RbWQ,2166
-py_near/dapps/phone/__init__.py,sha256=6fWGxsVr_lb_wTf_MHrbwBl1fgf78b5ezmsVa3JeFjI,32
-py_near/dapps/phone/async_client.py,sha256=VN25Knd5FfnzmwlXCXaO7XbyLFqUHQjwrdNfgz2zLDw,6849
-py_near/dapps/phone/exceptions.py,sha256=pGz0w1Ubh2A1aHEWvUX4dVaCcO9r2Y-h2JwhBY5KJbU,45
-py_near/dapps/phone/models.py,sha256=JbytZ2r18lCK6AXs8gL0hSZJR1Dsr0BuTFeRJvSQ3J0,332
 py_near/dapps/staking/__init__.py,sha256=1T2lj9DVp0FJ9IfnBtc5Qkx_nJMo1DRVX6L0ENyKugs,34
 py_near/dapps/staking/async_client.py,sha256=TYudiPwF4tQ03rZuWNL-PUQ2kKpx06BxWWmbvePxJjw,5203
 py_near/dapps/staking/exceptions.py,sha256=UjXLFsDQX0vDGS9CGO7HE9XpLD0vovFNUzCb11WKAtc,92
 py_near/dapps/staking/models.py,sha256=zC5M_pc1oMqHq4GaYif1uwFbW6acD2BsiA9rbyiaUTs,124
 py_near/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-py_near/exceptions/exceptions.py,sha256=OLoS-N97GPOk3eu0QKXMy2l_UPqDk4KtpfnJdM5VT4g,5040
-py_near/exceptions/provider.py,sha256=4RxQvO2ER7Bth1S0po0vBOE-gWkcYOZlrRhw2h-1Rig,7677
-py_near/models.py,sha256=QKQxL1wkTKZ4MWb5dprJZYalzrvd7bHSXC3WeBujuWE,9426
-py_near/providers.py,sha256=RVflvFx-ME1sh1anfO8DcV_g2KVfZk-ypAfdrTSi9Z0,9161
+py_near/exceptions/exceptions.py,sha256=qG-aBYAsyCXcdzmZ84n9wVHCLkuWnd16XZTVprJfUVM,5462
+py_near/exceptions/provider.py,sha256=RddgWbmwlXxrPuM7KtOjjJgtMR32ds2d3KxlnpMMC-A,7715
+py_near/models.py,sha256=_JMpwtI6kP6740jaUPN1JRQIIDGXmL7tXLlR-JvRPXc,9417
+py_near/providers.py,sha256=W1ttqR-dfl_Ists8FbUL7O5wARX92JgAqIPQ7uGz-7M,9915
 py_near/transactions.py,sha256=QAXegv2JpKISk92NaChtIH6-QPHrcWbrwdKH_lH4TsU,3186
 py_near/utils.py,sha256=FirRH93ydH1cwjn0-sNrZeIn3BRD6QHedrP2VkAdJ6g,126
-py_near-1.1.12.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
-py_near-1.1.12.dist-info/METADATA,sha256=kO3Xs7zm1iCe2ZqXNUhijfA6dbM12f4SYHh46GbsPlA,4662
-py_near-1.1.12.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-py_near-1.1.12.dist-info/RECORD,,
+py_near-1.1.14.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
+py_near-1.1.14.dist-info/METADATA,sha256=dYh9HIxdTvtkZis5EbI--meZhJVl0NAW6XLC3DbQ1pc,4662
+py_near-1.1.14.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+py_near-1.1.14.dist-info/RECORD,,

py_near/dapps/phone/__init__.py

@@ -1 +0,0 @@
-from .async_client import Phone

py_near/dapps/phone/async_client.py

@@ -1,189 +0,0 @@
-import json
-import re
-from typing import List
-
-import aiohttp
-
-from py_near.constants import TGAS
-from py_near.dapps.core import DappClient, NEAR
-from py_near.dapps.fts import FtModel
-from py_near.dapps.phone.exceptions import RequestLimitError
-from py_near.dapps.phone.models import NearTrustTransaction, FtTrustTransaction
-from py_near.exceptions.exceptions import FunctionCallError
-
-_PHONE_CONTRACT_ID = "phone.herewallet.near"
-
-
-class Phone(DappClient):
-    """
-    Client to phone.herewallet.near contract
-    With this contract you can send NEAR and fungible tokens to
-    phone number. Reciver will get notification with link to claim tokens.
-    """
-
-    def __init__(self, account, api_key="default"):
-        """
-
-        :param account:
-        :param api_key: there is limit for hash generator requests to provide spam,
-         to make unlimited requests use api key. You can get it for free by contacting team@herewallet.app
-        :param network: "mainnet" or "testnet"
-        """
-        if account.chain_id != "mainnet":
-            raise ValueError("Only mainnet is supported")
-        super().__init__(account)
-        self._api_key = api_key
-
-    async def _get_phone_hex(self, phone) -> str:
-        """
-        To calculate hash we need call herewallet api. This is necessary to prevent creation hash <> phone table.
-        :param phone:
-        :return: phone hash
-        """
-        if phone[0] != "+":
-            raise ValueError("Phone number must start with +")
-        phone = re.sub(r"\D", "", phone)
-        async with aiohttp.ClientSession() as session:
-            r = await session.get(
-                f"https://api.herewallet.app/api/v1/phone/calc_phone_hash?phone={phone}",
-                headers={
-                    "Content-Type": "application/json",
-                    "Authorization": self._api_key,
-                },
-            )
-            if r.status == 403:
-                raise RequestLimitError(
-                    "Too many hash generator requests, to make unlimited requests user api key."
-                    "Contact team@herewallet.app to get it for free"
-                )
-            if r.status != 200:
-                raise Exception(
-                    f"Error while getting phone hash: {r.status}\n{await r.text()}"
-                )
-            content = json.loads(await r.text())
-            return content["hash"]
-
-    async def get_ft_transfers(self, phone: str) -> List[FtTrustTransaction]:
-        """
-        Get list of fungible token transfers to phone number
-        :param phone: phone number
-        :return: list of FtTrustTransaction
-        """
-        res = (
-            await self._account.view_function(
-                _PHONE_CONTRACT_ID,
-                "get_ft_transfers",
-                {"phone": await self._get_phone_hex(phone)},
-            )
-        ).result
-        if res is None:
-            return []
-        return [FtTrustTransaction(**i) for i in res]
-
-    async def get_near_transfers(self, phone: str) -> List[NearTrustTransaction]:
-        """
-        Get list of NEAR transfers to phone number
-        :param phone: phone number
-        :return: list of NEAR transfers
-        """
-        res = (
-            await self._account.view_function(
-                _PHONE_CONTRACT_ID,
-                "get_transfers",
-                {"phone": await self._get_phone_hex(phone)},
-            )
-        ).result
-        if res is None:
-            return []
-        return [NearTrustTransaction(**i) for i in res]
-
-    async def send_near_to_phone(
-        self, phone: str, amount: float, comment: str = "", nowait: bool = False
-    ):
-        """
-        Send NEAR to phone number. Receiver will get sms with link to claim tokens.
-        :param phone: +X format phone number
-        :param amount: number of NEAR which will be sent
-        :param comment: any comment
-        :param nowait if True, method will return before transaction is confirmed
-        :return: transaction hash ot TransactionResult
-        """
-        if amount < 0.1:
-            raise ValueError("Amount must be >= 0.1 NEAR")
-        return await self._account.function_call(
-            _PHONE_CONTRACT_ID,
-            "send_near_to_phone",
-            {"phone": await self._get_phone_hex(phone), "comment": comment},
-            amount=int(amount * NEAR),
-            nowait=nowait,
-            gas=25 * TGAS,
-        )
-
-    async def send_ft_to_phone(
-        self,
-        ft: FtModel,
-        phone: str,
-        amount: float,
-        comment: str = "",
-        nowait: bool = False,
-    ):
-        """
-        Send fungible token to phone number. Reciver will get sms with link to claim tokens.
-        :param ft: Fungible token model
-        :param phone: +X format phone number
-        :param amount: number of FT which will be sent
-        :param comment:
-        :param nowait: if True, method will return before transaction is confirmed
-        :return:
-        """
-        return await self._account.function_call(
-            ft.contract_id,
-            "ft_transfer_call",
-            {
-                "msg": await self._get_phone_hex(phone),
-                "comment": comment,
-                "receiver_id": _PHONE_CONTRACT_ID,
-                "amount": str(int(amount * 10**ft.decimal)),
-            },
-            amount=1,
-            gas=50 * TGAS,
-            nowait=nowait,
-        )
-
-    async def cancel_near_transaction(self, phone: str, index: int):
-        """
-        Cancel NEAR transfer to phone number. Use index from get_near_transfers() method
-        :param phone: phone number
-        :param index: index in transaction list
-        :return:
-        """
-        try:
-            return await self._account.function_call(
-                _PHONE_CONTRACT_ID,
-                "cancel_near_transaction",
-                {"phone": await self._get_phone_hex(phone), "index": index},
-                amount=1,
-            )
-        except FunctionCallError as e:
-            if "`None` value" in str(e.error):
-                raise ValueError(f"Transaction with index {index} not found")
-            raise e
-
-    async def cancel_ft_transaction(self, phone: str, index: int):
-        """
-        Cancel fungible token transfer to phone number. Use index from get_ft_transfers() method
-        :param phone: phone number
-        :param index: index in transaction list
-        :return:
-        """
-        try:
-            return await self._account.function_call(
-                _PHONE_CONTRACT_ID,
-                "cancel_ft_transaction",
-                {"phone": await self._get_phone_hex(phone), "index": index},
-                amount=1,
-            )
-        except FunctionCallError as e:
-            if "`None` value" in str(e):
-                raise ValueError(f"Transaction with index {index} not found")
-            raise e

py_near/dapps/phone/exceptions.py

@@ -1,2 +0,0 @@
-class RequestLimitError(Exception):
-    pass

py_near/dapps/phone/models.py

@@ -1,18 +0,0 @@
-from pydantic import BaseModel
-
-
-class NearTrustTransaction(BaseModel):
-    from_account_id: str
-    amount: str
-
-
-class FtTrustTransaction(BaseModel):
-    from_account_id: str
-    ft_contract_id: str
-    ft_amount: str
-
-
-class NftTrustTransaction(BaseModel):
-    from_account_id: str
-    nft_contract_id: str
-    nft_token_id: str