Skip to content

Commit 7559f9b

Browse files
JuArceJuArce
authored
feat(explorer): enable aggregation for Mainnet (#2266)
1 parent c532036 commit 7559f9b

6 files changed

Lines changed: 183 additions & 122 deletions

File tree

‎explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex‎

Lines changed: 46 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,10 @@ defmodule AlignedProofAggregationService do
3636
end
3737

3838
def get_aggregated_proof_event(%{from_block: fromBlock, to_block: toBlock}) do
39+
Logger.debug(
40+
"[Aggregated Proofs] Querying contract #{@contract_address} for events from block #{fromBlock} to #{toBlock}"
41+
)
42+
3943
events =
4044
AlignedProofAggregationService.EventFilters.aggregated_proof_verified(nil)
4145
|> Ethers.get_logs(fromBlock: fromBlock, toBlock: toBlock)
@@ -45,6 +49,8 @@ defmodule AlignedProofAggregationService do
4549
{:ok, []}
4650

4751
{:ok, list} ->
52+
Logger.debug("[Aggregated Proofs] Raw events received: #{length(list)}")
53+
4854
{:ok,
4955
Enum.map(list, fn x ->
5056
data = x |> Map.get(:data)
@@ -64,6 +70,10 @@ defmodule AlignedProofAggregationService do
6470
end)}
6571

6672
{:error, reason} ->
73+
Logger.error(
74+
"[Aggregated Proofs] RPC error querying events from contract #{@contract_address}: #{inspect(reason)}"
75+
)
76+
6777
{:error, reason}
6878
end
6979
end
@@ -78,11 +88,20 @@ defmodule AlignedProofAggregationService do
7888
# Note: first two characters are the 0x
7989
function_signature = String.slice(input, 0..9)
8090

81-
case function_signature do
82-
@verifyRisc0_solidity_signature -> :risc0
83-
@verifySp1_solidity_signature -> :sp1
84-
_ -> nil
91+
aggregator =
92+
case function_signature do
93+
@verifyRisc0_solidity_signature -> :risc0
94+
@verifySp1_solidity_signature -> :sp1
95+
_ -> nil
96+
end
97+
98+
if is_nil(aggregator) do
99+
Logger.warning(
100+
"[Aggregated Proofs] Unknown aggregator function signature: #{function_signature} for tx_hash: #{tx_hash}"
101+
)
85102
end
103+
104+
aggregator
86105
end
87106

88107
def get_block_timestamp(block_number) do
@@ -93,25 +112,47 @@ defmodule AlignedProofAggregationService do
93112
end
94113

95114
def get_blob_data!(aggregated_proof) do
115+
Logger.debug(
116+
"[Aggregated Proofs] Fetching blob data for block #{aggregated_proof.block_number}, versioned_hash: #{aggregated_proof.blob_versioned_hash}"
117+
)
118+
96119
{:ok, block} =
97120
Explorer.EthClient.get_block_by_number(
98121
Explorer.Utils.decimal_to_hex(aggregated_proof.block_number)
99122
)
100123

101124
parent_beacon_block_hash = Map.get(block, "parentBeaconBlockRoot")
102125

126+
Logger.debug(
127+
"[Aggregated Proofs] Got parent beacon block hash: #{parent_beacon_block_hash}"
128+
)
129+
103130
{:ok, beacon_block} =
104131
Explorer.BeaconClient.get_block_header_by_parent_hash(parent_beacon_block_hash)
105132

106133
slot = Explorer.BeaconClient.get_block_slot(beacon_block)
107134

135+
Logger.debug("[Aggregated Proofs] Fetching blob from beacon slot: #{slot}")
136+
108137
data =
109138
Explorer.BeaconClient.fetch_blob_by_versioned_hash!(
110139
slot,
111140
aggregated_proof.blob_versioned_hash
112141
)
113142

114-
Map.get(data, "blob")
143+
blob = Map.get(data, "blob")
144+
145+
if is_nil(blob) do
146+
Logger.error(
147+
"[Aggregated Proofs] No blob data returned for versioned_hash: #{aggregated_proof.blob_versioned_hash} at slot #{slot}"
148+
)
149+
else
150+
Logger.debug(
151+
"[Aggregated Proofs] Successfully fetched blob data (#{String.length(blob)} chars)"
152+
)
153+
end
154+
155+
blob
115156
end
116157

117158
@doc """

‎explorer/lib/explorer/periodically.ex‎

Lines changed: 100 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -88,59 +88,116 @@ defmodule Explorer.Periodically do
8888
end
8989

9090
def process_aggregated_proofs(from_block, to_block) do
91-
"Processing aggregated proofs from #{from_block} to #{to_block}" |> Logger.debug()
92-
93-
{:ok, proofs} =
94-
AlignedProofAggregationService.get_aggregated_proof_event(%{
95-
from_block: from_block,
96-
to_block: to_block
97-
})
98-
99-
blob_data =
100-
proofs
101-
|> Enum.map(&AlignedProofAggregationService.get_blob_data!/1)
102-
103-
proof_hashes =
104-
blob_data
105-
|> Enum.map(fn x ->
106-
AlignedProofAggregationService.decode_blob(
107-
to_charlist(String.replace_prefix(x, "0x", ""))
91+
Logger.info("[Aggregated Proofs] Starting fetch from block #{from_block} to #{to_block}")
92+
93+
case AlignedProofAggregationService.get_aggregated_proof_event(%{
94+
from_block: from_block,
95+
to_block: to_block
96+
}) do
97+
{:ok, []} ->
98+
Logger.info("[Aggregated Proofs] No events found in block range #{from_block}-#{to_block}")
99+
100+
{:ok, proofs} ->
101+
Logger.info(
102+
"[Aggregated Proofs] Found #{length(proofs)} events in block range #{from_block}-#{to_block}"
108103
)
109-
end)
110104

111-
# Store aggregated proofs to db
112-
proofs =
113-
proofs
114-
|> Enum.zip(proof_hashes)
115-
|> Enum.map(fn {agg_proof, hashes} ->
116-
aggregator = AlignedProofAggregationService.get_aggregator!(agg_proof)
105+
process_aggregated_proof_events(proofs)
117106

107+
{:error, reason} ->
108+
Logger.error(
109+
"[Aggregated Proofs] Failed to fetch events from block #{from_block} to #{to_block}: #{inspect(reason)}"
110+
)
111+
end
112+
end
113+
114+
defp process_aggregated_proof_events(proofs) do
115+
proofs
116+
|> Enum.each(fn proof ->
117+
Logger.info(
118+
"[Aggregated Proofs] Processing proof at block #{proof.block_number}, merkle_root: #{proof.merkle_root}"
119+
)
120+
121+
try do
122+
# Fetch blob data
123+
Logger.debug(
124+
"[Aggregated Proofs] Fetching blob data for versioned_hash: #{proof.blob_versioned_hash}"
125+
)
126+
127+
blob_data = AlignedProofAggregationService.get_blob_data!(proof)
128+
129+
# Decode blob to get proof hashes
130+
proof_hashes =
131+
AlignedProofAggregationService.decode_blob(
132+
to_charlist(String.replace_prefix(blob_data, "0x", ""))
133+
)
134+
135+
Logger.info(
136+
"[Aggregated Proofs] Decoded #{length(proof_hashes)} proof hashes from blob"
137+
)
138+
139+
# Get aggregator type
140+
aggregator = AlignedProofAggregationService.get_aggregator!(proof)
141+
142+
Logger.debug(
143+
"[Aggregated Proofs] Aggregator type: #{inspect(aggregator)} for merkle_root: #{proof.merkle_root}"
144+
)
145+
146+
# Store aggregated proof to db
118147
agg_proof =
119-
agg_proof
148+
proof
120149
|> Map.merge(%{aggregator: aggregator})
121-
|> Map.merge(%{number_of_proofs: length(hashes)})
150+
|> Map.merge(%{number_of_proofs: length(proof_hashes)})
122151

123-
{:ok, %{id: id}} = AggregatedProofs.insert_or_update(agg_proof)
152+
case AggregatedProofs.insert_or_update(agg_proof) do
153+
{:ok, %{id: id}} ->
154+
Logger.info(
155+
"[Aggregated Proofs] Stored aggregated proof id=#{id}, merkle_root: #{proof.merkle_root}, proofs_count: #{length(proof_hashes)}"
156+
)
124157

125-
Map.merge(agg_proof, %{id: id})
126-
end)
158+
# Store each individual proof hash
159+
store_individual_proofs(id, proof_hashes, proof.merkle_root)
127160

128-
# Store each individual proof
129-
proofs
130-
|> Enum.zip(proof_hashes)
131-
|> Enum.each(fn {agg_proof, hashes} ->
132-
hashes
133-
|> Enum.with_index()
134-
|> Enum.each(fn {hash, index} ->
135-
AggregationModeProof.insert_or_update(%{
136-
agg_proof_id: agg_proof.id,
137-
proof_hash: "0x" <> List.to_string(hash),
138-
index: index
139-
})
140-
end)
161+
{:error, reason} ->
162+
Logger.error(
163+
"[Aggregated Proofs] Failed to store aggregated proof merkle_root: #{proof.merkle_root}: #{inspect(reason)}"
164+
)
165+
end
166+
rescue
167+
error ->
168+
Logger.error(
169+
"[Aggregated Proofs] Error processing proof at block #{proof.block_number}, merkle_root: #{proof.merkle_root}: #{Exception.message(error)}"
170+
)
171+
172+
Logger.debug(
173+
"[Aggregated Proofs] Stacktrace: #{Exception.format_stacktrace(__STACKTRACE__)}"
174+
)
175+
end
141176
end)
142177

143-
"Done processing aggregated proofs from #{from_block} to #{to_block}" |> Logger.debug()
178+
Logger.info("[Aggregated Proofs] Finished processing #{length(proofs)} events")
179+
end
180+
181+
defp store_individual_proofs(agg_proof_id, proof_hashes, merkle_root) do
182+
proof_hashes
183+
|> Enum.with_index()
184+
|> Enum.each(fn {hash, index} ->
185+
proof_hash = "0x" <> List.to_string(hash)
186+
187+
case AggregationModeProof.insert_or_update(%{
188+
agg_proof_id: agg_proof_id,
189+
proof_hash: proof_hash,
190+
index: index
191+
}) do
192+
{:ok, _} ->
193+
:ok
194+
195+
{:error, reason} ->
196+
Logger.error(
197+
"[Aggregated Proofs] Failed to store individual proof hash #{proof_hash} for merkle_root: #{merkle_root}: #{inspect(reason)}"
198+
)
199+
end
200+
end)
144201
end
145202

146203
def process_batches(fromBlock, toBlock) do

‎explorer/lib/explorer_web/components/contracts.ex‎

Lines changed: 5 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -8,25 +8,13 @@ defmodule ContractsComponent do
88
def mount(socket) do
99
addresses = Helpers.get_aligned_contracts_addresses()
1010

11-
proof_aggregator_service =
12-
case Helpers.is_mainnet() do
13-
true ->
14-
[]
15-
16-
false ->
17-
[
18-
%{
19-
contract_name: "AlignedProofAggregationService",
20-
address: addresses["alignedProofAggregationService"]
21-
}
22-
]
23-
end
24-
2511
{:ok,
2612
assign(socket,
27-
contracts:
28-
proof_aggregator_service ++
29-
[
13+
contracts: [
14+
%{
15+
contract_name: "AlignedProofAggregationService",
16+
address: addresses["alignedProofAggregationService"]
17+
},
3018
%{
3119
contract_name: "AlignedServiceManager",
3220
address: addresses["alignedLayerServiceManager"]

‎explorer/lib/explorer_web/components/nav.ex‎

Lines changed: 25 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -61,19 +61,17 @@ defmodule NavComponent do
6161
>
6262
Batches
6363
</.link>
64-
<%= if !ExplorerWeb.Helpers.is_mainnet() do %>
65-
<.link
66-
class={
67-
active_view_class(@socket.view, [
68-
ExplorerWeb.AggProofs.Index,
69-
ExplorerWeb.AggProof.Index
70-
])
71-
}
72-
navigate={~p"/aggregated_proofs"}
73-
>
74-
Aggregation
75-
</.link>
76-
<% end %>
64+
<.link
65+
class={
66+
active_view_class(@socket.view, [
67+
ExplorerWeb.AggProofs.Index,
68+
ExplorerWeb.AggProof.Index
69+
])
70+
}
71+
navigate={~p"/aggregated_proofs"}
72+
>
73+
Aggregation
74+
</.link>
7775
<.nav_links_dropdown
7876
title="Restaking"
7977
class={
@@ -158,22 +156,20 @@ defmodule NavComponent do
158156
>
159157
Batches
160158
</.link>
161-
<%= if !ExplorerWeb.Helpers.is_mainnet() do %>
162-
<.link
163-
class={
164-
classes([
165-
active_view_class(assigns.socket.view, [
166-
ExplorerWeb.AggregatedProofs.Index,
167-
ExplorerWeb.AggregatedProof.Index
168-
]),
169-
"text-foreground/80 hover:text-foreground font-semibold"
170-
])
171-
}
172-
navigate={~p"/aggregated_proofs"}
173-
>
174-
Aggregation
175-
</.link>
176-
<% end %>
159+
<.link
160+
class={
161+
classes([
162+
active_view_class(assigns.socket.view, [
163+
ExplorerWeb.AggregatedProofs.Index,
164+
ExplorerWeb.AggregatedProof.Index
165+
]),
166+
"text-foreground/80 hover:text-foreground font-semibold"
167+
])
168+
}
169+
navigate={~p"/aggregated_proofs"}
170+
>
171+
Aggregation
172+
</.link>
177173
<.link
178174
class="hover:text-foreground"
179175
target="_blank"

0 commit comments

Comments
 (0)