chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/cmds/show_funcs.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional, Union
+
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+
+async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[str, Any]) -> bool:
+    import time
+
+    from chia.cmds.cmds_util import format_bytes
+    from chia.consensus.block_record import BlockRecord
+    from chia.util.ints import uint64
+
+    blockchain_state = await node_client.get_blockchain_state()
+    if blockchain_state is None:
+        print("There is no blockchain found yet. Try again shortly")
+        return True
+    peak: Optional[BlockRecord] = blockchain_state["peak"]
+    node_id = blockchain_state["node_id"]
+    difficulty = blockchain_state["difficulty"]
+    sub_slot_iters = blockchain_state["sub_slot_iters"]
+    synced = blockchain_state["sync"]["synced"]
+    sync_mode = blockchain_state["sync"]["sync_mode"]
+    num_blocks: int = 10
+    network_name = config["selected_network"]
+    genesis_challenge = config["farmer"]["network_overrides"]["constants"][network_name]["GENESIS_CHALLENGE"]
+    full_node_port = config["full_node"]["port"]
+    full_node_rpc_port = config["full_node"]["rpc_port"]
+
+    print(f"Network: {network_name}    Port: {full_node_port}   RPC Port: {full_node_rpc_port}")
+    print(f"Node ID: {node_id}")
+    print(f"Genesis Challenge: {genesis_challenge}")
+
+    if synced:
+        print("Current Blockchain Status: Full Node Synced")
+        print("\nPeak: Hash:", bytes32(peak.header_hash) if peak is not None else "")
+    elif peak is not None and sync_mode:
+        sync_max_block = blockchain_state["sync"]["sync_tip_height"]
+        sync_current_block = blockchain_state["sync"]["sync_progress_height"]
+        print(
+            f"Current Blockchain Status: Syncing {sync_current_block}/{sync_max_block} "
+            f"({sync_max_block - sync_current_block} behind). "
+            f"({sync_current_block * 100.0 / sync_max_block:2.2f}% synced)"
+        )
+        print("Peak: Hash:", bytes32(peak.header_hash) if peak is not None else "")
+    elif peak is not None:
+        print(f"Current Blockchain Status: Not Synced. Peak height: {peak.height}")
+    else:
+        print("\nSearching for an initial chain\n")
+        print("You may be able to expedite with 'chia peer full_node -a host:port' using a known node.\n")
+
+    if peak is not None:
+        if peak.is_transaction_block:
+            peak_time = peak.timestamp
+        else:
+            peak_hash = bytes32(peak.header_hash)
+            curr = await node_client.get_block_record(peak_hash)
+            while curr is not None and not curr.is_transaction_block:
+                curr = await node_client.get_block_record(curr.prev_hash)
+            if curr is not None:
+                peak_time = curr.timestamp
+            else:
+                peak_time = uint64(0)
+        peak_time_struct = time.struct_time(time.localtime(peak_time))
+
+        print(
+            "      Time:",
+            f"{time.strftime('%a %b %d %Y %T %Z', peak_time_struct)}",
+            f"                 Height: {peak.height:>10}\n",
+        )
+
+        print("Estimated network space: ", end="")
+        print(format_bytes(blockchain_state["space"]))
+        print(f"Current difficulty: {difficulty}")
+        print(f"Current VDF sub_slot_iters: {sub_slot_iters}")
+        print("\n  Height: |   Hash:")
+
+        added_blocks: list[BlockRecord] = []
+        curr = await node_client.get_block_record(peak.header_hash)
+        while curr is not None and len(added_blocks) < num_blocks and curr.height > 0:
+            added_blocks.append(curr)
+            curr = await node_client.get_block_record(curr.prev_hash)
+
+        for b in added_blocks:
+            print(f"{b.height:>9} | {bytes32(b.header_hash)}")
+    else:
+        print("Blockchain has no blocks yet")
+    return False
+
+
+async def print_block_from_hash(
+    node_client: FullNodeRpcClient, config: dict[str, Any], block_by_header_hash: str
+) -> None:
+    import time
+
+    from chia.consensus.block_record import BlockRecord
+    from chia.types.blockchain_format.sized_bytes import bytes32
+    from chia.types.full_block import FullBlock
+    from chia.util.bech32m import encode_puzzle_hash
+
+    block: Optional[BlockRecord] = await node_client.get_block_record(bytes32.from_hexstr(block_by_header_hash))
+    full_block: Optional[FullBlock] = await node_client.get_block(bytes32.from_hexstr(block_by_header_hash))
+    # Would like to have a verbose flag for this
+    if block is not None:
+        assert full_block is not None
+        prev_b = await node_client.get_block_record(block.prev_hash)
+        if prev_b is not None:
+            difficulty = block.weight - prev_b.weight
+        else:
+            difficulty = block.weight
+        if block.is_transaction_block:
+            assert full_block.transactions_info is not None
+            block_time = time.struct_time(
+                time.localtime(
+                    full_block.foliage_transaction_block.timestamp if full_block.foliage_transaction_block else None
+                )
+            )
+            block_time_string = time.strftime("%a %b %d %Y %T %Z", block_time)
+            cost = str(full_block.transactions_info.cost)
+            tx_filter_hash: Union[str, bytes32] = "Not a transaction block"
+            if full_block.foliage_transaction_block:
+                tx_filter_hash = bytes32(full_block.foliage_transaction_block.filter_hash)
+            fees: Any = block.fees
+        else:
+            block_time_string = "Not a transaction block"
+            cost = "Not a transaction block"
+            tx_filter_hash = "Not a transaction block"
+            fees = "Not a transaction block"
+        address_prefix = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"]
+        farmer_address = encode_puzzle_hash(block.farmer_puzzle_hash, address_prefix)
+        pool_address = encode_puzzle_hash(block.pool_puzzle_hash, address_prefix)
+        pool_pk = (
+            full_block.reward_chain_block.proof_of_space.pool_public_key
+            if full_block.reward_chain_block.proof_of_space.pool_public_key is not None
+            else "Pay to pool puzzle hash"
+        )
+        print(
+            f"Block Height           {block.height}\n"
+            f"Header Hash            0x{block.header_hash.hex()}\n"
+            f"Timestamp              {block_time_string}\n"
+            f"Weight                 {block.weight}\n"
+            f"Previous Block         0x{block.prev_hash.hex()}\n"
+            f"Difficulty             {difficulty}\n"
+            f"Sub-slot iters         {block.sub_slot_iters}\n"
+            f"Cost                   {cost}\n"
+            f"Total VDF Iterations   {block.total_iters}\n"
+            f"Is a Transaction Block?{block.is_transaction_block}\n"
+            f"Deficit                {block.deficit}\n"
+            f"PoSpace 'k' Size       {full_block.reward_chain_block.proof_of_space.size}\n"
+            f"Plot Public Key        0x{full_block.reward_chain_block.proof_of_space.plot_public_key}\n"
+            f"Pool Public Key        {pool_pk}\n"
+            f"Tx Filter Hash         {tx_filter_hash}\n"
+            f"Farmer Address         {farmer_address}\n"
+            f"Pool Address           {pool_address}\n"
+            f"Fees Amount            {fees}\n"
+        )
+    else:
+        print("Block with header hash", block_by_header_hash, "not found")
+
+
+async def print_fee_info(node_client: FullNodeRpcClient) -> None:
+    target_times = [60, 120, 300]
+    target_times_names = ["1  minute", "2 minutes", "5 minutes"]
+    res = await node_client.get_fee_estimate(target_times=target_times, cost=1)
+    print(json.dumps(res))
+    print("\n")
+    print(f"  Mempool max cost: {res['mempool_max_size']:>12} CLVM cost")
+    print(f"      Mempool cost: {res['mempool_size']:>12} CLVM cost")
+    print(f"     Mempool count: {res['num_spends']:>12} spends")
+    print(f"   Fees in Mempool: {res['mempool_fees']:>12} mojos")
+    print()
+
+    print("Stats for last transaction block:")
+    print(f"      Block height: {res['last_tx_block_height']:>12}")
+    print(f"        Block fees: {res['fees_last_block']:>12} mojos")
+    print(f"        Block cost: {res['last_block_cost']:>12} CLVM cost")
+    print(f"          Fee rate: {res['fee_rate_last_block']:>12.5} mojos per CLVM cost")
+
+    print("\nFee Rate Estimates:")
+    max_name_len = max(len(name) for name in target_times_names)
+    for n, e in zip(target_times_names, res["estimates"]):
+        print(f"    {n:>{max_name_len}}: {e:.3f} mojo per CLVM cost")
+    print("")
+
+
+async def show_async(
+    rpc_port: Optional[int],
+    root_path: Path,
+    print_fee_info_flag: bool,
+    print_state: bool,
+    block_header_hash_by_height: Optional[int],
+    block_by_header_hash: str,
+) -> None:
+    from chia.cmds.cmds_util import get_any_service_client
+
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (node_client, config):
+        # Check State
+        if print_state:
+            if await print_blockchain_state(node_client, config) is True:
+                return None  # if no blockchain is found
+        if print_fee_info_flag:
+            await print_fee_info(node_client)
+        # Get Block Information
+        if block_header_hash_by_height is not None:
+            block_header = await node_client.get_block_record_by_height(block_header_hash_by_height)
+            if block_header is not None:
+                print(f"Header hash of block {block_header_hash_by_height}: {block_header.header_hash.hex()}")
+            else:
+                print("Block height", block_header_hash_by_height, "not found")
+        if block_by_header_hash != "":
+            await print_block_from_hash(node_client, config, block_by_header_hash)

chia/cmds/signer.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+import itertools
+import os
+import time
+from collections.abc import Sequence
+from dataclasses import replace
+from pathlib import Path
+from threading import Event, Thread
+from typing import TypeVar
+
+import click
+from chia_rs import AugSchemeMPL, G2Element
+from hsms.util.byte_chunks import create_chunks_for_blob, optimal_chunk_size_for_max_chunk_size
+from segno import QRCode, make_qr
+
+from chia.cmds.cmd_classes import chia_command, command_helper, option
+from chia.cmds.cmd_helpers import NeedsWalletRPC, TransactionsIn, TransactionsOut
+from chia.rpc.util import ALL_TRANSLATION_LAYERS
+from chia.rpc.wallet_request_types import (
+    ApplySignatures,
+    ExecuteSigningInstructions,
+    GatherSigningInfo,
+    PushTransactions,
+)
+from chia.util.streamable import Streamable
+from chia.wallet.signer_protocol import SignedTransaction, SigningInstructions, SigningResponse, Spend
+from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.clvm_streamable import byte_deserialize_clvm_streamable, byte_serialize_clvm_streamable
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+
+def _clear_screen() -> None:
+    # Cross-platform screen clear
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+@click.group("signer", help="Get information for an external signer")
+def signer_cmd() -> None:
+    pass  # pragma: no cover
+
+
+@command_helper
+class QrCodeDisplay:
+    qr_density: int = option(
+        "--qr-density",
+        "-d",
+        type=int,
+        help="The maximum number of bytes contained in a single qr code",
+        default=100,
+        show_default=True,
+    )
+    rotation_speed: int = option(
+        "--rotation-speed",
+        "-w",
+        type=int,
+        help="How many seconds delay between switching QR codes when there are multiple",
+        default=2,
+        show_default=True,
+    )
+
+    def _display_qr(self, index: int, max_index: int, code_list: list[QRCode], stop_event: Event) -> None:
+        while not stop_event.is_set():
+            for qr_code in itertools.cycle(code_list):
+                _clear_screen()
+                qr_code.terminal(compact=True)
+                print(f"Displaying QR Codes ({index + 1}/{max_index})")
+                print("<Press Enter to move to next QR code>")
+
+                for _ in range(self.rotation_speed * 100):
+                    time.sleep(0.01)
+                    if stop_event.is_set():
+                        return
+
+    def display_qr_codes(self, blobs: list[bytes]) -> None:
+        chunk_sizes = [optimal_chunk_size_for_max_chunk_size(len(blob), self.qr_density) for blob in blobs]
+        chunks = [create_chunks_for_blob(blob, chunk_size) for blob, chunk_size in zip(blobs, chunk_sizes)]
+        qr_codes = [[make_qr(chunk) for chunk in chks] for chks in chunks]
+
+        for i, qr_code_list in enumerate(qr_codes):
+            stop_event = Event()
+            t = Thread(target=self._display_qr, args=(i, len(qr_codes), qr_code_list, stop_event))
+            t.start()
+
+            try:
+                input("")
+            finally:
+                stop_event.set()
+                t.join()
+                stop_event.clear()
+
+
+@command_helper
+class _SPTranslation:
+    translation: str = option(
+        "--translation",
+        "-c",
+        type=click.Choice(["none", "CHIP-0028"]),
+        default="none",
+        help="Wallet Signer Protocol CHIP to use for translation of output",
+    )
+
+
+_T_ClvmStreamable = TypeVar("_T_ClvmStreamable", bound=Streamable)
+
+
+@command_helper
+class SPIn(_SPTranslation):
+    signer_protocol_input: Sequence[str] = option(
+        "--signer-protocol-input",
+        "-p",
+        type=str,
+        help="Signer protocol objects (signatures, signing instructions, etc.) as files to load as input",
+        multiple=True,
+        required=True,
+    )
+
+    def read_sp_input(self, typ: type[_T_ClvmStreamable]) -> list[_T_ClvmStreamable]:
+        final_list: list[_T_ClvmStreamable] = []
+        for filename in self.signer_protocol_input:
+            with open(Path(filename), "rb") as file:
+                final_list.append(
+                    byte_deserialize_clvm_streamable(
+                        file.read(),
+                        typ,
+                        translation_layer=(
+                            ALL_TRANSLATION_LAYERS[self.translation] if self.translation != "none" else None
+                        ),
+                    )
+                )
+
+        return final_list
+
+
+@command_helper
+class SPOut(QrCodeDisplay, _SPTranslation):
+    output_format: str = option(
+        "--output-format",
+        "-t",
+        type=click.Choice(["hex", "file", "qr"]),
+        default="hex",
+        help="How to output the information to transfer to an external signer",
+    )
+    output_file: Sequence[str] = option(
+        "--output-file",
+        "-b",
+        type=str,
+        multiple=True,
+        help="The file(s) to output to (if --output-format=file)",
+    )
+
+    def handle_clvm_output(self, outputs: list[Streamable]) -> None:
+        translation_layer = ALL_TRANSLATION_LAYERS[self.translation] if self.translation != "none" else None
+        if self.output_format == "hex":
+            for output in outputs:
+                print(byte_serialize_clvm_streamable(output, translation_layer=translation_layer).hex())
+        if self.output_format == "file":
+            if len(self.output_file) == 0:
+                print("--output-format=file specified without any --output-file")
+                return
+            elif len(self.output_file) != len(outputs):
+                print(
+                    "Incorrect number of file outputs specified, "
+                    f"expected: {len(outputs)} got {len(self.output_file)}"
+                )
+                return
+            else:
+                for filename, output in zip(self.output_file, outputs):
+                    with open(Path(filename), "wb") as file:
+                        file.write(byte_serialize_clvm_streamable(output, translation_layer=translation_layer))
+        if self.output_format == "qr":
+            self.display_qr_codes(
+                [byte_serialize_clvm_streamable(output, translation_layer=translation_layer) for output in outputs]
+            )
+
+
+@chia_command(
+    group=signer_cmd,
+    name="gather_signing_info",
+    short_help="gather signer information",
+    help="Gather the information from a transaction that a signer needs in order to create a signature",
+)
+class GatherSigningInfoCMD:
+    sp_out: SPOut
+    txs_in: TransactionsIn
+    rpc_info: NeedsWalletRPC
+
+    async def run(self) -> None:
+        async with self.rpc_info.wallet_rpc() as wallet_rpc:
+            spends: list[Spend] = [
+                Spend.from_coin_spend(cs)
+                for tx in self.txs_in.transaction_bundle.txs
+                if tx.spend_bundle is not None
+                for cs in tx.spend_bundle.coin_spends
+            ]
+            signing_instructions: SigningInstructions = (
+                await wallet_rpc.client.gather_signing_info(GatherSigningInfo(spends=spends))
+            ).signing_instructions
+            self.sp_out.handle_clvm_output([signing_instructions])
+
+
+@chia_command(
+    group=signer_cmd,
+    name="apply_signatures",
+    short_help="apply signatures",
+    help="Apply a signer's signatures to a transaction bundle",
+)
+class ApplySignaturesCMD:
+    txs_out: TransactionsOut
+    sp_in: SPIn
+    txs_in: TransactionsIn
+    rpc_info: NeedsWalletRPC
+
+    async def run(self) -> None:
+        async with self.rpc_info.wallet_rpc() as wallet_rpc:
+            signing_responses: list[SigningResponse] = self.sp_in.read_sp_input(SigningResponse)
+            spends: list[Spend] = [
+                Spend.from_coin_spend(cs)
+                for tx in self.txs_in.transaction_bundle.txs
+                if tx.spend_bundle is not None
+                for cs in tx.spend_bundle.coin_spends
+            ]
+            signed_transactions: list[SignedTransaction] = (
+                await wallet_rpc.client.apply_signatures(
+                    ApplySignatures(spends=spends, signing_responses=signing_responses)
+                )
+            ).signed_transactions
+            signed_spends: list[Spend] = [spend for tx in signed_transactions for spend in tx.transaction_info.spends]
+            final_signature: G2Element = G2Element()
+            for signature in [sig for tx in signed_transactions for sig in tx.signatures]:
+                if signature.type != "bls_12381_aug_scheme":  # pragma: no cover
+                    print("No external spot for non BLS signatures in a spend")
+                    return
+                final_signature = AugSchemeMPL.aggregate([final_signature, G2Element.from_bytes(signature.signature)])
+            new_spend_bundle = WalletSpendBundle([spend.as_coin_spend() for spend in signed_spends], final_signature)
+            new_transactions: list[TransactionRecord] = [
+                replace(
+                    self.txs_in.transaction_bundle.txs[0], spend_bundle=new_spend_bundle, name=new_spend_bundle.name()
+                ),
+                *(replace(tx, spend_bundle=None) for tx in self.txs_in.transaction_bundle.txs[1:]),
+            ]
+            self.txs_out.handle_transaction_output(new_transactions)
+
+
+@chia_command(
+    group=signer_cmd,
+    name="execute_signing_instructions",
+    short_help="execute signing instructions",
+    help="Given some signing instructions, return signing responses",
+)
+class ExecuteSigningInstructionsCMD:
+    sp_out: SPOut
+    sp_in: SPIn
+    rpc_info: NeedsWalletRPC
+
+    async def run(self) -> None:
+        async with self.rpc_info.wallet_rpc() as wallet_rpc:
+            signing_instructions: list[SigningInstructions] = self.sp_in.read_sp_input(SigningInstructions)
+            self.sp_out.handle_clvm_output(
+                [
+                    signing_response
+                    for instruction_set in signing_instructions
+                    for signing_response in (
+                        await wallet_rpc.client.execute_signing_instructions(
+                            ExecuteSigningInstructions(signing_instructions=instruction_set, partial_allowed=True)
+                        )
+                    ).signing_responses
+                ]
+            )
+
+
+@chia_command(
+    name="push_transactions",
+    short_help="push transaction bundle",
+    help="Push a transaction bundle to the wallet to send to the network",
+)
+class PushTransactionsCMD:
+    txs_in: TransactionsIn
+    rpc_info: NeedsWalletRPC
+
+    async def run(self) -> None:
+        async with self.rpc_info.wallet_rpc() as wallet_rpc:
+            # TODO: provide access to additional parameters instead of filling with the defaults constant
+            await wallet_rpc.client.push_transactions(
+                PushTransactions(transactions=self.txs_in.transaction_bundle.txs), DEFAULT_TX_CONFIG
+            )
+
+
+# Uncomment this for testing of qr code display
+# @chia_command(signer_cmd, "temp", "")
+# class Temp:
+#     qr: QrCodeDisplay
+#
+#     def run(self) -> None:
+#         self.qr.display_qr_codes([bytes([1] * 200), bytes([2] * 200)])