mx-sdk-py-cli/multiversx_sdk_cli/cli_output.py at 77963322979ff29b4528696247692aad68f2bd7a · multiversx/mx-sdk-py-cli · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import json
import logging
from collections import OrderedDict
from typing import Any, Optional, Union

from multiversx_sdk import Address, Transaction, TransactionOnNetwork

from multiversx_sdk_cli import utils
from multiversx_sdk_cli.utils import ISerializable

logger = logging.getLogger("cli.output")


class CLIOutputBuilder:
    def __init__(self) -> None:
        self.emitted_transaction_hash: Optional[str] = None
        self.emitted_transaction: Union[Transaction, None] = None
        self.emitted_transaction_omitted_fields: list[str] = []
        self.contract_address: Union[Address, None] = None
        self.transaction_on_network: Union[TransactionOnNetwork, None] = None
        self.transaction_on_network_omitted_fields: list[str] = []
        self.simulation_results: Union[ISerializable, None] = None

    def set_emitted_transaction_hash(self, hash: str):
        self.emitted_transaction_hash = hash
        return self

    def set_emitted_transaction(self, emitted_transaction: Transaction, omitted_fields: list[str] = []):
        self.emitted_transaction = emitted_transaction
        self.emitted_transaction_omitted_fields = omitted_fields
        return self

    def set_contract_address(self, contract_address: Address):
        self.contract_address = contract_address
        return self

    def set_awaited_transaction(self, awaited_transaction: TransactionOnNetwork, omitted_fields: list[str] = []):
        self.set_transaction_on_network(awaited_transaction, omitted_fields)
        self.set_emitted_transaction_hash(awaited_transaction.hash.hex())

    def set_transaction_on_network(
        self,
        transaction_on_network: TransactionOnNetwork,
        omitted_fields: list[str] = [],
    ):
        self.transaction_on_network = transaction_on_network
        self.transaction_on_network_omitted_fields = omitted_fields
        return self

    def set_simulation_results(self, simulation_results: ISerializable):
        self.simulation_results = simulation_results
        return self

    def build(self) -> dict[str, Any]:
        output: dict[str, Any] = OrderedDict()

        if self.emitted_transaction:
            emitted_transaction_dict = self.emitted_transaction.to_dictionary()
            emitted_transaction_hash = self.emitted_transaction_hash or ""
            emitted_transaction_data = self.emitted_transaction.data.decode()
            utils.omit_fields(emitted_transaction_dict, self.emitted_transaction_omitted_fields)

            output["emittedTransaction"] = emitted_transaction_dict
            output["emittedTransactionData"] = emitted_transaction_data
            output["emittedTransactionHash"] = emitted_transaction_hash

        if self.contract_address:
            contract_address = self.contract_address.to_bech32()
            output["contractAddress"] = contract_address

        if self.transaction_on_network:
            transaction_on_network_dict = self.transaction_on_network.raw
            utils.omit_fields(transaction_on_network_dict, self.transaction_on_network_omitted_fields)
            output["transactionOnNetwork"] = transaction_on_network_dict

        if self.simulation_results:
            output["simulation"] = self.simulation_results

        return output

    @classmethod
    def describe(
        cls,
        with_emitted: bool = True,
        with_contract: bool = False,
        with_transaction_on_network: bool = False,
        with_simulation: bool = False,
    ) -> str:
        output: dict[str, Any] = OrderedDict()

        if with_emitted:
            output["emittedTransaction"] = {
                "nonce": 42,
                "sender": "alice",
                "receiver": "bob",
                "...": "...",
            }
            output["emittedTransactionData"] = "the transaction data, not encoded"
            output["emittedTransactionHash"] = "the transaction hash"

        if with_contract:
            output["contractAddress"] = "the address of the contract"

        if with_transaction_on_network:
            output["transactionOnNetwork"] = {
                "nonce": 42,
                "sender": "alice",
                "receiver": "bob",
                "...": "...",
            }

        if with_simulation:
            output["simulation"] = {"execution": {"...": "..."}, "cost": {"...": "..."}}

        description = json.dumps(output, indent=4)
        description_wrapped = f"""

Output example:
===============
{description}
"""
        return description_wrapped