feat(vapp): remove VAppStateContainer addresses (#174)

Author: mattstam

crates/vapp/src/errors.rs

@@ -79,11 +79,13 @@ pub enum VAppPanic {
     )]
     ProverDelegatedSignerMismatch { prover: Address, delegated_signer: Address },
 
-    #[error("Auctioneer mismatch: request_auctioneer={request_auctioneer}, settle_signer={settle_signer}, auctioneer={auctioneer}")]
-    AuctioneerMismatch { request_auctioneer: Address, settle_signer: Address, auctioneer: Address },
+    #[error("Auctioneer mismatch: request_auctioneer={request_auctioneer}, settle_signer={settle_signer}")]
+    AuctioneerMismatch { request_auctioneer: Address, settle_signer: Address },
 
-    #[error("Executor mismatch: request_executor={request_executor}, execute_signer={execute_signer}, executor={executor}")]
-    ExecutorMismatch { request_executor: Address, execute_signer: Address, executor: Address },
+    #[error(
+        "Executor mismatch: request_executor={request_executor}, execute_signer={execute_signer}"
+    )]
+    ExecutorMismatch { request_executor: Address, execute_signer: Address },
 
     #[error("Address deserialization failed")]
     AddressDeserializationFailed,

crates/vapp/src/sol.rs

@@ -101,9 +101,6 @@ sol! {
         bytes32 accountsRoot;
         bytes32 transactionsRoot;
         address treasury;
-        address auctioneer;
-        address executor;
-        address verifier;
     }
 
     /// @notice The account data for Merkle tree leaves.

crates/vapp/src/state.rs

@@ -61,18 +61,6 @@ pub struct VAppState<A: Storage<Address, Account>, R: Storage<RequestId, bool>>
     ///
     /// Fees earned by the protocol are sent to this address.
     pub treasury: Address,
-    /// The auctioneer address.
-    ///
-    /// This is a trusted party that matches requests to provers.
-    pub auctioneer: Address,
-    /// The executor address.
-    ///
-    /// This is a trusted party that executes the requests and provides auxiliary information.
-    pub executor: Address,
-    /// The verifier address.
-    ///
-    /// This is a trusted party that verifies the proof and provides auxiliary information.
-    pub verifier: Address,
 }
 
 impl VAppState<MerkleStorage<Address, Account>, MerkleStorage<RequestId, bool>> {
@@ -87,9 +75,6 @@ impl VAppState<MerkleStorage<Address, Account>, MerkleStorage<RequestId, bool>>
             accountsRoot: self.accounts.root(),
             transactionsRoot: self.transactions.root(),
             treasury: self.treasury,
-            auctioneer: self.auctioneer,
-            executor: self.executor,
-            verifier: self.verifier,
         };
         H::hash(&state)
     }
@@ -108,9 +93,6 @@ impl VAppState<SparseStorage<Address, Account>, SparseStorage<RequestId, bool>>
             accountsRoot: account_root,
             transactionsRoot: transactions_root,
             treasury: self.treasury,
-            auctioneer: self.auctioneer,
-            executor: self.executor,
-            verifier: self.verifier,
         };
         H::hash(&state)
     }
@@ -119,13 +101,7 @@ impl VAppState<SparseStorage<Address, Account>, SparseStorage<RequestId, bool>>
 impl<A: Storage<Address, Account>, R: Storage<RequestId, bool>> VAppState<A, R> {
     /// Creates a new [`VAppState`].
     #[must_use]
-    pub fn new(
-        domain: B256,
-        treasury: Address,
-        auctioneer: Address,
-        executor: Address,
-        verifier: Address,
-    ) -> Self {
+    pub fn new(domain: B256, treasury: Address) -> Self {
         Self {
             domain,
             tx_id: 1,
@@ -135,9 +111,6 @@ impl<A: Storage<Address, Account>, R: Storage<RequestId, bool>> VAppState<A, R>
             accounts: A::new(),
             transactions: R::new(),
             treasury,
-            auctioneer,
-            executor,
-            verifier,
         }
     }
 
@@ -705,22 +678,17 @@ impl<A: Storage<Address, Account>, R: Storage<RequestId, bool>> VAppState<A, R>
 
                 // Validate that the request, settle, and auctioneer addresses match.
                 let request_auctioneer = address(request.auctioneer.as_slice())?;
-                if !(request_auctioneer == settle_signer && settle_signer == self.auctioneer) {
+                if request_auctioneer != settle_signer {
                     return Err(VAppPanic::AuctioneerMismatch {
                         request_auctioneer,
                         settle_signer,
-                        auctioneer: self.auctioneer,
                     });
                 }
 
                 // Validate that the request, execute, and executor addresses match.
                 let request_executor = address(request.executor.as_slice())?;
-                if !(request_executor == execute_signer && request_executor == self.executor) {
-                    return Err(VAppPanic::ExecutorMismatch {
-                        request_executor,
-                        execute_signer,
-                        executor: self.executor,
-                    });
+                if request_executor != execute_signer {
+                    return Err(VAppPanic::ExecutorMismatch { request_executor, execute_signer });
                 }
 
                 // Ensure that the bid price is less than the max price per pgu.
@@ -866,7 +834,7 @@ impl<A: Storage<Address, Account>, R: Storage<RequestId, bool>> VAppState<A, R>
                             .hash_with_signer(fulfill_signer.as_slice())
                             .map_err(|_| VAppPanic::HashingBodyFailed)?;
                         let verifier = eth_sign_verify(&fulfillment_id, verify)?;
-                        if verifier != self.verifier {
+                        if verifier != address(request.verifier.as_slice())? {
                             return Err(VAppPanic::InvalidVerifierSignature);
                         }
                     }

crates/vapp/tests/clear.rs

@@ -1762,12 +1762,14 @@ fn test_clear_auctioneer_mismatch_global() {
     let create_prover_tx = create_prover_tx(prover_address, prover_address, U256::ZERO, 1, 2, 2);
     test.state.execute::<MockVerifier>(&create_prover_tx).unwrap();
 
-    // For this test, we need to modify the request's auctioneer field.
-    let clear_tx = create_clear_tx(
+    // Create a clear transaction where the request specifies test.auctioneer
+    // but the settle is signed by a different signer.
+    let clear_tx = create_clear_tx_with_mismatched_auctioneer(
         &test.requester,
         &test.fulfiller,
         &test.fulfiller,
-        &signer("different_auctioneer"),
+        &test.auctioneer,                // Expected auctioneer in request
+        &signer("different_auctioneer"), // Wrong settle signer
         &test.executor,
         &test.verifier,
         1,
@@ -1801,14 +1803,14 @@ fn test_clear_executor_mismatch_request() {
     let create_prover_tx = create_prover_tx(prover_address, prover_address, U256::ZERO, 1, 2, 2);
     test.state.execute::<MockVerifier>(&create_prover_tx).unwrap();
 
-    // Create clear transaction where execute signer != request executor.
+    // Create clear transaction with correct executor in request but wrong execute signer.
     let wrong_executor = signer("wrong_executor");
-    let clear_tx = create_clear_tx(
+    let mut clear_tx = create_clear_tx(
         &test.requester,
         &test.fulfiller,
         &test.fulfiller,
         &test.auctioneer,
-        &wrong_executor, // Wrong executor as execute signer
+        &test.executor,
         &test.verifier,
         1,
         U256::from(50_000),
@@ -1821,6 +1823,13 @@ fn test_clear_executor_mismatch_request() {
         false,
     );
 
+    // Replace the execute signature with wrong signer.
+    if let VAppTransaction::Clear(ref mut clear) = clear_tx {
+        if let Some(ref execute_body) = clear.execute.body {
+            clear.execute.signature = proto_sign(&wrong_executor, execute_body).as_bytes().to_vec();
+        }
+    }
+
     // Execute should fail with ExecutorMismatch.
     let result = test.state.execute::<MockVerifier>(&clear_tx);
     assert!(matches!(result, Err(VAppPanic::ExecutorMismatch { .. })));
@@ -1841,13 +1850,15 @@ fn test_clear_executor_mismatch_global() {
     let create_prover_tx = create_prover_tx(prover_address, prover_address, U256::ZERO, 1, 2, 2);
     test.state.execute::<MockVerifier>(&create_prover_tx).unwrap();
 
-    // For this test, we need to modify the request's executor field.
-    let clear_tx = create_clear_tx(
+    // Create a clear transaction where the request specifies test.executor
+    // but the execute is signed by a different signer.
+    let different_executor = signer("different_executor");
+    let mut clear_tx = create_clear_tx(
         &test.requester,
         &test.fulfiller,
         &test.fulfiller,
         &test.auctioneer,
-        &signer("different_executor"),
+        &test.executor,
         &test.verifier,
         1,
         U256::from(50_000),
@@ -1860,6 +1871,14 @@ fn test_clear_executor_mismatch_global() {
         false,
     );
 
+    // Replace the execute signature with different signer.
+    if let VAppTransaction::Clear(ref mut clear) = clear_tx {
+        if let Some(ref execute_body) = clear.execute.body {
+            clear.execute.signature =
+                proto_sign(&different_executor, execute_body).as_bytes().to_vec();
+        }
+    }
+
     // Execute should fail with ExecutorMismatch.
     let result = test.state.execute::<MockVerifier>(&clear_tx);
     assert!(matches!(result, Err(VAppPanic::ExecutorMismatch { .. })));
@@ -2194,14 +2213,14 @@ fn test_clear_verifier_address_mismatch() {
     // Create a wrong verifier signer.
     let wrong_verifier = signer("wrong_verifier");
 
-    // Create clear transaction with wrong verifier signing.
-    let clear_tx = create_clear_tx(
+    // Create clear transaction with correct verifier in request but wrong verifier signing.
+    let mut clear_tx = create_clear_tx(
         &test.requester,
         &test.fulfiller,
         &test.fulfiller,
         &test.auctioneer,
         &test.executor,
-        &wrong_verifier, // Wrong verifier
+        &test.verifier,
         1,
         U256::from(50_000),
         1,
@@ -2213,6 +2232,15 @@ fn test_clear_verifier_address_mismatch() {
         true,
     );
 
+    // Replace the verifier signature with wrong signer.
+    if let VAppTransaction::Clear(ref mut clear) = clear_tx {
+        if let Some(ref fulfill) = clear.fulfill {
+            if let Some(ref fulfill_body) = fulfill.body {
+                clear.verify = Some(proto_sign(&wrong_verifier, fulfill_body).as_bytes().to_vec());
+            }
+        }
+    }
+
     // Execute should fail with InvalidVerifierSignature.
     let result = test.state.execute::<MockVerifier>(&clear_tx);
     assert!(matches!(result, Err(VAppPanic::InvalidVerifierSignature)));

crates/vapp/tests/common/mod.rs

@@ -75,13 +75,7 @@ pub fn setup() -> VAppTestContext {
     let auctioneer = signer("auctioneer");
     let executor = signer("executor");
     let verifier = signer("verifier");
-    let state = VAppState::new(
-        domain,
-        treasury.address(),
-        auctioneer.address(),
-        executor.address(),
-        verifier.address(),
-    );
+    let state = VAppState::new(domain, treasury.address());
     VAppTestContext {
         state,
         auctioneer,

crates/vapp/tests/delegate.rs

@@ -18,7 +18,7 @@ fn test_delegate_basic() {
     let prover_owner = test.signers[0].clone();
     let prover_address = test.signers[1].address();
     let delegate_address = test.signers[2].address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Create prover first.
     let create_prover_tx =
@@ -85,7 +85,7 @@ fn test_delegate_multiple_delegations() {
     let delegate1 = test.signers[2].address();
     let delegate2 = test.signers[3].address();
     let delegate3 = test.signers[4].address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Create prover first.
     let create_prover_tx =
@@ -442,7 +442,7 @@ fn test_delegate_exact_balance() {
     let prover_owner = test.signers[0].clone();
     let prover_address = test.signers[1].address();
     let delegate_address = test.signers[2].address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Create prover first.
     let create_prover_tx =

crates/vapp/tests/withdraw.rs

@@ -9,7 +9,7 @@ use crate::common::*;
 fn test_withdraw_basic() {
     let mut test = setup();
     let account = test.requester.address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Set up initial balance with deposit (101 PROVE = 101e18 wei).
     let initial_balance = U256::from(101) * U256::from(10).pow(U256::from(18));
@@ -36,7 +36,7 @@ fn test_withdraw_basic() {
 fn test_withdraw_partial() {
     let mut test = setup();
     let account = test.requester.address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Set up initial balance with deposit (503 PROVE to cover 3 withdrawals with fees).
     let initial_balance = U256::from(503) * U256::from(10).pow(U256::from(18));
@@ -78,7 +78,7 @@ fn test_withdraw_partial() {
 fn test_withdraw_exact_balance() {
     let mut test = setup();
     let account = test.requester.address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Set up initial balance with deposit (790 PROVE).
     let initial_balance = U256::from(790) * U256::from(10).pow(U256::from(18));
@@ -151,7 +151,7 @@ fn test_withdraw_prover_self_withdraw() {
     let mut test = setup();
     let prover_address = test.fulfiller.address();
     let prover_owner = test.requester.address();
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Create a prover with owner different from prover address.
     let create_tx = create_prover_tx(prover_address, prover_owner, U256::from(500), 0, 1, 1);
@@ -189,7 +189,7 @@ fn test_withdraw_third_party_for_prover() {
     let prover_address = test.fulfiller.address();
     let prover_owner = test.requester.address();
     let third_party = test.signers[0].clone(); // Third party who will sign the withdraw
-    let auctioneer = test.state.auctioneer;
+    let auctioneer = test.auctioneer.address();
 
     // Create a prover with owner different from prover address.
     let create_tx = create_prover_tx(prover_address, prover_owner, U256::from(500), 0, 1, 1);