(feat) Added a component to calculate gas limit for the Transaction Broadcaster based on the messages (without running the transaction simulation)

abel · abel · commit cd3fa2775215 · 2023-08-24T13:37:57.000-03:00
diff --git a/examples/chain_client/46_MessageBroadcasterWithoutSimulation.py b/examples/chain_client/46_MessageBroadcasterWithoutSimulation.py
@@ -0,0 +1,64 @@
+import asyncio
+
+from pyinjective.composer import Composer as ProtoMsgComposer
+from pyinjective.core.broadcaster import MsgBroadcasterWithPk
+from pyinjective.constant import Network
+from pyinjective.wallet import PrivateKey
+
+
+async def main() -> None:
+    # select network: local, testnet, mainnet
+    network = Network.testnet()
+    composer = ProtoMsgComposer(network=network.string())
+    private_key_in_hexa = "f9db9bf330e23cb7839039e944adef6e9df447b90b503d5b4464c90bea9022f3"
+
+    message_broadcaster = MsgBroadcasterWithPk.new_without_simulation(
+        network=network,
+        private_key=private_key_in_hexa,
+        use_secure_connection=True
+    )
+
+    priv_key = PrivateKey.from_hex(private_key_in_hexa)
+    pub_key = priv_key.to_public_key()
+    address = pub_key.to_address()
+    subaccount_id = address.get_subaccount_id(index=0)
+
+    # prepare trade info
+    fee_recipient = "inj1hkhdaj2a2clmq5jq6mspsggqs32vynpk228q3r"
+
+    spot_market_id_create = "0x0611780ba69656949525013d947713300f56c37b6175e02f26bffa495c3208fe"
+
+    spot_orders_to_create = [
+        composer.SpotOrder(
+            market_id=spot_market_id_create,
+            subaccount_id=subaccount_id,
+            fee_recipient=fee_recipient,
+            price=3,
+            quantity=55,
+            is_buy=True,
+            is_po=False
+        ),
+        composer.SpotOrder(
+            market_id=spot_market_id_create,
+            subaccount_id=subaccount_id,
+            fee_recipient=fee_recipient,
+            price=300,
+            quantity=55,
+            is_buy=False,
+            is_po=False
+        ),
+    ]
+
+    # prepare tx msg
+    msg = composer.MsgBatchUpdateOrders(
+        sender=address.to_acc_bech32(),
+        spot_orders_to_create=spot_orders_to_create,
+    )
+
+    # broadcast the transaction
+    result = await message_broadcaster.broadcast([msg])
+    print("---Transaction Response---")
+    print(result)
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(main())
diff --git a/examples/chain_client/47_MessageBroadcasterWithGranteeAccountWithoutSimulation.py b/examples/chain_client/47_MessageBroadcasterWithGranteeAccountWithoutSimulation.py
@@ -0,0 +1,54 @@
+import asyncio
+
+from pyinjective.composer import Composer as ProtoMsgComposer
+from pyinjective.async_client import AsyncClient
+from pyinjective.core.broadcaster import MsgBroadcasterWithPk
+from pyinjective.constant import Network
+from pyinjective.wallet import PrivateKey, Address
+
+
+async def main() -> None:
+    # select network: local, testnet, mainnet
+    network = Network.testnet()
+    composer = ProtoMsgComposer(network=network.string())
+
+    # initialize grpc client
+    client = AsyncClient(network, insecure=False)
+    await client.sync_timeout_height()
+
+    # load account
+    private_key_in_hexa = "5d386fbdbf11f1141010f81a46b40f94887367562bd33b452bbaa6ce1cd1381e"
+    priv_key = PrivateKey.from_hex(private_key_in_hexa)
+    pub_key = priv_key.to_public_key()
+    address = pub_key.to_address()
+
+    message_broadcaster = MsgBroadcasterWithPk.new_for_grantee_account_without_simulation(
+        network=network,
+        grantee_private_key=private_key_in_hexa,
+        use_secure_connection=True
+    )
+
+    # prepare tx msg
+    market_id = "0x0611780ba69656949525013d947713300f56c37b6175e02f26bffa495c3208fe"
+    granter_inj_address = "inj1hkhdaj2a2clmq5jq6mspsggqs32vynpk228q3r"
+    granter_address = Address.from_acc_bech32(granter_inj_address)
+    granter_subaccount_id = granter_address.get_subaccount_id(index=0)
+
+    msg = composer.MsgCreateSpotLimitOrder(
+        sender=granter_inj_address,
+        market_id=market_id,
+        subaccount_id=granter_subaccount_id,
+        fee_recipient=address.to_acc_bech32(),
+        price=7.523,
+        quantity=0.01,
+        is_buy=True,
+        is_po=False
+    )
+
+    # broadcast the transaction
+    result = await message_broadcaster.broadcast([msg])
+    print("---Transaction Response---")
+    print(result)
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(main())
diff --git a/examples/exchange_client/explorer_rpc/1_GetTxByHash.py b/examples/exchange_client/explorer_rpc/1_GetTxByHash.py
@@ -7,10 +7,10 @@
 
 async def main() -> None:
     # select network: local, testnet, mainnet
-    network = Network.testnet()
+    network = Network.mainnet()
     client = AsyncClient(network, insecure=False)
     composer = Composer(network=network.string())
-    tx_hash = "0F3EBEC1882E1EEAC5B7BDD836E976250F1CD072B79485877CEACCB92ACDDF52"
+    tx_hash = "50DD80270052D85835939A393127B5626917007E71A7ABD5205F1A094B976C1B"
     transaction_response = await client.get_tx_by_hash(tx_hash=tx_hash)
     print(transaction_response)
 
diff --git a/pyinjective/core/broadcaster.py b/pyinjective/core/broadcaster.py
@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from decimal import Decimal
-from typing import List, Optional
+from typing import Callable, List, Optional, Tuple
 
 import math
 from google.protobuf import any_pb2
@@ -9,6 +9,7 @@
 from pyinjective.async_client import AsyncClient
 from pyinjective.composer import Composer
 from pyinjective.constant import Network
+from pyinjective.proto.cosmos.authz.v1beta1 import tx_pb2 as cosmos_authz_tx_pb
 
 
 class BroadcasterAccountConfig(ABC):
@@ -86,6 +87,31 @@ def new_using_simulation(
         )
         return instance
 
+    @classmethod
+    def new_without_simulation(
+            cls,
+            network: Network,
+            private_key: str,
+            use_secure_connection: bool = True,
+            client: Optional[AsyncClient] = None,
+            composer: Optional[Composer] = None,
+    ):
+        client = client or AsyncClient(network=network, insecure=not (use_secure_connection))
+        composer = composer or Composer(network=client.network.string())
+        account_config = StandardAccountBroadcasterConfig(private_key=private_key)
+        fee_calculator = MessageBasedTransactionFeeCalculator(
+            client=client,
+            composer=composer
+        )
+        instance = cls(
+            network=network,
+            account_config=account_config,
+            client=client,
+            composer=composer,
+            fee_calculator=fee_calculator,
+        )
+        return instance
+
     @classmethod
     def new_for_grantee_account_using_simulation(
             cls,
@@ -111,6 +137,31 @@ def new_for_grantee_account_using_simulation(
         )
         return instance
 
+    @classmethod
+    def new_for_grantee_account_without_simulation(
+            cls,
+            network: Network,
+            grantee_private_key: str,
+            use_secure_connection: bool = True,
+            client: Optional[AsyncClient] = None,
+            composer: Optional[Composer] = None,
+    ):
+        client = client or AsyncClient(network=network, insecure=not (use_secure_connection))
+        composer = composer or Composer(network=client.network.string())
+        account_config = GranteeAccountBroadcasterConfig(grantee_private_key=grantee_private_key, composer=composer)
+        fee_calculator = MessageBasedTransactionFeeCalculator(
+            client=client,
+            composer=composer
+        )
+        instance = cls(
+            network=network,
+            account_config=account_config,
+            client=client,
+            composer=composer,
+            fee_calculator=fee_calculator,
+        )
+        return instance
+
     async def broadcast(self, messages: List[any_pb2.Any]):
         await self._client.sync_timeout_height()
         await self._client.get_account(self._account_config.trading_injective_address)
@@ -196,10 +247,16 @@ def messages_prepared_for_transaction(self, messages: List[any_pb2.Any]) -> List
 
 class SimulatedTransactionFeeCalculator(TransactionFeeCalculator):
 
-    def __init__(self, client: AsyncClient, composer: Composer, gas_price: Optional[int] = None):
+    def __init__(
+            self,
+            client: AsyncClient,
+            composer: Composer,
+            gas_price: Optional[int] = None,
+            gas_limit_adjustment_multiplier: Optional[Decimal] = None):
         self._client = client
         self._composer = composer
         self._gas_price = gas_price or self.DEFAULT_GAS_PRICE
+        self._gas_limit_adjustment_multiplier = gas_limit_adjustment_multiplier or Decimal("1.3")
 
     async def configure_gas_fee_for_transaction(
             self,
@@ -216,7 +273,7 @@ async def configure_gas_fee_for_transaction(
         if not success:
             raise RuntimeError(f"Transaction simulation error: {sim_res}")
 
-        gas_limit = math.ceil(Decimal(str(sim_res.gas_info.gas_used)) * Decimal("1.1"))
+        gas_limit = math.ceil(Decimal(str(sim_res.gas_info.gas_used)) * self._gas_limit_adjustment_multiplier)
 
         fee = [
             self._composer.Coin(
@@ -227,3 +284,95 @@ async def configure_gas_fee_for_transaction(
 
         transaction.with_gas(gas=gas_limit)
         transaction.with_fee(fee=fee)
+
+
+class MessageBasedTransactionFeeCalculator(TransactionFeeCalculator):
+    DEFAULT_GAS_LIMIT = 400_000
+    DEFAULT_EXCHANGE_GAS_LIMIT = 200_000
+
+    def __init__(
+            self,
+            client: AsyncClient,
+            composer: Composer,
+            gas_price: Optional[int] = None,
+            base_gas_limit: Optional[int] = None,
+            base_exchange_gas_limit: Optional[int] = None):
+        self._client = client
+        self._composer = composer
+        self._gas_price = gas_price or self.DEFAULT_GAS_PRICE
+        self._base_gas_limit = base_gas_limit or self.DEFAULT_GAS_LIMIT
+        self._base_exchange_gas_limit = base_exchange_gas_limit or self.DEFAULT_EXCHANGE_GAS_LIMIT
+
+        self._gas_limit_per_message_type_rules: List[Tuple[Callable, Decimal]] = [
+            (
+                lambda message: "MsgPrivilegedExecuteContract" in self._message_type(message=message),
+                Decimal("6") * self._base_gas_limit
+            ),
+            (
+                lambda message: "MsgExecuteContract" in self._message_type(message=message),
+                Decimal("2.5") * self._base_gas_limit
+            ),
+            (
+                lambda message: "wasm" in self._message_type(message=message),
+                Decimal("1.5") * self._base_gas_limit
+            ),
+            (
+                lambda message: "exchange" in self._message_type(message=message),
+                Decimal("1") * self._base_exchange_gas_limit
+            ),
+            (
+                lambda message: self._is_governance_message(message=message),
+                Decimal("15") * self._base_gas_limit
+            ),
+        ]
+
+    async def configure_gas_fee_for_transaction(
+            self,
+            transaction: Transaction,
+            private_key: PrivateKey,
+            public_key: PublicKey,
+    ):
+        transaction_gas_limit = math.ceil(self._calculate_gas_limit(messages=transaction.msgs))
+
+        fee = [
+            self._composer.Coin(
+                amount=math.ceil(self._gas_price * transaction_gas_limit),
+                denom=self._client.network.fee_denom,
+            )
+        ]
+
+        transaction.with_gas(gas=transaction_gas_limit)
+        transaction.with_fee(fee=fee)
+
+    def _message_type(self, message: any_pb2.Any) -> str:
+        if isinstance(message, any_pb2.Any):
+            message_type = message.type_url
+        else:
+            message_type = message.DESCRIPTOR.full_name
+        return message_type
+
+    def _is_governance_message(self, message: any_pb2.Any) -> bool:
+        message_type = self._message_type(message=message)
+        return "gov" in message_type and ("MsgDeposit" in message_type or "MsgSubmitProposal" in message_type)
+
+    def _calculate_gas_limit(self, messages: List[any_pb2.Any]) -> int:
+        total_gas_limit = Decimal("0")
+
+        for message in messages:
+            applying_rule = next(
+                (rule_tuple for rule_tuple in self._gas_limit_per_message_type_rules
+                 if rule_tuple[0](message)),
+                None
+            )
+
+            if applying_rule is None:
+                total_gas_limit += self._base_gas_limit
+            else:
+                total_gas_limit += applying_rule[1]
+
+            if self._message_type(message=message).endswith("MsgExec"):
+                exec_message = cosmos_authz_tx_pb.MsgExec.FromString(message.value)
+                sub_messages_limit = self._calculate_gas_limit(messages=exec_message.msgs)
+                total_gas_limit += sub_messages_limit
+
+        return math.ceil(total_gas_limit)
diff --git a/tests/core/test_message_based_transaction_fee_calculator.py b/tests/core/test_message_based_transaction_fee_calculator.py
