py-near 1.1.30__tar.gz → 1.1.32__tar.gz

{py_near-1.1.30 → py_near-1.1.32}/PKG-INFO

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

{py_near-1.1.30 → py_near-1.1.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "py-near"
-version = "1.1.30"
+version = "1.1.32"
 description="Pretty simple and fully asynchronous framework for working with NEAR blockchain"
 authors = ["pvolnov <petr@herewallet.app>"]
 readme = "README.md"
@@ -22,7 +22,7 @@ base58 = "^2.1.1"
 
 [project]
 name = "py-near"
-version = "1.1.30"
+version = "1.1.32"
 description = "Pretty simple and fully asynchronous framework for working with NEAR blockchaink"
 authors = [ {name = "pvolnov", email = "petr@herewallet.app"} ]
 requires-python = ">=3.7"

{py_near-1.1.30 → py_near-1.1.32}/src/py_near/account.py

@@ -108,7 +108,7 @@ class Account(object):
         self._latest_block_hash_ts = utils.timestamp()
 
     async def sign_and_submit_tx(
-        self, receiver_id, actions: List[Action], nowait=False
+        self, receiver_id, actions: List[Action], nowait=False, included=False
     ) -> Union[TransactionResult, str]:
         """
         Sign transaction and send it to blockchain
@@ -116,6 +116,7 @@ class Account(object):
         :param actions: list of actions
         :param nowait: if nowait is True, return transaction hash, else wait execution
         confirm and return TransactionResult
+        :param included: if included is True, return transaction hash, else wait execution
         :return: transaction hash or TransactionResult
         """
         if not self._signers:
@@ -149,7 +150,10 @@ class Account(object):
         )
 
         try:
-            if nowait:
+            if included:
+                await self._provider.send_tx_included(serialized_tx)
+                return trx_hash
+            elif nowait:
                 return await self._provider.send_tx(serialized_tx)
             return await self._provider.send_tx_and_wait(
                 serialized_tx, trx_hash=trx_hash, receiver_id=receiver_id
@@ -211,17 +215,18 @@ class Account(object):
         return await self._provider.get_account(self.account_id)
 
     async def send_money(
-        self, account_id: str, amount: int, nowait: bool = False
+        self, account_id: str, amount: int, nowait: bool = False, included=False
     ) -> TransactionResult:
         """
         Send money to account_id
         :param account_id: receiver account id
         :param amount: amount in yoctoNEAR
         :param nowait: if nowait is True, return transaction hash, else wait execution
+        :param included: if included is True, return transaction hash, else wait execution
         :return: transaction hash or TransactionResult
         """
         return await self.sign_and_submit_tx(
-            account_id, [transactions.create_transfer_action(amount)], nowait
+            account_id, [transactions.create_transfer_action(amount)], nowait, included
         )
 
     async def function_call(
@@ -232,6 +237,7 @@ class Account(object):
         gas: int = constants.DEFAULT_ATTACHED_GAS,
         amount: int = 0,
         nowait: bool = False,
+        included=False
     ):
         """
         Call function on smart contract
@@ -241,6 +247,7 @@ class Account(object):
         :param gas: amount of attachment gas. Default is 200000000000000
         :param amount: amount of attachment NEAR, Default is 0
         :param nowait: if nowait is True, return transaction hash, else wait execution
+        :param included: if included is True, return transaction hash, else wait execution
         :return: transaction hash or TransactionResult
         """
         ser_args = json.dumps(args).encode("utf8")
@@ -252,6 +259,7 @@ class Account(object):
                 )
             ],
             nowait,
+            included
         )
 
     async def create_account(

{py_near-1.1.30 → py_near-1.1.32}/src/py_near/providers.py

@@ -44,7 +44,11 @@ PROVIDER_CODE_TO_EXCEPTION = {
 
 
 class JsonProvider(object):
-    def __init__(self, rpc_addr):
+    def __init__(self, rpc_addr, allow_broadcast=True):
+        """
+        :param rpc_addr: str or list of str
+        :param allow_broadcast: bool - submit signed transaction to all RPCs
+        """
         if isinstance(rpc_addr, tuple):
             self._rpc_addresses = ["http://{}:{}".format(*rpc_addr)]
         elif isinstance(rpc_addr, list):
@@ -53,6 +57,7 @@ class JsonProvider(object):
             self._rpc_addresses = [rpc_addr]
         self._available_rpcs = self._rpc_addresses.copy()
         self._last_rpc_addr_check = 0
+        self.allow_broadcast = allow_broadcast
 
     async def check_available_rpcs(self):
         if (
@@ -109,10 +114,12 @@ class JsonProvider(object):
                     logger.error(f"Remove rpc: {e}")
         self._available_rpcs = available_rpcs
 
-    async def call_rpc_request(self, method, params, timeout=TIMEOUT_WAIT_RPC):
+    async def call_rpc_request(
+        self, method, params, timeout=TIMEOUT_WAIT_RPC, broadcast=False
+    ):
         await self.check_available_rpcs()
         j = {"method": method, "params": params, "id": "dontcare", "jsonrpc": "2.0"}
-
+        res = {}
         for rpc_addr in self._available_rpcs:
             try:
                 async with aiohttp.ClientSession() as session:
@@ -120,10 +127,14 @@ class JsonProvider(object):
                         rpc_addr,
                         json=j,
                         timeout=timeout,
-                        headers={"Referer": "https://tgapp.herewallet.app/"},  # NEAR RPC requires Referer header
+                        headers={
+                            "Referer": "https://tgapp.herewallet.app/"
+                        },  # NEAR RPC requires Referer header
                     )
                     r.raise_for_status()
-                    return json.loads(await r.text())
+                    res = json.loads(await r.text())
+                    if not broadcast:
+                        return res
             except (
                 RPCTimeoutError,
                 ClientResponseError,
@@ -133,6 +144,7 @@ class JsonProvider(object):
             ) as e:
                 logger.error(f"Rpc error: {e}")
                 continue
+        return res
 
     @staticmethod
     def get_error_from_response(content: dict):
@@ -156,8 +168,10 @@ class JsonProvider(object):
                     break
             return error
 
-    async def json_rpc(self, method, params, timeout=TIMEOUT_WAIT_RPC):
-        content = await self.call_rpc_request(method, params, timeout)
+    async def json_rpc(self, method, params, timeout=TIMEOUT_WAIT_RPC, broadcast=False):
+        content = await self.call_rpc_request(
+            method, params, timeout, broadcast=broadcast
+        )
         if not content:
             raise RpcEmptyResponse("RPC returned empty response")
 
@@ -173,7 +187,28 @@ class JsonProvider(object):
         :param timeout: rpc request timeout
         :return:
         """
-        return await self.json_rpc("broadcast_tx_async", [signed_tx], timeout=timeout)
+        return await self.json_rpc(
+            "broadcast_tx_async",
+            [signed_tx],
+            timeout=timeout,
+            broadcast=self.allow_broadcast,
+        )
+
+    async def send_tx_included(
+        self, signed_tx: str, timeout: int = constants.TIMEOUT_WAIT_RPC
+    ):
+        """
+        Send a signed transaction to the network and return the hash of the transaction
+        :param signed_tx: base64 encoded signed transaction, str.
+        :param timeout: rpc request timeout
+        :return:
+        """
+        return await self.json_rpc(
+            "send_tx",
+            {"signed_tx_base64": signed_tx, "wait_until": "INCLUDED_FINAL"},
+            timeout=timeout,
+            broadcast=self.allow_broadcast,
+        )
 
     async def wait_for_trx(self, trx_hash, receiver_id) -> TransactionResult:
         for _ in range(6):
@@ -207,6 +242,7 @@ class JsonProvider(object):
                 "broadcast_tx_commit",
                 [signed_tx],
                 timeout=timeout,
+                broadcast=self.allow_broadcast,
             )
             return TransactionResult(**res)
         except RPCTimeoutError: