chia-blockchain 2.5.1rc1__py3-none-any.whl

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,153 @@
+from __future__ import annotations
+
+import random
+
+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

chia/_tests/util/bip39_test_vectors.json

@@ -0,0 +1,148 @@
+{
+  "english": [
+    [
+      "00000000000000000000000000000000",
+      "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+      "5eb00bbddcf069084889a8ab9155568165f5c453ccb85e70811aaed6f6da5fc19a5ac40b389cd370d086206dec8aa6c43daea6690f20ad3d8d48b2d2ce9e38e4",
+      "aban aban aban aban aban aban aban aban aban aban aban abou"
+    ],
+    [
+      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+      "legal winner thank year wave sausage worth useful legal winner thank yellow",
+      "878386efb78845b3355bd15ea4d39ef97d179cb712b77d5c12b6be415fffeffe5f377ba02bf3f8544ab800b955e51fbff09828f682052a20faa6addbbddfb096",
+      "lega winn than year wave saus wort usef lega winn than yell"
+    ],
+    [
+      "80808080808080808080808080808080",
+      "letter advice cage absurd amount doctor acoustic avoid letter advice cage above",
+      "77d6be9708c8218738934f84bbbb78a2e048ca007746cb764f0673e4b1812d176bbb173e1a291f31cf633f1d0bad7d3cf071c30e98cd0688b5bcce65ecaceb36",
+      "lett advi cage absu amou doct acou avoi lett advi cage abov"
+    ],
+    [
+      "ffffffffffffffffffffffffffffffff",
+      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
+      "b6a6d8921942dd9806607ebc2750416b289adea669198769f2e15ed926c3aa92bf88ece232317b4ea463e84b0fcd3b53577812ee449ccc448eb45e6f544e25b6",
+      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wron"
+    ],
+    [
+      "000000000000000000000000000000000000000000000000",
+      "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
+      "4975bb3d1faf5308c86a30893ee903a976296609db223fd717e227da5a813a34dc1428b71c84a787fc51f3b9f9dc28e9459f48c08bd9578e9d1b170f2d7ea506",
+      "aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban agen"
+    ],
+    [
+      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+      "legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
+      "b059400ce0f55498a5527667e77048bb482ff6daa16c37b4b9e8af70c85b3f4df588004f19812a1a027c9a51e5e94259a560268e91cd10e206451a129826e740",
+      "lega winn than year wave saus wort usef lega winn than year wave saus wort usef lega will"
+    ],
+    [
+      "808080808080808080808080808080808080808080808080",
+      "letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
+      "04d5f77103510c41d610f7f5fb3f0badc77c377090815cee808ea5d2f264fdfabf7c7ded4be6d4c6d7cdb021ba4c777b0b7e57ca8aa6de15aeb9905dba674d66",
+      "lett advi cage absu amou doct acou avoi lett advi cage absu amou doct acou avoi lett alwa"
+    ],
+    [
+      "ffffffffffffffffffffffffffffffffffffffffffffffff",
+      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
+      "d2911131a6dda23ac4441d1b66e2113ec6324354523acfa20899a2dcb3087849264e91f8ec5d75355f0f617be15369ffa13c3d18c8156b97cd2618ac693f759f",
+      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"
+    ],
+    [
+      "0000000000000000000000000000000000000000000000000000000000000000",
+      "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
+      "408b285c123836004f4b8842c89324c1f01382450c0d439af345ba7fc49acf705489c6fc77dbd4e3dc1dd8cc6bc9f043db8ada1e243c4a0eafb290d399480840",
+      "aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban art"
+    ],
+    [
+      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+      "legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
+      "761914478ebf6fe16185749372e91549361af22b386de46322cf8b1ba7e92e80c4af05196f742be1e63aab603899842ddadf4e7248d8e43870a4b6ff9bf16324",
+      "lega winn than year wave saus wort usef lega winn than year wave saus wort usef lega winn than year wave saus wort titl"
+    ],
+    [
+      "8080808080808080808080808080808080808080808080808080808080808080",
+      "letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
+      "848bbe19cad445e46f35fd3d1a89463583ac2b60b5eb4cfcf955731775a5d9e17a81a71613fed83f1ae27b408478fdec2bbc75b5161d1937aa7cdf4ad686ef5f",
+      "lett advi cage absu amou doct acou avoi lett advi cage absu amou doct acou avoi lett advi cage absu amou doct acou bles"
+    ],
+    [
+      "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
+      "e28a37058c7f5112ec9e16a3437cf363a2572d70b6ceb3b6965447623d620f14d06bb321a26b33ec15fcd84a3b5ddfd5520e230c924c87aaa0d559749e044fef",
+      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"
+    ],
+    [
+      "9e885d952ad362caeb4efe34a8e91bd2",
+      "ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic",
+      "e2f88a043776c828063d4c3c97173944d32cf847a925b6e40b0b8bd0b4bead3ba734bdda5250d4698b310a71c9934e1a48e562315ce22bf85f89459df0e73a6c",
+      "ozon dril grab fibe curt grac pudd than crui elde eigh picn"
+    ],
+    [
+      "6610b25967cdcca9d59875f5cb50b0ea75433311869e930b",
+      "gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog",
+      "31736b4f31612ece84404c74a5d3b938a092480eb89c11b81491f1a3657eb2fe50024610fbe814df55913a87ef741020fcf076a75a29aea0aba638126ba4c8bb",
+      "grav mach nort sort syst fema filt atti volu fold club stay feat offi ecol stab narr fog"
+    ],
+    [
+      "68a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc74e6ce7c",
+      "hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length",
+      "17e4b5661796eeff8904550f8572289317ece7c1cc1316469f8f4c986c1ffd7b9f4c3aeac3e1713ffc21fa33707d09d57a2ece358d72111ef7c7658e7b33f2d5",
+      "hams diag priv dutc caus dela priv meat slid todd razo book happ fanc gosp tenn mapl dile loan word shrug infl dela leng"
+    ],
+    [
+      "c0ba5a8e914111210f2bd131f3d5e08d",
+      "scheme spot photo card baby mountain device kick cradle pact join borrow",
+      "00e1e39a39e23735adab690d0ffbefda6cacc063b4a5fcc605de060bd370adc54c94370d966b9a3fae5ed16bd58a02224cbefca4146a083951b70be2a2ce3dcc",
+      "sche spot phot card baby moun devi kick crad pact join borr"
+    ],
+    [
+      "6d9be1ee6ebd27a258115aad99b7317b9c8d28b6d76431c3",
+      "horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave",
+      "e893fc34fa2a78ceaaea78c246b69257ad283fa538d88f3c4520beb618a2062b8ec4920ed1793fff6ad443523ed18c03da433004d0a1e9497e194621607bc9e2",
+      "horn tena knee tale spon spel gate clip puls soap slus warm silv neph swap uncl crac brav"
+    ],
+    [
+      "9f6a2878b2520799a44ef18bc7df394e7061a224d2c33cd015b157d746869863",
+      "panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside",
+      "3e066d7dee2dbf8fcd3fe240a3975658ca118a8f6f4ca81cf99104944604b05a5090a79d99e545704b914ca0397fedb82fd00fd6a72098703709c891a065ee49",
+      "pand eyeb bull gori call smok muff tast mesh disc soft ostr alco spee nati flas devo leve hobb quic inne driv ghos insi"
+    ],
+    [
+      "23db8160a31d3e0dca3688ed941adbf3",
+      "cat swing flag economy stadium alone churn speed unique patch report train",
+      "7ea73b3a398f8a71f7dde589d972b0358d3fa8b9e91317ecc544e42752b1bb251a1926b1f4c69eec0a80c0396aa0f7df29f7d73411d3106eba539f3d584fcdf8",
+      "cat swin flag econ stad alon chur spee uniq patc repo trai"
+    ],
+    [
+      "8197a4a47f0425faeaa69deebc05ca29c0a5b5cc76ceacc0",
+      "light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access",
+      "d0ca8861283a7124515e825b7a06de8e0ad0dd5ac7888013efe6e3c300d4745bbd2c729f3355d769d23718579e7b735999a8f0b38e22b5bff45c9085af449056",
+      "ligh rule cinn wrap dras word prid squi upgr then inco fata apar sust crac supp prou acce"
+    ],
+    [
+      "066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad",
+      "all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform",
+      "fc795be0c3f18c50dddb34e72179dc597d64055497ecc1e69e2e56a5409651bc139aae8070d4df0ea14d8d2a518a9a00bb1cc6e92e053fe34051f6821df9164c",
+      "all hour make firs lead exte hole alie behi guar gosp lava path outp cens muse juni mass reop famo sing adva salt refo"
+    ],
+    [
+      "f30f8c1da665478f49b001d94c5fc452",
+      "vessel ladder alter error federal sibling chat ability sun glass valve picture",
+      "e2d7f9a462875c1325f44f321392edc8eaafebf1547c89d72d10b41b4ee23af3fb0ab010f39f5cbea3b3aa671161b58262b6a508bcbe2d34ee272a942534d45f",
+      "vess ladd alte erro fede sibl chat abil sun glas valv pict"
+    ],
+    [
+      "c10ec20dc3cd9f652c7fac2f1230f7a3c828389a14392f05",
+      "scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump",
+      "a555426999448df9022c3afc2ed0e4aebff3a0ac37d8a395f81412e14994efc960ed168d39a80478e0467a3d5cfc134fef2767c1d3a27f18e3afeb11bfc8e6ad",
+      "scis invi lock mapl supr raw rapi void cong musc digi eleg litt bris hair mang cong clum"
+    ],
+    [
+      "f585c11aec520db57dd353c69554b21a89b20fb0650966fa0a9d6f74fd989d8f",
+      "void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold",
+      "b873212f885ccffbf4692afcb84bc2e55886de2dfa07d90f5c3c239abc31c0a6ce047e30fd8bf6a281e71389aa82d73df74c7bbfb3b06b4639a5cee775cccd3c",
+      "void come effo suff camp surv warr heav shoo prim clut crus open amaz scre patr grou spac poin ten exis slus invo unfo"
+    ]
+  ]
+}

chia/_tests/util/blockchain.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import pickle
+from collections.abc import AsyncIterator
+from pathlib import Path
+from typing import Optional
+
+from chia.consensus.blockchain import Blockchain
+from chia.consensus.constants import ConsensusConstants
+from chia.full_node.block_store import BlockStore
+from chia.full_node.coin_store import CoinStore
+from chia.simulator.block_tools import BlockTools
+from chia.types.full_block import FullBlock
+from chia.util.db_wrapper import DBWrapper2, generate_in_memory_db_uri
+from chia.util.default_root import DEFAULT_ROOT_PATH
+
+
+@contextlib.asynccontextmanager
+async def create_blockchain(
+    constants: ConsensusConstants, db_version: int
+) -> AsyncIterator[tuple[Blockchain, DBWrapper2]]:
+    db_uri = generate_in_memory_db_uri()
+    async with DBWrapper2.managed(database=db_uri, uri=True, reader_count=1, db_version=db_version) as wrapper:
+        coin_store = await CoinStore.create(wrapper)
+        store = await BlockStore.create(wrapper)
+        bc1 = await Blockchain.create(coin_store, store, constants, Path("."), 2, single_threaded=True, log_coins=True)
+        try:
+            assert bc1.get_peak() is None
+            yield bc1, wrapper
+        finally:
+            bc1.shut_down()
+
+
+def persistent_blocks(
+    num_of_blocks: int,
+    db_name: str,
+    bt: BlockTools,
+    seed: bytes = b"",
+    empty_sub_slots: int = 0,
+    *,
+    normalized_to_identity_cc_eos: bool = False,
+    normalized_to_identity_icc_eos: bool = False,
+    normalized_to_identity_cc_sp: bool = False,
+    normalized_to_identity_cc_ip: bool = False,
+    block_list_input: Optional[list[FullBlock]] = None,
+    time_per_block: Optional[float] = None,
+    dummy_block_references: bool = False,
+    include_transactions: bool = False,
+) -> list[FullBlock]:
+    # try loading from disc, if not create new blocks.db file
+    # TODO hash fixtures.py and blocktool.py, add to path, delete if the files changed
+    if block_list_input is None:
+        block_list_input = []
+    block_path_dir = DEFAULT_ROOT_PATH.parent.joinpath("blocks")
+    file_path = block_path_dir.joinpath(db_name)
+
+    ci = os.environ.get("CI")
+    if ci is not None and not file_path.exists():
+        raise Exception(f"Running in CI and expected path not found: {file_path!r}")
+
+    block_path_dir.mkdir(parents=True, exist_ok=True)
+
+    if file_path.exists():
+        print(f"File found at: {file_path}")
+        try:
+            bytes_list = file_path.read_bytes()
+            block_bytes_list: list[bytes] = pickle.loads(bytes_list)
+            blocks: list[FullBlock] = []
+            for block_bytes in block_bytes_list:
+                blocks.append(FullBlock.from_bytes_unchecked(block_bytes))
+            if len(blocks) == num_of_blocks + len(block_list_input):
+                print(f"\n loaded {file_path} with {len(blocks)} blocks")
+                return blocks
+        except EOFError:
+            print("\n error reading db file")
+    else:
+        print(f"File not found at: {file_path}")
+
+    print("Creating a new test db")
+    return new_test_db(
+        file_path,
+        num_of_blocks,
+        seed,
+        empty_sub_slots,
+        bt,
+        block_list_input,
+        time_per_block,
+        normalized_to_identity_cc_eos=normalized_to_identity_cc_eos,
+        normalized_to_identity_icc_eos=normalized_to_identity_icc_eos,
+        normalized_to_identity_cc_sp=normalized_to_identity_cc_sp,
+        normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
+        dummy_block_references=dummy_block_references,
+        include_transactions=include_transactions,
+    )
+
+
+def new_test_db(
+    path: Path,
+    num_of_blocks: int,
+    seed: bytes,
+    empty_sub_slots: int,
+    bt: BlockTools,
+    block_list_input: list[FullBlock],
+    time_per_block: Optional[float],
+    *,
+    normalized_to_identity_cc_eos: bool = False,  # CC_EOS,
+    normalized_to_identity_icc_eos: bool = False,  # ICC_EOS
+    normalized_to_identity_cc_sp: bool = False,  # CC_SP,
+    normalized_to_identity_cc_ip: bool = False,  # CC_IP
+    dummy_block_references: bool = False,
+    include_transactions: bool = False,
+) -> list[FullBlock]:
+    print(f"create {path} with {num_of_blocks} blocks with ")
+    blocks: list[FullBlock] = bt.get_consecutive_blocks(
+        num_of_blocks,
+        block_list_input=block_list_input,
+        time_per_block=time_per_block,
+        seed=seed,
+        skip_slots=empty_sub_slots,
+        normalized_to_identity_cc_eos=normalized_to_identity_cc_eos,
+        normalized_to_identity_icc_eos=normalized_to_identity_icc_eos,
+        normalized_to_identity_cc_sp=normalized_to_identity_cc_sp,
+        normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
+        dummy_block_references=dummy_block_references,
+        include_transactions=include_transactions,
+    )
+    block_bytes_list: list[bytes] = []
+    for block in blocks:
+        block_bytes_list.append(bytes(block))
+    bytes_fn = pickle.dumps(block_bytes_list)
+    path.write_bytes(bytes_fn)
+    return blocks