Merge pull request #225 from InjectiveLabs/feat/message_broadcaster

aarmoa · web-flow · commit f4db6f2800ed · 2023-08-17T20:54:28.000+02:00
Feat/message broadcaster
diff --git a/README.md b/README.md
@@ -87,6 +87,9 @@ make tests
 ```
 
 ### Changelogs
+**0.7.1**
+* Include implementation of the MessageBroadcaster, to simplify the transaction creation and broadcasting process.
+
 **0.7.0.6**
 * ADD SEI/USDT in metadata
 
diff --git a/examples/chain_client/44_MessageBroadcaster.py b/examples/chain_client/44_MessageBroadcaster.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_using_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/45_MessageBroadcasterWithGranteeAccount.py b/examples/chain_client/45_MessageBroadcasterWithGranteeAccount.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_using_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/pyinjective/constant.py b/pyinjective/constant.py
@@ -94,13 +94,33 @@ def devnet(cls):
         )
 
     @classmethod
-    def testnet(cls):
+    def testnet(cls, node="lb"):
+        nodes = [
+            "lb",
+            "sentry",
+        ]
+        if node not in nodes:
+            raise ValueError('Must be one of {}'.format(nodes))
+
+        if node == 'lb':
+            lcd_endpoint = 'https://k8s.testnet.lcd.injective.network',
+            tm_websocket_endpoint = 'wss://k8s.testnet.tm.injective.network/websocket',
+            grpc_endpoint = 'k8s.testnet.chain.grpc.injective.network:443',
+            grpc_exchange_endpoint = 'k8s.testnet.exchange.grpc.injective.network:443',
+            grpc_explorer_endpoint = 'k8s.testnet.explorer.grpc.injective.network:443',
+        else:
+            lcd_endpoint = 'https://testnet.lcd.injective.network'
+            tm_websocket_endpoint = 'wss://testnet.tm.injective.network/websocket'
+            grpc_endpoint = 'testnet.chain.grpc.injective.network'
+            grpc_exchange_endpoint = 'testnet.exchange.grpc.injective.network'
+            grpc_explorer_endpoint = 'testnet.explorer.grpc.injective.network'
+
         return cls(
-            lcd_endpoint='https://k8s.testnet.lcd.injective.network',
-            tm_websocket_endpoint='wss://k8s.testnet.tm.injective.network/websocket',
-            grpc_endpoint='k8s.testnet.chain.grpc.injective.network:443',
-            grpc_exchange_endpoint='k8s.testnet.exchange.grpc.injective.network:443',
-            grpc_explorer_endpoint='k8s.testnet.explorer.grpc.injective.network:443',
+            lcd_endpoint=lcd_endpoint,
+            tm_websocket_endpoint=tm_websocket_endpoint,
+            grpc_endpoint=grpc_endpoint,
+            grpc_exchange_endpoint=grpc_exchange_endpoint,
+            grpc_explorer_endpoint=grpc_explorer_endpoint,
             chain_id='injective-888',
             fee_denom='inj',
             env='testnet'
diff --git a/pyinjective/core/broadcaster.py b/pyinjective/core/broadcaster.py
@@ -0,0 +1,229 @@
+from abc import ABC, abstractmethod
+from decimal import Decimal
+from typing import List, Optional
+
+import math
+from google.protobuf import any_pb2
+
+from pyinjective import PrivateKey, Transaction, PublicKey
+from pyinjective.async_client import AsyncClient
+from pyinjective.composer import Composer
+from pyinjective.constant import Network
+
+
+class BroadcasterAccountConfig(ABC):
+
+    @property
+    @abstractmethod
+    def trading_injective_address(self) -> str:
+        ...
+
+    @property
+    @abstractmethod
+    def trading_private_key(self) -> PrivateKey:
+        ...
+
+    @property
+    @abstractmethod
+    def trading_public_key(self) -> PublicKey:
+        ...
+
+    @abstractmethod
+    def messages_prepared_for_transaction(self, messages: List[any_pb2.Any]) -> List[any_pb2.Any]:
+        ...
+
+
+class TransactionFeeCalculator (ABC):
+    DEFAULT_GAS_PRICE = 500_000_000
+
+    @abstractmethod
+    async def configure_gas_fee_for_transaction(
+            self,
+            transaction: Transaction,
+            private_key: PrivateKey,
+            public_key: PublicKey,
+    ):
+        ...
+
+
+class MsgBroadcasterWithPk:
+
+    def __init__(
+            self,
+            network: Network,
+            account_config: BroadcasterAccountConfig,
+            client: AsyncClient,
+            composer: Composer,
+            fee_calculator: TransactionFeeCalculator):
+        self._network = network
+        self._account_config = account_config
+        self._client = client
+        self._composer = composer
+        self._fee_calculator = fee_calculator
+
+    @classmethod
+    def new_using_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 = SimulatedTransactionFeeCalculator(
+            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,
+            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 = SimulatedTransactionFeeCalculator(
+            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)
+
+        messages_for_transaction = self._account_config.messages_prepared_for_transaction(messages=messages)
+
+        transaction = Transaction()
+        transaction.with_messages(*messages_for_transaction)
+        transaction.with_sequence(self._client.get_sequence())
+        transaction.with_account_num(self._client.get_number())
+        transaction.with_chain_id(self._network.chain_id)
+
+        await self._fee_calculator.configure_gas_fee_for_transaction(
+            transaction=transaction,
+            private_key=self._account_config.trading_private_key,
+            public_key=self._account_config.trading_public_key,
+        )
+        transaction.with_memo("")
+        transaction.with_timeout_height(timeout_height=self._client.timeout_height)
+
+        sign_doc = transaction.get_sign_doc(self._account_config.trading_public_key)
+        sig = self._account_config.trading_private_key.sign(sign_doc.SerializeToString())
+        tx_raw_bytes = transaction.get_tx_data(sig, self._account_config.trading_public_key)
+
+        # broadcast tx: send_tx_async_mode, send_tx_sync_mode
+        transaction_result = await self._client.send_tx_sync_mode(tx_raw_bytes)
+
+        return transaction_result
+
+
+class StandardAccountBroadcasterConfig(BroadcasterAccountConfig):
+
+    def __init__(self, private_key: str):
+        self._private_key = PrivateKey.from_hex(private_key)
+        self._public_key = self._private_key.to_public_key()
+        self._address = self._public_key.to_address()
+
+    @property
+    def trading_injective_address(self) -> str:
+        return self._address.to_acc_bech32()
+
+    @property
+    def trading_private_key(self) -> PrivateKey:
+        return self._private_key
+
+    @property
+    def trading_public_key(self) -> PublicKey:
+        return self._public_key
+
+    def messages_prepared_for_transaction(self, messages: List[any_pb2.Any]) -> List[any_pb2.Any]:
+        # For standard account the messages do not need to be addapted
+        return messages
+
+
+class GranteeAccountBroadcasterConfig(BroadcasterAccountConfig):
+
+    def __init__(self, grantee_private_key: str, composer: Composer):
+        self._grantee_private_key = PrivateKey.from_hex(grantee_private_key)
+        self._grantee_public_key = self._grantee_private_key.to_public_key()
+        self._grantee_address = self._grantee_public_key.to_address()
+        self._composer = composer
+
+    @property
+    def trading_injective_address(self) -> str:
+        return self._grantee_address.to_acc_bech32()
+
+    @property
+    def trading_private_key(self) -> PrivateKey:
+        return self._grantee_private_key
+
+    @property
+    def trading_public_key(self) -> PublicKey:
+        return self._grantee_public_key
+
+    def messages_prepared_for_transaction(self, messages: List[any_pb2.Any]) -> List[any_pb2.Any]:
+        exec_message = self._composer.MsgExec(
+            grantee=self.trading_injective_address,
+            msgs=messages,
+        )
+
+        return [exec_message]
+
+
+class SimulatedTransactionFeeCalculator(TransactionFeeCalculator):
+
+    def __init__(self, client: AsyncClient, composer: Composer, gas_price: Optional[int] = None):
+        self._client = client
+        self._composer = composer
+        self._gas_price = gas_price or self.DEFAULT_GAS_PRICE
+
+    async def configure_gas_fee_for_transaction(
+            self,
+            transaction: Transaction,
+            private_key: PrivateKey,
+            public_key: PublicKey,
+    ):
+        sim_sign_doc = transaction.get_sign_doc(public_key)
+        sim_sig = private_key.sign(sim_sign_doc.SerializeToString())
+        sim_tx_raw_bytes = transaction.get_tx_data(sim_sig, public_key)
+
+        # simulate tx
+        (sim_res, success) = await self._client.simulate_tx(sim_tx_raw_bytes)
+        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"))
+
+        fee = [
+            self._composer.Coin(
+                amount=self._gas_price * gas_limit,
+                denom=self._client.network.fee_denom,
+            )
+        ]
+
+        transaction.with_gas(gas=gas_limit)
+        transaction.with_fee(fee=fee)
diff --git a/setup.py b/setup.py
