BM-279: Added single entry point for submitMerkle + fulfillBatches (github#91)

This PR introduces a single transaction entry point for fulfillment of
orders to simplify and reduce errors between merkle submission and order
fulfillment. It does so by adding a optional method on the proof market
to perform both actions in a single TXN.

---------

Co-authored-by: Victor Graf <[email protected]>

Author: mothran

contracts/src/IProofMarket.sol

@@ -168,6 +168,15 @@ interface IProofMarket {
     /// Fulfills a batch of locked requests
     function fulfillBatch(Fulfillment[] calldata fills, bytes calldata assessorSeal) external;
 
+    /// Optional path to combine submitting a new merkle root to the set-verifier and then calling fulfillBatch
+    /// Useful to reduce the transaction count for fulfillments
+    function submitRootAndFulfillBatch(
+        bytes32 root,
+        bytes calldata seal,
+        Fulfillment[] calldata fills,
+        bytes calldata assessorSeal
+    ) external;
+
     /// When a prover fails to fulfill a request by the deadline, this method can be used to burn
     /// the associated prover stake.
     function slash(uint192 requestId) external;

contracts/src/ProofMarket.sol

@@ -9,6 +9,7 @@ import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
 import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
 import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import {IRiscZeroVerifier, Receipt, ReceiptClaim, ReceiptClaimLib} from "risc0/IRiscZeroVerifier.sol";
+import {IRiscZeroSetVerifier} from "./IRiscZeroSetVerifier.sol";
 
 import {IProofMarket, ProvingRequest, Offer, Fulfillment, AssessorJournal} from "./IProofMarket.sol";
 import {ProofMarketLib} from "./ProofMarketLib.sol";
@@ -266,7 +267,7 @@ contract ProofMarket is IProofMarket, EIP712 {
         emit RequestFulfilled(fill.id, fill.journal, fill.seal);
     }
 
-    function fulfillBatch(Fulfillment[] calldata fills, bytes calldata assessorSeal) external {
+    function fulfillBatch(Fulfillment[] calldata fills, bytes calldata assessorSeal) public {
         // TODO(victor): Figure out how much the memory here is costing. If it's significant, we can do some tricks to reduce memory pressure.
         bytes32[] memory claimDigests = new bytes32[](fills.length);
         uint192[] memory ids = new uint192[](fills.length);
@@ -362,6 +363,17 @@ contract ProofMarket is IProofMarket, EIP712 {
     function imageInfo() external view returns (bytes32, string memory) {
         return (ASSESSOR_ID, imageUrl);
     }
+
+    function submitRootAndFulfillBatch(
+        bytes32 root,
+        bytes calldata seal,
+        Fulfillment[] calldata fills,
+        bytes calldata assessorSeal
+    ) external {
+        IRiscZeroSetVerifier setVerifier = IRiscZeroSetVerifier(address(VERIFIER));
+        setVerifier.submitMerkleRoot(root, seal);
+        fulfillBatch(fills, assessorSeal);
+    }
 }
 
 // Functions copied from OZ MerkleProof library to allow building the Merkle tree above.

contracts/test/ProofMarket.t.sol

@@ -160,9 +160,9 @@ contract ProofMarketTest is Test {
         return (fills[0], seal);
     }
 
-    function fulfillRequestBatch(ProvingRequest[] memory requests, bytes[] memory journals)
+    function createFills(ProvingRequest[] memory requests, bytes[] memory journals)
         internal
-        returns (Fulfillment[] memory fills, bytes memory assessorSeal)
+        returns (Fulfillment[] memory fills, bytes memory assessorSeal, bytes32 root)
     {
         // initialize the fullfillments; one for each request;
         // the seal is filled in later, by calling fillInclusionProof
@@ -182,15 +182,25 @@ contract ProofMarketTest is Test {
             TestUtils.mockAssessor(fills, ASSESSOR_IMAGE_ID, proofMarket.eip712DomainSeparator());
         // compute the batchRoot of the batch Merkle Tree (without the assessor)
         (bytes32 batchRoot, bytes32[][] memory tree) = TestUtils.mockSetBuilder(fills);
-        // Join the batchRoot with the assessor digest.
-        bytes32 root = MerkleProofish._hashPair(batchRoot, assessorClaim.digest());
-        // submit the root to the set verifier
-        publishRoot(root);
+
+        root = MerkleProofish._hashPair(batchRoot, assessorClaim.digest());
+
         // compute all the inclusion proofs for the fullfillments
         TestUtils.fillInclusionProofs(setVerifier, fills, assessorClaim.digest(), tree);
         // compute the assessor seal
         assessorSeal = TestUtils.mockAssessorSeal(setVerifier, batchRoot);
 
+        return (fills, assessorSeal, root);
+    }
+
+    function fulfillRequestBatch(ProvingRequest[] memory requests, bytes[] memory journals)
+        internal
+        returns (Fulfillment[] memory fills, bytes memory assessorSeal)
+    {
+        bytes32 root;
+        (fills, assessorSeal, root) = createFills(requests, journals);
+        // submit the root to the set verifier
+        publishRoot(root);
         return (fills, assessorSeal);
     }
 
@@ -749,6 +759,19 @@ contract ProofMarketTest is Test {
         benchFulfillBatch(128);
     }
 
+    function testsubmitRootAndFulfillBatch() public {
+        (ProvingRequest[] memory requests, bytes[] memory journals) = newBatch(2);
+        (Fulfillment[] memory fills, bytes memory assessorSeal, bytes32 root) = createFills(requests, journals);
+
+        bytes memory seal =
+            verifier.mockProve(SET_BUILDER_IMAGE_ID, sha256(abi.encodePacked(SET_BUILDER_IMAGE_ID, root))).seal;
+        proofMarket.submitRootAndFulfillBatch(root, seal, fills, assessorSeal);
+
+        for (uint256 j = 0; j < fills.length; j++) {
+            assertTrue(proofMarket.requestIsFulfilled(fills[j].id), "Request should have fulfilled status");
+        }
+    }
+
     function testProcessTree2() public pure {
         bytes32[] memory leaves = new bytes32[](2);
         leaves[0] = 0x6a428060b5d51f04583182f2ff1b565f9db661da12ee7bdc003e9ab6d5d91ba9;

crates/boundless-market/src/contracts/proof_market.rs

@@ -383,6 +383,32 @@ where
         Ok(())
     }
 
+    pub async fn submit_merkle_and_fulfill(
+        &self,
+        root: B256,
+        seal: Bytes,
+        fulfillments: Vec<Fulfillment>,
+        assessor_seal: Bytes,
+    ) -> Result<(), MarketError> {
+        tracing::debug!("Calling submitRootAndFulfillBatch({root:?}, {seal:x}, {fulfillments:?}, {assessor_seal:x})");
+        let call = self
+            .instance
+            .submitRootAndFulfillBatch(root, seal, fulfillments, assessor_seal)
+            .from(self.caller);
+        tracing::debug!("Calldata: {}", call.calldata());
+        let pending_tx = call.send().await.map_err(IProofMarketErrors::decode_error)?;
+        tracing::debug!("Broadcasting tx {}", pending_tx.tx_hash());
+        let tx_hash = pending_tx
+            .with_timeout(Some(self.timeout))
+            .watch()
+            .await
+            .context("failed to confirm tx")?;
+
+        tracing::info!("Submitted merkle root and proof for batch {}", tx_hash);
+
+        Ok(())
+    }
+
     /// Checks if a request is locked in.
     pub async fn is_locked_in(&self, request_id: U256) -> Result<bool, MarketError> {
         tracing::debug!("Calling requestIsLocked({})", request_id);
@@ -889,4 +915,59 @@ mod tests {
         assert_eq!(journal, fulfillment.journal);
         assert_eq!(seal, fulfillment.seal);
     }
+
+    #[tokio::test]
+    #[traced_test]
+    async fn test_e2e_merged_submit_fulfill() {
+        // Setup anvil
+        let anvil = Anvil::new().spawn();
+
+        let ctx = TestCtx::new(&anvil).await.unwrap();
+
+        let eip712_domain = eip712_domain! {
+            name: "IProofMarket",
+            version: "1",
+            chain_id: anvil.chain_id(),
+            verifying_contract: *ctx.customer_market.instance().address(),
+        };
+
+        let request = new_request(1, &ctx).await;
+
+        let request_id =
+            ctx.customer_market.submit_request(&request, &ctx.customer_signer).await.unwrap();
+
+        // fetch logs to retrieve the customer signature from the event
+        let logs = ctx.customer_market.instance().RequestSubmitted_filter().query().await.unwrap();
+
+        let (_, log) = logs.first().unwrap();
+        let log = log.log_decode::<IProofMarket::RequestSubmitted>().unwrap();
+        let request = log.inner.data.request;
+        let customer_sig = log.inner.data.clientSignature;
+
+        // Deposit prover balances
+        ctx.prover_market.deposit(parse_ether("1").unwrap()).await.unwrap();
+
+        // Lockin the request
+        ctx.prover_market.lockin_request(&request, &customer_sig, None).await.unwrap();
+        assert!(ctx.customer_market.is_locked_in(request_id).await.unwrap());
+        assert!(ctx.customer_market.get_status(request_id).await.unwrap() == ProofStatus::Locked);
+
+        // mock the fulfillment
+        let (root, set_verifier_seal, fulfillment, market_seal) =
+            mock_singleton(request_id, eip712_domain);
+
+        let fulfillments = vec![fulfillment];
+        // publish the committed root + fulfillments
+        ctx.prover_market
+            .submit_merkle_and_fulfill(root, set_verifier_seal, fulfillments.clone(), market_seal)
+            .await
+            .unwrap();
+
+        // retrieve journal and seal from the fulfilled request
+        let (journal, seal) =
+            ctx.customer_market.get_request_fulfillment(request_id).await.unwrap();
+
+        assert_eq!(journal, fulfillments[0].journal);
+        assert_eq!(seal, fulfillments[0].seal);
+    }
 }

crates/broker/src/config.rs

@@ -120,6 +120,11 @@ pub struct BatcherConfig {
     pub block_deadline_buffer_secs: u64,
     /// Timeout, in seconds for transaction confirmations
     pub txn_timeout: Option<u64>,
+    /// Use the single TXN submission that batchs submit_merkle / fulfill_batch into
+    /// A single transaction. Requires the `submitRootAndFulfillBatch` method
+    /// be present on the deployed contract
+    #[serde(default)]
+    pub single_txn_fulfill: bool,
 }
 
 impl Default for BatcherConfig {
@@ -130,6 +135,7 @@ impl Default for BatcherConfig {
             batch_max_fees: None,
             block_deadline_buffer_secs: 120,
             txn_timeout: None,
+            single_txn_fulfill: false,
         }
     }
 }
@@ -335,7 +341,8 @@ req_retry_count = 0
 batch_max_time = 300
 batch_size = 2
 block_deadline_buffer_secs = 120
-txn_timeout = 45"#;
+txn_timeout = 45
+single_txn_fulfill = true"#;
 
     const BAD_CONFIG: &str = r#"
 [market]
@@ -421,6 +428,7 @@ error = ?"#;
             assert_eq!(config.prover.status_poll_ms, 1000);
             assert!(config.prover.bonsai_r0_zkvm_ver.is_none());
             assert_eq!(config.batcher.txn_timeout, Some(45));
+            assert_eq!(config.batcher.single_txn_fulfill, true);
         }
         tracing::debug!("closing...");
     }