Merge branch 'testnet' into staging

Author: uri-99

aggregator/cmd/main.go

@@ -49,7 +49,7 @@ func aggregatorMain(ctx *cli.Context) error {
 		return err
 	}
 
-	// Listen for new task created in the ServiceManager contract in a separate goroutine
+	// Listen for new task created in the ServiceManager contract in a separate goroutine, both V1 and V2 subscriptions:
 	go func() {
 		listenErr := aggregator.SubscribeToNewTasks()
 		if listenErr != nil {

aggregator/internal/pkg/aggregator.go

@@ -276,14 +276,14 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
 		"batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
-
+	// current_task_block := agg.batchCreatedBlockByIdx[blsAggServiceResp.TaskIndex]
 	for i := 0; i < MaxSentTxRetries; i++ {
 		_, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
 		if err == nil {
 			agg.logger.Info("Aggregator successfully responded to task",
 				"taskIndex", blsAggServiceResp.TaskIndex,
 				"batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
-
+				
 			return
 		}
 

batcher/aligned-sdk/abi/AlignedLayerServiceManager.json

@@ -95,12 +95,14 @@ contract AlignedLayerServiceManager is
 
         batchesState[batchIdentifier] = batchState;
 
+        // For operators:
         emit NewBatchV2(
             batchMerkleRoot,
             msg.sender,
             uint32(block.number),
             batchDataPointer
         );
+        // For aggregator:
         emit NewBatchV3(
             batchMerkleRoot,
             msg.sender,

contracts/bindings/AlignedLayerServiceManager/binding.go

@@ -207,7 +207,7 @@ func (s *AvsSubscriber) getLatestTaskFromEthereum() (*servicemanager.ContractAli
 	}
 
 	// We just care about the NewBatch event
-	newBatchEvent := alignedLayerServiceManagerABI.Events["NewBatch"]
+	newBatchEvent := alignedLayerServiceManagerABI.Events["NewBatchV3"]
 	if newBatchEvent.ID == (ethcommon.Hash{}) {
 		return nil, fmt.Errorf("NewBatch event not found in ABI")
 	}
@@ -234,7 +234,7 @@ func (s *AvsSubscriber) getLatestTaskFromEthereum() (*servicemanager.ContractAli
 	lastLog := logs[len(logs)-1]
 
 	var latestTask servicemanager.ContractAlignedLayerServiceManagerNewBatchV3
-	err = alignedLayerServiceManagerABI.UnpackIntoInterface(&latestTask, "NewBatch", lastLog.Data)
+	err = alignedLayerServiceManagerABI.UnpackIntoInterface(&latestTask, "NewBatchV3", lastLog.Data)
 	if err != nil {
 		return nil, fmt.Errorf("failed to unpack log data: %w", err)
 	}

contracts/bindings/ERC20Mock/binding.go

@@ -5,6 +5,12 @@ import (
 	eigentypes "github.com/Layr-Labs/eigensdk-go/types"
 )
 
+// type SignedTaskResponse struct {
+// 	BatchMerkleRoot [32]byte
+// 	BlsSignature    bls.Signature
+// 	OperatorId      eigentypes.OperatorId
+// }
+
 type SignedTaskResponse struct {
 	BatchMerkleRoot [32]byte
 	SenderAddress [20]byte

contracts/scripts/anvil/state/alignedlayer-deployed-anvil-state.json

@@ -116,12 +116,13 @@ The proof submission and verification can be done either with the SDK or by usin
 
 #### Using the SDK
 
-To submit a proof using the SDK, you can use the `submit` function, and then you can use the `verify_proof_onchain` function to check if the proof was correctly verified in Aligned.
-
+To submit a proof using the SDK, you can use the `submit_and_wait_verification` function.
+This function submits the proof to aligned and waits for it to be verified in Aligned.
+Alternatively you can call `submit` if you dont want to wait for proof verification.
 The following code is an example of how to submit a proof using the SDK:
 
 ```rust
-use aligned_sdk::sdk::{submit, get_next_nonce};
+use aligned_sdk::sdk::{submit_and_wait_verification, get_next_nonce};
 use aligned_sdk::types::{ProvingSystemId, VerificationData};
 use ethers::prelude::*;
 
@@ -147,13 +148,33 @@ async fn submit_proof_to_aligned(
         .await
         .map_err(|e| anyhow::anyhow!("Failed to get next nonce: {:?}", e))?;
 
-    submit(BATCHER_URL, &verification_data, wallet, nonce).await
-        .map_err(|e| anyhow::anyhow!("Failed to submit proof: {:?}", e))
+    match submit_and_wait_verification(
+        BATCHER_URL,
+        &rpc_url,
+        Chain::Holesky,
+        &verification_data,
+        wallet.clone(),
+        nonce,
+        BATCHER_PAYMENTS_ADDRESS
+    )
+
+    submit_and_wait_verification(
+        BATCHER_URL,
+        RPC_URL,
+        Chain::Holesky,
+        &verification_data,
+        wallet,
+        nonce,
+        BATCHER_CONTRACT_ADDRESS
+    ).await.map_err(|e| anyhow::anyhow!("Failed to submit proof: {:?}", e))
 }
 
 #[tokio::main]
 async fn main() {
     let wallet = // Initialize wallet
+
+    let wallet = wallet.with_chain_id(17000u64)
+
     let proof = // Generate or obtain proof
 
     match submit_proof_to_aligned(proof, wallet).await {
@@ -163,41 +184,6 @@ async fn main() {
 }
 ```
 
-The following code is an example of how to verify the proof was correctly verified in Aligned using the SDK:
-
-```rust
-use aligned_sdk::sdk::verify_proof_onchain;
-use aligned_sdk::types::{AlignedVerificationData, Chain};
-use ethers::prelude::*;
-use tokio::time::{sleep, Duration};
-
-async fn wait_for_proof_verification(
-    aligned_verification_data: AlignedVerificationData,
-    rpc_url: String,
-) -> Result<(), anyhow::Error> {
-    for _ in 0..10 {
-        if verify_proof_onchain(aligned_verification_data.clone(), Chain::Holesky, rpc_url.as_str()).await.is_ok_and(|r| r) {
-            println!("Proof verified successfully.");
-            return Ok(());
-        }
-        println!("Proof not verified yet. Waiting 10 seconds before checking again...");
-        sleep(Duration::from_secs(10)).await;
-    }
-    anyhow::bail!("Proof verification failed")
-}
-
-#[tokio::main]
-async fn main() {
-    let aligned_verification_data = // Obtain aligned verification data
-    let rpc_url = "https://ethereum-holesky-rpc.publicnode.com".to_string();
-
-    match wait_for_proof_verification(aligned_verification_data, rpc_url).await {
-        Ok(_) => println!("Proof verified"),
-        Err(err) => println!("Error: {:?}", err),
-    }
-}
-```
-
 You can find an example of the proof submission and verification in the [ZKQuiz Program](../../examples/zkquiz/quiz/script/src/main.rs).
 
 This example generates a proof, instantiates a wallet to submit the proof, and then submits the proof to Aligned for verification. It then waits for the proof to be verified in Aligned.