Get repack_mine_tests working

apps/arweave/e2e/ar_e2e.erl

@@ -37,7 +37,6 @@ install_fixture(FilePath, FixtureType, FixtureName) ->
 
 -spec load_wallet_fixture(atom()) -> tuple().
 load_wallet_fixture(WalletFixture) ->
-    ?debugFmt("Loading wallet fixture: ~p", [WalletFixture]),
     WalletName = atom_to_list(WalletFixture),
     FixtureDir = fixture_dir(wallets),
     FixturePath = filename:join([FixtureDir, WalletName ++ ".json"]),

apps/arweave/e2e/ar_repack_in_place_mine_tests.erl

@@ -0,0 +1,84 @@
+-module(ar_repack_in_place_mine_tests).
+
+-include_lib("arweave/include/ar_config.hrl").
+-include_lib("arweave/include/ar_consensus.hrl").
+-include_lib("eunit/include/eunit.hrl").
+
+%% --------------------------------------------------------------------------------------------
+%% Test Registration
+%% --------------------------------------------------------------------------------------------
+repack_in_place_mine_test_() ->
+	[
+		{timeout, 300, {with, {spora_2_6, spora_2_6}, [fun test_repack_in_place_mine/1]}}
+	].
+
+%% --------------------------------------------------------------------------------------------
+%% test_repack_in_place_mine
+%% --------------------------------------------------------------------------------------------
+test_repack_in_place_mine({FromPackingType, ToPackingType}) ->
+	ar_e2e:delayed_print(<<" ~p -> ~p ">>, [FromPackingType, ToPackingType]),
+	ValidatorNode = peer1,
+	RepackerNode = peer2,
+	{Blocks, _AddrA, Chunks} = ar_e2e:start_source_node(
+		RepackerNode, FromPackingType, wallet_a),
+
+	[B0 | _] = Blocks,
+	start_validator_node(ValidatorNode, RepackerNode, B0),
+
+	{WalletB, FinalStorageModules} = ar_e2e:source_node_storage_modules(
+		RepackerNode, ToPackingType, wallet_b),
+	AddrB = case WalletB of
+		undefined -> undefined;
+		_ -> ar_wallet:to_address(WalletB)
+	end,
+	ToPacking = ar_e2e:packing_type_to_packing(ToPackingType, AddrB),
+	{ok, Config} = ar_test_node:get_config(RepackerNode),
+
+	RepackInPlaceStorageModules = [ 
+		{Module, ToPacking} || Module <- Config#config.storage_modules ],
+
+	ar_test_node:update_config(RepackerNode, Config#config{
+		storage_modules = [],
+		repack_in_place_storage_modules = RepackInPlaceStorageModules,
+		mining_addr = undefined
+	}),
+	ar_test_node:restart(RepackerNode),
+
+	ar_e2e:assert_partition_size(RepackerNode, 1, ToPacking, ?PARTITION_SIZE),
+
+	ar_test_node:update_config(RepackerNode, Config#config{
+		storage_modules = FinalStorageModules,
+		repack_in_place_storage_modules = [],
+		mining_addr = AddrB
+	}),
+	ar_test_node:restart(RepackerNode),
+	ar_e2e:assert_chunks(RepackerNode, ToPacking, Chunks),
+
+	case ToPackingType of
+		unpacked ->
+			ok;
+		_ ->
+			CurrentHeight = ar_test_node:remote_call(RepackerNode, ar_node, get_height, []),
+			ar_test_node:mine(RepackerNode),
+
+			RepackerBI = ar_test_node:wait_until_height(RepackerNode, CurrentHeight + 1),
+			{ok, RepackerBlock} = ar_test_node:http_get_block(element(1, hd(RepackerBI)), RepackerNode),
+			ar_e2e:assert_block(ToPacking, RepackerBlock),
+
+			ValidatorBI = ar_test_node:wait_until_height(ValidatorNode, RepackerBlock#block.height),
+			{ok, ValidatorBlock} = ar_test_node:http_get_block(element(1, hd(ValidatorBI)), ValidatorNode),
+			?assertEqual(RepackerBlock, ValidatorBlock)
+	end.
+
+
+start_validator_node(ValidatorNode, RepackerNode, B0) ->
+	{ok, Config} = ar_test_node:get_config(ValidatorNode),
+	?assertEqual(ar_test_node:peer_name(ValidatorNode),
+		ar_test_node:start_other_node(ValidatorNode, B0, Config#config{
+			peers = [ar_test_node:peer_ip(RepackerNode)],
+			start_from_latest_state = true,
+			auto_join = true
+		}, true)
+	),
+	ok.
+

apps/arweave/e2e/ar_repack_mine_tests.erl

@@ -16,14 +16,14 @@ repack_mine_test_() ->
 		{timeout, 300, {with, {spora_2_6, composite_1}, [fun test_repack_mine/1]}},
 		{timeout, 300, {with, {spora_2_6, composite_2}, [fun test_repack_mine/1]}},
 		{timeout, 300, {with, {spora_2_6, unpacked}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_1, spora_2_6}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_1, composite_1}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_1, composite_2}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_1, unpacked}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_2, spora_2_6}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_2, composite_1}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_2, composite_2}, [fun test_repack_mine/1]}},
-		{timeout, 300, {with, {composite_2, unpacked}, [fun test_repack_mine/1]}}
+		{timeout, 600, {with, {composite_1, spora_2_6}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_1, composite_1}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_1, composite_2}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_1, unpacked}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_2, spora_2_6}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_2, composite_1}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_2, composite_2}, [fun test_repack_mine/1]}},
+		{timeout, 600, {with, {composite_2, unpacked}, [fun test_repack_mine/1]}}
 	].
 
 %% --------------------------------------------------------------------------------------------

apps/arweave/include/ar.hrl

@@ -357,9 +357,7 @@
 %% picked as recall chunks and therefore equally incentivize the storage.
 -define(PADDING_NODE_DATA_ROOT, <<>>).
 
--ifdef(DEBUG).
--define(INITIAL_VDF_DIFFICULTY, 2).
--else.
+-ifndef(INITIAL_VDF_DIFFICULTY).
 -define(INITIAL_VDF_DIFFICULTY, 600_000).
 -endif.
 

apps/arweave/include/ar_consensus.hrl

@@ -90,13 +90,9 @@
 %% adding the entropy at certain blocks (rather than nonce limiter steps) allows
 %% miners to use extra bandwidth (bearing almost no additional costs) to compute
 %% nonces on the short forks with different-entropy nonce limiting chains.
--ifdef(DEBUG).
--define(NONCE_LIMITER_RESET_FREQUENCY, 5).
--else.
 -ifndef(NONCE_LIMITER_RESET_FREQUENCY).
 -define(NONCE_LIMITER_RESET_FREQUENCY, (10 * 120)).
 -endif.
--endif.
 
 %% The maximum number of one-step checkpoints the block header may include.
 -ifndef(NONCE_LIMITER_MAX_CHECKPOINTS_COUNT).

apps/arweave/include/ar_vdf.hrl

@@ -6,18 +6,22 @@
 %% Typical ryzen 5900X iterations for 1 sec
 -define(VDF_SHA_1S, 15_000_000).
 
+-ifndef(VDF_DIFFICULTY).
+	-define(VDF_DIFFICULTY, ?VDF_SHA_1S div ?VDF_CHECKPOINT_COUNT_IN_STEP).
+-endif.
+
 -ifdef(DEBUG).
-	-define(VDF_DIFFICULTY, 2).
 	% NOTE. VDF_DIFFICULTY_RETARGET should be > 10 because it's > 10 in mainnet
 	% So VDF difficulty should change slower than difficulty
 	-define(VDF_DIFFICULTY_RETARGET, 20).
 	-define(VDF_HISTORY_CUT, 2).
 -else.
--define(VDF_DIFFICULTY, ?VDF_SHA_1S div ?VDF_CHECKPOINT_COUNT_IN_STEP).
 	-ifndef(VDF_DIFFICULTY_RETARGET).
 		-define(VDF_DIFFICULTY_RETARGET, 720).
 	-endif.
 	-ifndef(VDF_HISTORY_CUT).
 		-define(VDF_HISTORY_CUT, 50).
 	-endif.
 -endif.
+
+

apps/arweave/src/ar_mining_server.erl

@@ -661,7 +661,10 @@ prepare_solution(steps, Candidate, Solution) ->
 					{start_step_number, PrevStepNumber},
 					{next_step_number, StepNumber},
 					{next_seed, ar_util:safe_encode(PrevNextSeed)},
-					{next_vdf_difficulty, PrevNextVDFDifficulty}]),
+					{next_vdf_difficulty, PrevNextVDFDifficulty},
+					{h1, ar_util:safe_encode(Candidate#mining_candidate.h1)},
+					{h2, ar_util:safe_encode(Candidate#mining_candidate.h2)}
+					]),
 			error
 	end;
 

apps/arweave/src/ar_mining_worker.erl

@@ -457,8 +457,11 @@ handle_task({computed_h1, Candidate, _ExtraArgs}, State) ->
 	State2 = hash_computed(h1, Candidate, State),
 	case h1_passes_diff_checks(H1, Candidate, State2) of
 		true ->
-			?LOG_INFO([{event, found_h1_solution}, {worker, State2#state.name},
-				{h1, ar_util:encode(H1)}, {difficulty, get_difficulty(State2, Candidate)}]),
+			?LOG_INFO([{event, found_h1_solution},
+				{step, Candidate#mining_candidate.step_number},
+				{worker, State2#state.name},
+				{h1, ar_util:encode(H1)}, 
+				{difficulty, get_difficulty(State2, Candidate)}]),
 			ar_mining_stats:h1_solution(),
 			%% Decrement 1 for chunk1:
 			%% Since we found a solution we won't need chunk2 (and it will be evicted if
@@ -519,13 +522,15 @@ handle_task({computed_h2, Candidate, _ExtraArgs}, State) ->
 		true ->
 			?LOG_INFO([{event, found_h2_solution},
 					{worker, State#state.name},
+					{step, Candidate#mining_candidate.step_number},
 					{h2, ar_util:encode(H2)},
 					{difficulty, get_difficulty(State2, Candidate)},
 					{partial_difficulty, get_partial_difficulty(State2, Candidate)}]),
 			ar_mining_stats:h2_solution();
 		partial ->
 			?LOG_INFO([{event, found_h2_partial_solution},
 					{worker, State2#state.name},
+					{step, Candidate#mining_candidate.step_number},
 					{h2, ar_util:encode(H2)},
 					{partial_difficulty, get_partial_difficulty(State2, Candidate)}])
 	end,

apps/arweave/test/ar_test_node.erl

@@ -1018,6 +1018,7 @@ test_with_mocked_functions(Functions, TestFun, Timeout) ->
 
 post_and_mine(#{ miner := Node, await_on := AwaitOnNode }, TXs) ->
 	CurrentHeight = remote_call(Node, ar_node, get_height, []),
+	?LOG_INFO("post_and_mine height (~p): ~p", [Node, CurrentHeight+1]),
 	lists:foreach(fun(TX) -> assert_post_tx_to_peer(Node, TX) end, TXs),
 	mine(Node),
 	[{H, _, _} | _] = wait_until_height(AwaitOnNode, CurrentHeight + 1),

rebar.config

@@ -429,7 +429,10 @@
 			%% lower multiplier to allow single-block solutions in tests
 			{d, 'POA1_DIFF_MULTIPLIER', 1},
 			%% use sha256 instead of randomx to speed up tests
-			{d, 'STUB_RANDOMX', true}
+			{d, 'STUB_RANDOMX', true},
+			{d, 'VDF_DIFFICULTY', 2},
+			{d, 'INITIAL_VDF_DIFFICULTY', 2},
+			{d, 'NONCE_LIMITER_RESET_FREQUENCY', 5}
 		]}
 	]},
 	{e2e, [