chia-blockchain 2.4.4__py3-none-any.whl

chia/_tests/tools/config.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import sys
+
+legacy_keyring_required = sys.platform == "linux"

chia/_tests/tools/test_full_sync.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import pytest
+
+from chia._tests.util.full_sync import run_sync_test
+
+
+@pytest.mark.parametrize("keep_up", [True, False])
+def test_full_sync_test(keep_up: bool) -> None:
+    file_path = os.path.realpath(__file__)
+    db_file = Path(file_path).parent / "test-blockchain-db.sqlite"
+    asyncio.run(
+        run_sync_test(
+            db_file,
+            db_version=2,
+            profile=False,
+            single_thread=False,
+            test_constants=False,
+            keep_up=keep_up,
+            db_sync="off",
+            node_profiler=False,
+            start_at_checkpoint=None,
+        )
+    )

chia/_tests/tools/test_legacy_keyring.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner, Result
+
+try:
+    from keyrings.cryptfile.cryptfile import CryptFileKeyring
+except ImportError:
+    if sys.platform == "linux":
+        raise
+
+from chia.legacy.keyring import create_legacy_keyring, generate_and_add, get_keys, legacy_keyring
+
+
+def show() -> Result:
+    return CliRunner().invoke(legacy_keyring, ["show"])
+
+
+def clear(input_str: str) -> Result:
+    return CliRunner().invoke(legacy_keyring, ["clear"], input=f"{input_str}\n")
+
+
+@pytest.mark.skipif(sys.platform == "win32" or sys.platform == "darwin", reason="Tests the linux legacy keyring format")
+def test_legacy_keyring_format(tmp_dir: Path) -> None:
+    keyring = CryptFileKeyring()
+    keyring.keyring_key = "your keyring password"
+    # Create the legacy keyring file with the old format
+    keyring.file_path = tmp_dir / "keyring"
+    keyring.filename = keyring.file_path.name
+    keyring_data = """
+    [chia_2Duser_2Dchia_2D1_2E8]
+    wallet_2duser_2dchia_2d1_2e8_2d0 =
+            eyJzYWx0IjogIi9NY3J3UG9iQjdiclpQMGRHclZiU1E9PSIsICJkYXRhIjogIjBnMEROUzRDSGdJ
+            NU4yVEFYUVVhaExFY2RzN0NFR05rNnpKSmNLcWY5VmdOb2h6SkdxcUlOZzNKaTBEa3NIOGh3aHlM
+            cG1GeFZVYWRcbmRtMTVWMDlsU3I1b3dNZDZHY3JGQTJHckZtZGszUmFmY0ZicmhlMmlRMjMzRW1P
+            c28zQUxNbG5CcGtWTlR0cHZYYjlzbEp4VE5yVVVcbm8xUE0wNytTa1lJTHVzcmlNUStkUjBIQkxZ
+            WXF3VjBUVndETHVKZmdtNWdyd1hrUkdkUjdvU0VyVTJUcnRnPT0iLCAibWFjIjogInA4MWJFTXhJ
+            ay83bm1iMDMxR0NpZnc9PSIsICJub25jZSI6ICJzcUhoTUhOMkZQeTQxR3U4em40MXhBPT0ifQ==
+    wallet_2duser_2dchia_2d1_2e8_2d1 =
+            eyJzYWx0IjogIjNhWkFCQXBCcXUxdzI5WHpJcXBzS3c9PSIsICJkYXRhIjogImZwU05ZYk5WMmJM
+            Vms5MjB6cGYzdzYrK2ZMc2w4b3Y4OU9uTWdHNlo4OXhzenRoc0tFZjdieHVKVGRyT3JmYmtBUmgv
+            TzhzY3R1R2ZcblR1REVIOHJHNVA3RGpOWWQ3dFhxd2xabkg1VTVnV2VCNzZPaXdmVDQxQytxWlVX
+            RXQ5L1dnMTQybHdqMy8vR2pJZ0w2d2Q0QXQyWjBcbmtQQVNOMnVnVmZpa0RiZGFaN21oeFRxNnRK
+            TEszQWtLU3VPVmJyWEplbjZ2OGhXcGNMVU1HN3RIZENWNU5nPT0iLCAibWFjIjogIitPS3h1ZjZQ
+            RzArdTA2Z2Qzb2dSNGc9PSIsICJub25jZSI6ICIxdWR2N1JIajhWaER2UWpVSjRJLzZnPT0ifQ==
+    """
+    with open(str(keyring.file_path), "w") as keyring_file:
+        keyring_file.write(keyring_data)
+    # Make sure the loaded keys match the file content
+    keys = get_keys(keyring)
+    assert len(keys) == 2
+    assert keys[0].fingerprint == 1925978301
+    assert keys[1].fingerprint == 2990446712
+
+
+def test_legacy_keyring_cli() -> None:
+    keyring = create_legacy_keyring()
+    result = show()
+    assert result.exit_code == 1
+    assert "No keys found in the legacy keyring." in result.output
+    keys = []
+    for i in range(5):
+        keys.append(generate_and_add(keyring))
+        result = show()
+        assert result.exit_code == 0
+        for key in keys:
+            assert key.mnemonic_str() in result.output
+
+    # Should abort if the prompt gets a `n`
+    result = clear("n")
+    assert result.exit_code == 1
+    assert "Aborted" in result.output
+
+    # And succeed if the prompt gets a `y`
+    result = clear("y")
+    assert result.exit_code == 0
+    for key in keys:
+        assert key.mnemonic_str() in result.output
+    assert f"{len(keys)} keys removed" in result.output

chia/_tests/tools/test_run_block.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import List
+
+from chia._tests.util.run_block import run_json_block
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.condition_with_args import ConditionWithArgs
+from chia.util.hash import std_hash
+from chia.util.ints import uint8, uint32, uint64, uint128
+
+AGG_SIG_DATA = bytes32.fromhex("ae83525ba8d1dd3f09b277de18ca3e43fc0af20d20c4b3e92ef2a48bd291ccb2")
+
+constants = DEFAULT_CONSTANTS.replace(
+    AGG_SIG_ME_ADDITIONAL_DATA=AGG_SIG_DATA,
+    AGG_SIG_PARENT_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([43])),
+    AGG_SIG_PUZZLE_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([44])),
+    AGG_SIG_AMOUNT_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([45])),
+    AGG_SIG_PUZZLE_AMOUNT_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([46])),
+    AGG_SIG_PARENT_AMOUNT_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([47])),
+    AGG_SIG_PARENT_PUZZLE_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([48])),
+    DIFFICULTY_CONSTANT_FACTOR=uint128(10052721566054),
+    DIFFICULTY_STARTING=uint64(30),
+    EPOCH_BLOCKS=uint32(768),
+    GENESIS_CHALLENGE=bytes32.fromhex("ae83525ba8d1dd3f09b277de18ca3e43fc0af20d20c4b3e92ef2a48bd291ccb2"),
+    GENESIS_PRE_FARM_FARMER_PUZZLE_HASH=bytes32.fromhex(
+        "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
+    ),
+    GENESIS_PRE_FARM_POOL_PUZZLE_HASH=bytes32.fromhex(
+        "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
+    ),
+    MEMPOOL_BLOCK_BUFFER=uint8(10),
+    MIN_PLOT_SIZE=uint8(18),
+)
+retire_bytes = (
+    b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+)
+
+
+def find_retirement(tocheck: List[ConditionWithArgs]) -> bool:
+    for c in tocheck:
+        if c.opcode != ConditionOpcode.CREATE_COIN:
+            continue
+        if len(c.vars) < 3:
+            continue
+        if c.vars[2] == retire_bytes:
+            return True
+
+    return False
+
+
+def test_block_no_generator():
+    dirname = Path(__file__).parent
+    with open(dirname / "300000.json") as f:
+        full_block = json.load(f)
+
+    cat_list = run_json_block(full_block, dirname, constants)
+
+    assert not cat_list
+
+
+def test_block_retired_cat_with_memo():
+    dirname = Path(__file__).parent
+    with open(dirname / "1315630.json") as f:
+        full_block = json.load(f)
+
+    cat_list = run_json_block(full_block, dirname, constants)
+
+    assert cat_list
+    assert cat_list[0].asset_id == "c2808f37e758b713150da4860091dd94a90a781bc4f18377d20de6291b3d506d"
+    assert cat_list[0].memo == "Hello, please find me, I'm a memo!"
+    assert cat_list[0].npc.coin_name.hex() == "cc6dca2748865d77eb411e3a44827ad970a0cd8488ad26f6a83842fe4e0e4054"
+    assert cat_list[0].npc.puzzle_hash.hex() == "c621cd597aa525338d3e4e499a34e0d0b1040304a2f4766b48a368aa57d3ab6f"
+    found = False
+    for cond in cat_list[0].npc.conditions:
+        if cond[0] != ConditionOpcode.CREATE_COIN:
+            continue
+        found |= find_retirement(cond[1])
+    assert found
+
+
+def test_block_retired_cat_no_memo():
+    dirname = Path(__file__).parent
+    with open(dirname / "1315544.json") as f:
+        full_block = json.load(f)
+
+    cat_list = run_json_block(full_block, dirname, constants)
+
+    assert cat_list
+    assert cat_list[0].asset_id == "c2808f37e758b713150da4860091dd94a90a781bc4f18377d20de6291b3d506d"
+    assert not cat_list[0].memo
+    assert cat_list[0].npc.coin_name.hex() == "90941ac42b92aad0ed1de5d599d854072fcf1f4bb82cd37e365852f0a730cf5d"
+    assert cat_list[0].npc.puzzle_hash.hex() == "20a2284ec41cdcc3c54e6b44f8801db2dc28f3aa01c115674b598757d62f09a6"
+
+    found = False
+    for cond in cat_list[0].npc.conditions:
+        if cond[0] != ConditionOpcode.CREATE_COIN:
+            continue
+        found |= find_retirement(cond[1])
+    assert found
+
+
+def test_block_cat():
+    dirname = Path(__file__).parent
+    with open(dirname / "1315537.json") as f:
+        full_block = json.load(f)
+
+    cat_list = run_json_block(full_block, dirname, constants)
+
+    assert cat_list
+    assert cat_list[0].asset_id == "c2808f37e758b713150da4860091dd94a90a781bc4f18377d20de6291b3d506d"
+    assert not cat_list[0].memo
+    assert cat_list[0].npc.coin_name.hex() == "6fb12ab32556537803112badcfaf828bfe1b79eb4181b3adc5d571680295ce6c"
+    assert cat_list[0].npc.puzzle_hash.hex() == "20a2284ec41cdcc3c54e6b44f8801db2dc28f3aa01c115674b598757d62f09a6"
+
+
+def test_generator_ref():
+    """Run a block containing a back reference without error"""
+    dirname = Path(__file__).parent
+    with open(dirname / "466212.json") as f:
+        full_block = json.load(f)
+
+    cat_list = run_json_block(full_block, dirname, constants)
+
+    assert cat_list == []

chia/_tests/util/benchmark_cost.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import random
+import time
+
+from chia_rs import AugSchemeMPL, PrivateKey
+from clvm_tools import binutils
+
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.simulator.wallet_tools import WalletTool
+from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.condition_with_args import ConditionWithArgs
+from chia.util.ints import uint32
+from chia.wallet.derive_keys import master_sk_to_wallet_sk
+from chia.wallet.puzzles.p2_delegated_puzzle import puzzle_for_pk
+
+
+def float_to_str(f):
+    float_string = repr(f)
+    if "e" in float_string:  # detect scientific notation
+        digits, exp_str = float_string.split("e")
+        digits = digits.replace(".", "").replace("-", "")
+        exp = int(exp_str)
+        zero_padding = "0" * (abs(int(exp)) - 1)  # minus 1 for decimal point in the sci notation
+        sign = "-" if f < 0 else ""
+        if exp > 0:
+            float_string = f"{sign}{digits}{zero_padding}.0"
+        else:
+            float_string = f"{sign}0.{zero_padding}{digits}"
+    return float_string
+
+
+def run_and_return_cost_time(chialisp):
+    start = time.time()
+    clvm_loop = "((c (q ((c (f (a)) (c (f (a)) (c (f (r (a))) (c (f (r (r (a))))"
+    " (q ()))))))) (c (q ((c (i (f (r (a))) (q (i (q 1) ((c (f (a)) (c (f (a))"
+    " (c (- (f (r (a))) (q 1)) (c (f (r (r (a)))) (q ()))))))"
+    " ((c (f (r (r (a)))) (q ()))))) (q (q ()))) (a)))) (a))))"
+    loop_program = Program.to(binutils.assemble(clvm_loop))
+    clvm_loop_solution = f"(1000 {chialisp})"
+    solution_program = Program.to(binutils.assemble(clvm_loop_solution))
+
+    cost, _ = loop_program.run_with_cost(INFINITE_COST, solution_program)
+
+    end = time.time()
+    total_time = end - start
+
+    return cost, total_time
+
+
+def get_cost_compared_to_addition(addition_cost, addition_time, other_time):
+    return (addition_cost * other_time) / addition_time
+
+
+def benchmark_all_operators():
+    addition = "(+ (q 1000000000) (q 1000000000))"
+    substraction = "(- (q 1000000000) (q 1000000000))"
+    multiply = "(* (q 1000000000) (q 1000000000))"
+    greater = "(> (q 1000000000) (q 1000000000))"
+    equal = "(= (q 1000000000) (q 1000000000))"
+    if_clvm = "(i (= (q 1000000000) (q 1000000000)) (q 1000000000) (q 1000000000))"
+    sha256tree = "(sha256 (q 1000000000))"
+    pubkey_for_exp = "(pubkey_for_exp (q 1))"
+    point_add = "(point_add"
+    " (q 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb)"
+    " (q 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb))"
+    point_add_cost, point_add_time = run_and_return_cost_time(point_add)
+    addition_cost, addition_time = run_and_return_cost_time(addition)
+    substraction_cost, substraction_time = run_and_return_cost_time(substraction)
+    multiply_cost, multiply_time = run_and_return_cost_time(multiply)
+    greater_cost, greater_time = run_and_return_cost_time(greater)
+    equal_cost, equal_time = run_and_return_cost_time(equal)
+    if_cost, if_time = run_and_return_cost_time(if_clvm)
+    sha256tree_cost, sha256tree_time = run_and_return_cost_time(sha256tree)
+    pubkey_for_exp_cost, pubkey_for_exp_time = run_and_return_cost_time(pubkey_for_exp)
+
+    one_addition = 1
+    one_substraction = get_cost_compared_to_addition(addition_cost, addition_time, substraction_time) / addition_cost
+    one_multiply = get_cost_compared_to_addition(addition_cost, addition_time, multiply_time) / addition_cost
+    one_greater = get_cost_compared_to_addition(addition_cost, addition_time, greater_time) / addition_cost
+    one_equal = get_cost_compared_to_addition(addition_cost, addition_time, equal_time) / addition_cost
+    one_if = get_cost_compared_to_addition(addition_cost, addition_time, if_time) / addition_cost
+    one_sha256 = get_cost_compared_to_addition(addition_cost, addition_time, sha256tree_time) / addition_cost
+    one_pubkey_for_exp = (
+        get_cost_compared_to_addition(addition_cost, addition_time, pubkey_for_exp_time) / addition_cost
+    )
+    one_point_add = get_cost_compared_to_addition(addition_cost, addition_time, point_add_time) / addition_cost
+
+    print(f"cost of addition is: {one_addition}")
+    print(f"cost of one_substraction is: {one_substraction}")
+    print(f"cost of one_multiply is: {one_multiply}")
+    print(f"cost of one_greater is: {one_greater}")
+    print(f"cost of one_equal is: {one_equal}")
+    print(f"cost of one_if is: {one_if}")
+    print(f"cost of one_sha256 is: {one_sha256}")
+    print(f"cost of one_pubkey_for_exp is: {one_pubkey_for_exp}")
+    print(f"cost of one_point_add is: {one_point_add}")
+
+
+if __name__ == "__main__":
+    """
+    Naive way to calculate cost ratio between vByte and CLVM cost unit.
+    AggSig has assigned cost of 20vBytes, simple CLVM program is benchmarked against it.
+    """
+    wallet_tool = WalletTool(DEFAULT_CONSTANTS)
+    benchmark_all_operators()
+    secret_key: PrivateKey = AugSchemeMPL.key_gen(bytes([2] * 32))
+    puzzles = []
+    solutions = []
+    private_keys = []
+    public_keys = []
+
+    seeded_random = random.Random()
+    seeded_random.seed(a=0, version=2)
+
+    for i in range(0, 1000):
+        private_key: PrivateKey = master_sk_to_wallet_sk(secret_key, uint32(i))
+        public_key = private_key.get_g1()
+        solution = wallet_tool.make_solution(
+            {
+                ConditionOpcode.ASSERT_MY_COIN_ID: [
+                    ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [bytes32.random(seeded_random)])
+                ]
+            }
+        )
+        puzzle = puzzle_for_pk(bytes(public_key))
+        puzzles.append(puzzle)
+        solutions.append(solution)
+        private_keys.append(private_key)
+        public_keys.append(public_key)
+
+    # Run Puzzle 1000 times
+    puzzle_start = time.time()
+    clvm_cost = 0
+    for i in range(0, 1000):
+        cost_run, _ = puzzles[i].run_with_cost(INFINITE_COST, solutions[i])
+        clvm_cost += cost_run
+
+    puzzle_end = time.time()
+    puzzle_time = puzzle_end - puzzle_start
+    print(f"Puzzle_time is: {puzzle_time}")
+    print(f"Puzzle cost sum is: {clvm_cost}")
+
+    private_key = master_sk_to_wallet_sk(secret_key, uint32(0))
+    public_key = private_key.get_g1()
+    message = bytes32.random(seeded_random)
+    signature = AugSchemeMPL.sign(private_key, message)
+    pk_message_pair = (public_key, message)
+
+    # Run AggSig 1000 times
+    agg_sig_start = time.time()
+    agg_sig_cost = 0
+    for i in range(0, 1000):
+        valid = AugSchemeMPL.verify(public_key, message, signature)
+        assert valid
+        agg_sig_cost += 20
+    agg_sig_end = time.time()
+    agg_sig_time = agg_sig_end - agg_sig_start
+    print(f"Aggsig Cost: {agg_sig_cost}")
+    print(f"Aggsig time is: {agg_sig_time}")
+
+    # clvm_should_cost = agg_sig_cost * puzzle_time / agg_sig_time
+    clvm_should_cost = (agg_sig_cost * puzzle_time) / agg_sig_time
+    print(f"Puzzle should cost: {clvm_should_cost}")
+    constant = clvm_should_cost / clvm_cost
+    format = float_to_str(constant)
+    print(f"Constant factor: {format}")
+    print(f"CLVM RATIO MULTIPLIER: {1/constant}")

chia/_tests/util/benchmarks.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import random
+from typing import Tuple
+
+import importlib_resources
+from chia_rs import AugSchemeMPL, ClassgroupElement, Coin, G1Element, G2Element, VDFInfo, VDFProof
+
+from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.foliage import Foliage, FoliageBlockData, FoliageTransactionBlock, TransactionsInfo
+from chia.types.blockchain_format.pool_target import PoolTarget
+from chia.types.blockchain_format.proof_of_space import ProofOfSpace
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlock
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32, bytes100
+from chia.types.full_block import FullBlock
+from chia.util.ints import uint8, uint32, uint64, uint128
+
+# farmer puzzle hash
+ph = bytes32(b"a" * 32)
+
+clvm_generator_bin_path = importlib_resources.files(__name__.rpartition(".")[0]).joinpath("clvm_generator.bin")
+clvm_generator = clvm_generator_bin_path.read_bytes()
+
+
+def rewards(height: uint32) -> Tuple[Coin, Coin]:
+    farmer_coin = create_farmer_coin(height, ph, uint64(250000000), DEFAULT_CONSTANTS.GENESIS_CHALLENGE)
+    pool_coin = create_pool_coin(height, ph, uint64(1750000000), DEFAULT_CONSTANTS.GENESIS_CHALLENGE)
+    return farmer_coin, pool_coin
+
+
+def rand_bytes(num: int) -> bytes:
+    ret = bytearray(num)
+    for i in range(num):
+        ret[i] = random.getrandbits(8)
+    return bytes(ret)
+
+
+def rand_hash() -> bytes32:
+    return bytes32(rand_bytes(32))
+
+
+def rand_g1() -> G1Element:
+    sk = AugSchemeMPL.key_gen(rand_bytes(96))
+    return sk.get_g1()
+
+
+def rand_g2() -> G2Element:
+    sk = AugSchemeMPL.key_gen(rand_bytes(96))
+    return AugSchemeMPL.sign(sk, b"foobar")
+
+
+def rand_class_group_element() -> ClassgroupElement:
+    return ClassgroupElement(bytes100(rand_bytes(100)))
+
+
+def rand_vdf() -> VDFInfo:
+    return VDFInfo(rand_hash(), uint64(random.randint(100000, 1000000000)), rand_class_group_element())
+
+
+def rand_vdf_proof() -> VDFProof:
+    return VDFProof(
+        uint8(1),  # witness_type
+        rand_hash(),  # witness
+        bool(random.randint(0, 1)),  # normalized_to_identity
+    )
+
+
+def rand_full_block() -> FullBlock:
+    proof_of_space = ProofOfSpace(
+        rand_hash(),
+        rand_g1(),
+        None,
+        rand_g1(),
+        uint8(0),
+        rand_bytes(8 * 32),
+    )
+
+    reward_chain_block = RewardChainBlock(
+        uint128(1),
+        uint32(2),
+        uint128(3),
+        uint8(4),
+        rand_hash(),
+        proof_of_space,
+        None,
+        rand_g2(),
+        rand_vdf(),
+        None,
+        rand_g2(),
+        rand_vdf(),
+        rand_vdf(),
+        True,
+    )
+
+    pool_target = PoolTarget(
+        rand_hash(),
+        uint32(0),
+    )
+
+    foliage_block_data = FoliageBlockData(
+        rand_hash(),
+        pool_target,
+        rand_g2(),
+        rand_hash(),
+        rand_hash(),
+    )
+
+    foliage = Foliage(
+        rand_hash(),
+        rand_hash(),
+        foliage_block_data,
+        rand_g2(),
+        rand_hash(),
+        rand_g2(),
+    )
+
+    foliage_transaction_block = FoliageTransactionBlock(
+        rand_hash(),
+        uint64(0),
+        rand_hash(),
+        rand_hash(),
+        rand_hash(),
+        rand_hash(),
+    )
+
+    farmer_coin, pool_coin = rewards(uint32(0))
+
+    transactions_info = TransactionsInfo(
+        rand_hash(),
+        rand_hash(),
+        rand_g2(),
+        uint64(0),
+        uint64(1),
+        [farmer_coin, pool_coin],
+    )
+
+    full_block = FullBlock(
+        [],
+        reward_chain_block,
+        rand_vdf_proof(),
+        rand_vdf_proof(),
+        rand_vdf_proof(),
+        rand_vdf_proof(),
+        rand_vdf_proof(),
+        foliage,
+        foliage_transaction_block,
+        transactions_info,
+        SerializedProgram.from_bytes(clvm_generator),
+        [],
+    )
+
+    return full_block