Merge branch 'main' into farmer_solver_networking

Author: almogdepaz

.github/workflows/test.yml

@@ -185,10 +185,11 @@ jobs:
       collect-junit: false
 
   coverage:
-    if: github.repository_owner == 'Chia-Network'
+    if: always() && github.repository_owner == 'Chia-Network'
     name: ${{ matrix.os.emoji }} Coverage - ${{ matrix.python.name }}
     runs-on: ${{ matrix.os.runs-on }}
     needs:
+      - configure
       - macos-intel
       - macos-arm
       - ubuntu
@@ -209,6 +210,12 @@ jobs:
             matrix: "3.10"
 
     steps:
+      - uses: re-actors/alls-green@release/v1.2
+        id: alls-green
+        with:
+          allowed-skips: ${{ needs.configure.outputs.mac_intel != 'true' && 'macos-intel' || '' }}
+          jobs: ${{ toJSON(needs) }}
+
       - uses: actions/checkout@v5
         with:
           fetch-depth: 0
@@ -265,13 +272,13 @@ jobs:
       - uses: chia-network/actions/activate-venv@main
 
       - name: Add time out assert results to workflow summary
-        if: always() && false
+        if: always() && steps.alls-green.outputs.success == 'true' && false
         run: |
           python -m chia._tests.process_junit --limit 50 --type time_out_assert --xml junit-results/junit.xml --markdown --link-prefix ${{ github.event.repository.html_url }}/blob/${{ github.sha }}/ --link-line-separator \#L >> "$GITHUB_STEP_SUMMARY"
           python -m chia._tests.process_junit            --type time_out_assert --xml junit-results/junit.xml --markdown --link-prefix ${{ github.event.repository.html_url }}/blob/${{ github.sha }}/ --link-line-separator \#L >> junit-results/time_out_assert.md
 
       - name: Publish JUnit results
-        if: always() && false
+        if: always() && steps.alls-green.outputs.success == 'true' && false
         uses: actions/upload-artifact@v4
         with:
           name: junit-results
@@ -285,18 +292,18 @@ jobs:
           coverage html --rcfile=.coveragerc --data-file=coverage-reports/.coverage --directory coverage-reports/html/
 
       - uses: coverallsapp/github-action@v2
-        if: always()
+        if: always() && steps.alls-green.outputs.success == 'true'
         env:
           COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
 
       - name: Coverage report (chia/)
-        if: always()
+        if: always() && steps.alls-green.outputs.success == 'true'
         run: |
           set -o pipefail
           coverage report --rcfile=.coveragerc --data-file=coverage-reports/.coverage --include='chia/**/*' --omit='chia/_tests/**/*' --show-missing | tee coverage-reports/coverage-chia-stdout
 
       - name: Coverage report (chia/_tests/)
-        if: always()
+        if: always() && steps.alls-green.outputs.success == 'true'
         run: |
           set -o pipefail
           coverage report --rcfile=.coveragerc --data-file=coverage-reports/.coverage --include='chia/_tests/**/*' --show-missing | tee coverage-reports/coverage-tests-stdout
@@ -307,7 +314,7 @@ jobs:
           echo "hash=$(git rev-parse HEAD~1)" >> "$GITHUB_OUTPUT"
 
       - name: Coverage report (diff)
-        if: (github.base_ref != '' || github.event.before != '') && always()
+        if: (github.base_ref != '' || github.event.before != '') && always() && steps.alls-green.outputs.success == 'true'
         env:
           compare-branch: ${{ github.base_ref == '' && steps.parent-commit.outputs.hash || format('origin/{0}', github.base_ref) }}
         run: |
@@ -320,7 +327,7 @@ jobs:
           fi
 
       - name: Remove previous coverage report comment and label from PR
-        if: github.base_ref != '' && always()
+        if: github.base_ref != '' && always() && steps.alls-green.outputs.success == 'true'
         shell: bash
         env:
           COV_STATUS: ${{ env.COV_STATUS }}
@@ -341,7 +348,7 @@ jobs:
           fi
 
       - name: Add diff coverage report comment to PR
-        if: github.base_ref != '' && always()
+        if: github.base_ref != '' && always() && steps.alls-green.outputs.success == 'true'
         env:
           BRANCH_NAME: ${{ github.sha }}
           COV_STATUS: ${{ env.COV_STATUS }}
@@ -391,12 +398,12 @@ jobs:
           fi
 
       - name: Add diff coverage report to workflow summary
-        if: (github.base_ref != '' || github.event.before != '') && always()
+        if: (github.base_ref != '' || github.event.before != '') && always() && steps.alls-green.outputs.success == 'true'
         run: |
           cat coverage-reports/diff-cover.md >> "$GITHUB_STEP_SUMMARY"
 
       - name: Publish coverage reports
-        if: always()
+        if: always() && steps.alls-green.outputs.success == 'true'
         uses: actions/upload-artifact@v4
         with:
           name: coverage-reports

build_scripts/build_linux_deb-2-installer.sh

@@ -91,11 +91,6 @@ if [ "$PLATFORM" = "arm64" ]; then
   # https://github.com/jordansissel/fpm/issues/1801#issuecomment-919877499
   # @TODO Consolidates the process to amd64 if the issue of electron-builder is resolved
   sudo apt-get -y install ruby ruby-dev
-  # ERROR:  Error installing fpm:
-  #     The last version of dotenv (>= 0) to support your Ruby & RubyGems was 2.8.1. Try installing it with `gem install dotenv -v 2.8.1` and then running the current command again
-  #     dotenv requires Ruby version >= 3.0. The current ruby version is 2.7.0.0.
-  # @TODO Once ruby 3.0 can be installed on `apt install ruby`, installing dotenv below should be removed.
-  sudo gem install dotenv -v 2.8.1
   sudo gem install fpm
   echo USE_SYSTEM_FPM=true "${NPM_PATH}/electron-builder" build --linux deb --arm64 \
     --config.extraMetadata.name=chia-blockchain \

chia/_tests/blockchain/blockchain_test_utils.py

@@ -76,7 +76,7 @@ async def _validate_and_add_block(
             conds = None
         else:
             # fake the signature validation. Just say True here.
-            conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0)
+            conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0, 0, 0, 0)
         results = PreValidationResult(None, uint64(1), conds, uint32(0))
     else:
         future = await pre_validate_block(

chia/_tests/blockchain/test_blockchain.py

@@ -4352,6 +4352,9 @@ async def test_include_spends_same_as_parent(
         True,
         0,
         0,
+        0,
+        0,
+        0,
     )
     # Now let's run the test
     test_setup.fork_info.include_spends(conds, test_setup.test_block, test_setup.test_block.header_hash)

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -12,8 +12,8 @@
 from chia._tests.util.misc import Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.proof_of_space import (
-    calculate_plot_difficulty,
     calculate_prefix_bits,
+    calculate_required_plot_strength,
     check_plot_size,
     make_pos,
     passes_plot_filter,
@@ -201,26 +201,26 @@ def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case
 
 
 @pytest.mark.parametrize(
-    "height, difficulty",
+    "height, strength",
     [
         (0, 2),
         (DEFAULT_CONSTANTS.HARD_FORK_HEIGHT, 2),
         (DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT, 2),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_4_HEIGHT - 1, 2),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_4_HEIGHT, 4),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_5_HEIGHT - 1, 4),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_5_HEIGHT, 5),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_6_HEIGHT - 1, 5),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_6_HEIGHT, 6),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_7_HEIGHT - 1, 6),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_7_HEIGHT, 7),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT - 1, 7),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT, 8),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT + 1000000, 8),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_4_HEIGHT - 1, 2),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_4_HEIGHT, 4),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_5_HEIGHT - 1, 4),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_5_HEIGHT, 5),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_6_HEIGHT - 1, 5),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_6_HEIGHT, 6),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_7_HEIGHT - 1, 6),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_7_HEIGHT, 7),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_8_HEIGHT - 1, 7),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_8_HEIGHT, 8),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_8_HEIGHT + 1000000, 8),
     ],
 )
-def test_calculate_plot_difficulty(height: uint32, difficulty: uint8) -> None:
-    assert calculate_plot_difficulty(DEFAULT_CONSTANTS, height) == difficulty
+def test_calculate_plot_strength(height: uint32, strength: uint8) -> None:
+    assert calculate_required_plot_strength(DEFAULT_CONSTANTS, height) == strength
 
 
 @pytest.mark.parametrize(

chia/_tests/core/full_node/test_full_node.py

@@ -112,11 +112,11 @@
 
 
 def test_pre_validation_result() -> None:
-    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0)
+    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0, 0, 0, 0)
     results = PreValidationResult(None, uint64(1), conds, uint32(0))
     assert results.validated_signature is True
 
-    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, False, 0, 0)
+    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, False, 0, 0, 0, 0, 0)
     results = PreValidationResult(None, uint64(1), conds, uint32(0))
     assert results.validated_signature is False
 

chia/_tests/core/full_node/test_generator_tools.py

@@ -81,7 +81,7 @@
 
 def test_tx_removals_and_additions() -> None:
     conditions = SpendBundleConditions(
-        spends, uint64(0), uint32(0), uint64(0), None, None, [], uint64(0), 0, 0, False, 0, 0
+        spends, uint64(0), uint32(0), uint64(0), None, None, [], uint64(0), 0, 0, False, 0, 0, 0, 0, 0
     )
     expected_rems = [coin_ids[0], coin_ids[1]]
     expected_additions = []

chia/_tests/core/mempool/test_mempool.py

@@ -119,7 +119,7 @@ def make_item(
     return MempoolItem(
         SpendBundle([], G2Element()),
         fee,
-        SpendBundleConditions([], 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0),
+        SpendBundleConditions([], 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0, 0, 0, 0),
         spend_bundle_name,
         uint32(0),
         assert_height,
@@ -3213,6 +3213,97 @@ def test_get_puzzle_and_solution_for_coin_failure() -> None:
             raise ValueError(f"Failed to get puzzle and solution for coin {TEST_COIN}, error: {e}") from e
 
 
+# this puzzle just creates coins, however many are requested by the solution
+# (mod (A)
+#    (defun loop (n)
+#        (if (= n 1)
+#            (list)
+#            (c (list 51 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff n) (loop (- n 1))))
+#    )
+#    (loop A)
+# )
+create_coins_loop: str = (
+    "ff02ffff01ff02ff02ffff04ff02ffff04ff05ff80808080ffff04ffff01ff02"
+    "ffff03ffff09ff05ffff010180ff80ffff01ff04ffff04ffff0133ffff04ffff"
+    "01a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+    "ffffffff04ff05ff80808080ffff02ff02ffff04ff02ffff04ffff11ff05ffff"
+    "010180ff808080808080ff0180ff018080"
+)
+
+
+# this test uses artificial puzzles just to exercise the block creation. These
+# spends are expected not to verify any signatures
+# This is to keep the test simple.
+@pytest.mark.parametrize(
+    "puzzle, solution",
+    [
+        # create 2000 coins
+        (create_coins_loop, "ff8207d180"),
+        # create 1000 coins
+        (create_coins_loop, "ff8203e980"),
+        # create 500 coins
+        (create_coins_loop, "ff8201f580"),
+    ],
+)
+@pytest.mark.parametrize("old", [True, False])
+def test_create_block_generator_custom_spend(puzzle: str, solution: str, old: bool) -> None:
+    mempool_info = MempoolInfo(
+        CLVMCost(uint64(11000000000 * 3)),
+        FeeRate(uint64(1000000)),
+        CLVMCost(uint64(11000000000)),
+    )
+
+    fee_estimator = create_bitcoin_fee_estimator(test_constants.MAX_BLOCK_COST_CLVM)
+    solution_str = SerializedProgram.fromhex(solution)
+    puzzle_reveal = SerializedProgram.fromhex(puzzle)
+    puzzle_hash = puzzle_reveal.get_tree_hash()
+    mempool = Mempool(mempool_info, fee_estimator)
+    coins = [Coin(bytes32.random(), puzzle_hash, uint64(amount)) for amount in range(100000000, 100000022)]
+
+    spend_bundles = [
+        SpendBundle(
+            coin_spends=[CoinSpend(coin, puzzle_reveal=puzzle_reveal, solution=solution_str)],
+            aggregated_signature=G2Element(),
+        )
+        for coin in coins
+    ]
+
+    for sb in spend_bundles:
+        mi = mempool_item_from_spendbundle(sb)
+        mempool.add_to_pool(mi)
+        invariant_check_mempool(mempool)
+
+    create_block = mempool.create_block_generator if old else mempool.create_block_generator2
+    generator = create_block(test_constants, test_constants.HARD_FORK2_HEIGHT, 10.0)
+    assert generator is not None
+
+    assert generator.signature == G2Element()
+
+    removals = set(generator.removals)
+
+    err, conds = run_block_generator2(
+        bytes(generator.program),
+        generator.generator_refs,
+        test_constants.MAX_BLOCK_COST_CLVM,
+        0,
+        generator.signature,
+        None,
+        test_constants,
+    )
+
+    assert err is None
+    assert conds is not None
+
+    assert len(conds.spends) == len(removals)
+
+    for spend in conds.spends:
+        removal = Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount))
+        assert removal in coins
+        assert removal in removals
+
+    invariant_check_mempool(mempool)
+
+
 @pytest.mark.parametrize("old", [True, False])
 def test_create_block_generator(old: bool) -> None:
     mempool = construct_mempool()

chia/_tests/core/mempool/test_mempool_manager.py

@@ -41,6 +41,7 @@
     QUOTE_BYTES,
     QUOTE_EXECUTION_COST,
     MempoolManager,
+    NewPeakItem,
     TimelockConditions,
     can_replace,
     check_removals,
@@ -375,6 +376,9 @@ def make_test_conds(
         False,
         0,
         0,
+        0,
+        0,
+        0,
     )
 
 
@@ -590,7 +594,9 @@ def make_bundle_spends_map_and_fee(
 
 
 def mempool_item_from_spendbundle(spend_bundle: SpendBundle) -> MempoolItem:
-    conds = get_conditions_from_spendbundle(spend_bundle, INFINITE_COST, DEFAULT_CONSTANTS, uint32(0))
+    conds = get_conditions_from_spendbundle(
+        spend_bundle, INFINITE_COST, DEFAULT_CONSTANTS, DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT
+    )
     bundle_coin_spends, fee = make_bundle_spends_map_and_fee(spend_bundle, conds)
     return MempoolItem(
         spend_bundle=spend_bundle,
@@ -3260,3 +3266,47 @@ async def test_different_ff_versions() -> None:
     latest_singleton_lineage2 = new_mi2.bundle_coin_spends[version2_id].latest_singleton_lineage
     assert latest_singleton_lineage2 is not None
     assert latest_singleton_lineage2.coin_id == new_latest_lineage_id
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "condition_and_error",
+    [
+        (ConditionOpcode.ASSERT_HEIGHT_RELATIVE, Err.ASSERT_HEIGHT_RELATIVE_FAILED),
+        (ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, Err.ASSERT_HEIGHT_ABSOLUTE_FAILED),
+    ],
+)
+@pytest.mark.parametrize("optimized_path", [True, False])
+async def test_new_peak_txs_added(condition_and_error: tuple[ConditionOpcode, Err], optimized_path: bool) -> None:
+    """
+    Tests that deferred transactions because of time-lock are retried once the
+    time-lock allows them to be reconsidered.
+    """
+    coins = TestCoins([TEST_COIN], {})
+    mempool_manager = await setup_mempool(coins)
+    # Add an item that should go to the pending cache
+    assert mempool_manager.peak is not None
+    condition_height = mempool_manager.peak.height + 1
+    condition, expected_error = condition_and_error
+    sb, sb_name, result = await generate_and_add_spendbundle(mempool_manager, [[condition, condition_height]])
+    _, status, error = result
+    assert status == MempoolInclusionStatus.PENDING
+    assert error == expected_error
+    # Advance the mempool beyond the asserted height to retry the test item
+    if optimized_path:
+        spent_coins: Optional[list[bytes32]] = []
+        new_peak_info = await mempool_manager.new_peak(
+            create_test_block_record(height=uint32(condition_height)), spent_coins
+        )
+        # We're not there yet (needs to be higher, not equal)
+        assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is None
+        assert new_peak_info.items == []
+    else:
+        spent_coins = None
+    new_peak_info = await mempool_manager.new_peak(
+        create_test_block_record(height=uint32(condition_height + 1)), spent_coins
+    )
+    # The item gets retried successfully now
+    mi = mempool_manager.get_mempool_item(sb_name, include_pending=False)
+    assert mi is not None
+    assert new_peak_info.items == [NewPeakItem(sb_name, sb, mi.conds)]