BM-1466: Ec2/claim digest

.vscode/settings.json

@@ -14,10 +14,10 @@
 	"rust-analyzer.linkedProjects": [
 		"./Cargo.toml",
 		"./crates/distributor/Cargo.toml",
-		// "./crates/guest/assessor/assessor-guest/Cargo.toml",
+		"./crates/guest/assessor/assessor-guest/Cargo.toml",
 		// "./crates/guest/util/echo/Cargo.toml",
 		// "./crates/guest/util/identity/Cargo.toml",
-		// "./examples/counter/Cargo.toml",
+		"./examples/counter/Cargo.toml",
 		// "./examples/smart-contract-requestor/Cargo.toml",
 		// "./examples/counter-with-callback/Cargo.toml"
 	],

contracts/deployment-test/Deploymnet.t.sol

@@ -22,7 +22,7 @@ import {Input, InputType} from "../src/types/Input.sol";
 import {Requirements} from "../src/types/Requirements.sol";
 import {Offer} from "../src/types/Offer.sol";
 import {ProofRequest} from "../src/types/ProofRequest.sol";
-import {Predicate, PredicateType} from "../src/types/Predicate.sol";
+import {PredicateLibrary} from "../src/types/Predicate.sol";
 import {RequestId, RequestIdLibrary} from "../src/types/RequestId.sol";
 import {RequestLock} from "../src/types/RequestLock.sol";
 
@@ -105,7 +105,10 @@ contract DeploymentTest is Test {
     function testRouterIsDeployed() external view {
         require(address(verifier) != address(0), "no verifier (router) address is set");
         require(keccak256(address(verifier).code) != keccak256(bytes("")), "verifier code is empty");
-        require(address(verifier) == address(BoundlessMarket(address(boundlessMarket)).VERIFIER()), "verifier address does not match boundless market");
+        require(
+            address(verifier) == address(BoundlessMarket(address(boundlessMarket)).VERIFIER()),
+            "verifier address does not match boundless market"
+        );
     }
 
     function testSetVerifierIsDeployed() external view {
@@ -191,9 +194,7 @@ contract DeploymentTest is Test {
         vm.expectEmit(true, true, true, false);
         emit IBoundlessMarket.ProofDelivered(request.id, address(testProver), result.fills[0]);
 
-        boundlessMarket.priceAndFulfill(
-            requests, clientSignatures, result.fills, result.assessorReceipt
-        );
+        boundlessMarket.priceAndFulfill(requests, clientSignatures, result.fills, result.assessorReceipt);
         Fulfillment memory fill = result.fills[0];
         assertTrue(boundlessMarket.requestIsFulfilled(fill.id), "Request should have fulfilled status");
     }
@@ -230,8 +231,7 @@ contract Client {
 
     function defaultRequirements() public pure returns (Requirements memory) {
         return Requirements({
-            imageId: bytes32(APP_IMAGE_ID),
-            predicate: Predicate({predicateType: PredicateType.PrefixMatch, data: hex"53797374"}),
+            predicate: PredicateLibrary.createPrefixMatchPredicate(bytes32(APP_IMAGE_ID), hex"53797374"),
             callback: Callback({gasLimit: 0, addr: address(0)}),
             selector: bytes4(0)
         });
@@ -257,4 +257,4 @@ contract Client {
         (uint8 v, bytes32 r, bytes32 s) = VM.sign(wallet, structDigest);
         return abi.encodePacked(r, s, v);
     }
-}
+}

contracts/snapshots/BoundlessMarketBasicTest.json

@@ -1,40 +1,41 @@
 {
   "ERC20 approve: required for depositStake": "45966",
-  "bytecode size implementation": "24381",
+  "bytecode size implementation": "23636",
   "bytecode size proxy": "89",
-  "deposit: first ever deposit": "50920",
-  "deposit: second deposit": "33820",
-  "depositStake: 1 HP (tops up market account)": "59400",
-  "depositStake: full (drains testProver account)": "49800",
-  "depositStakeWithPermit: 1 HP (tops up market account)": "72272",
-  "depositStakeWithPermit: full (drains testProver account)": "72262",
-  "fulfill: a batch of 8": "402078",
-  "fulfill: a locked request": "90511",
-  "fulfill: a locked request (locked via prover signature)": "90511",
-  "fulfill: a locked request with 10kB journal": "427539",
-  "fulfill: another prover fulfills without payment": "85473",
-  "fulfill: fulfilled by the locked prover for payment (request already fulfilled by another prover)": "80772",
-  "fulfillAndWithdraw: a batch of 8": "414256",
-  "fulfillAndWithdraw: a locked request": "102689",
-  "lockinRequest: base case": "146877",
-  "lockinRequest: with prover signature": "156522",
-  "priceAndFulfill: a single request": "108760",
-  "priceAndFulfill: a single request (smart contract signature)": "118938",
-  "priceAndFulfill: a single request (with selector)": "111059",
-  "priceAndFulfill: a single request that was not locked": "108760",
-  "priceAndFulfill: a single request that was not locked fulfilled by prover not in allow-list": "108760",
-  "priceAndFulfill: fulfill already fulfilled was locked request": "102475",
-  "slash: base case": "100967",
-  "slash: fulfilled request after lock deadline": "80532",
-  "submitRequest: with maxPrice ether": "51904",
-  "submitRequest: without ether": "45061",
-  "submitRootAndFulfill: a batch of 2 requests": "168676",
-  "submitRootAndFulfill: a locked request": "124555",
-  "submitRootAndFulfill: a locked request (locked via prover signature)": "124555",
-  "submitRootAndFulfillAndWithdraw: a locked request": "136476",
-  "submitRootAndPriceAndFulfill: a single request": "141098",
-  "submitRootAndPriceAndFulfill: a single request that was not locked": "141110",
-  "submitRootAndPriceAndFulfill: a single request that was not locked fulfilled by prover not in allow-list": "141110",
+  "deposit: first ever deposit": "50832",
+  "deposit: second deposit": "33732",
+  "depositStake: 1 HP (tops up market account)": "59312",
+  "depositStake: full (drains testProver account)": "49712",
+  "depositStakeWithPermit: 1 HP (tops up market account)": "72236",
+  "depositStakeWithPermit: full (drains testProver account)": "72227",
+  "fulfill (no journal): a batch of 8": "384582",
+  "fulfill: a batch of 8": "412815",
+  "fulfill: a locked request": "92176",
+  "fulfill: a locked request (locked via prover signature)": "92176",
+  "fulfill: a locked request with 10kB journal": "424790",
+  "fulfill: another prover fulfills without payment": "87139",
+  "fulfill: fulfilled by the locked prover for payment (request already fulfilled by another prover)": "81038",
+  "fulfillAndWithdraw: a batch of 8": "425191",
+  "fulfillAndWithdraw: a locked request": "104552",
+  "lockinRequest: base case": "146984",
+  "lockinRequest: with prover signature": "156626",
+  "priceAndFulfill: a single request": "109862",
+  "priceAndFulfill: a single request (smart contract signature)": "120052",
+  "priceAndFulfill: a single request (with selector)": "112163",
+  "priceAndFulfill: a single request that was not locked": "109862",
+  "priceAndFulfill: a single request that was not locked fulfilled by prover not in allow-list": "109862",
+  "priceAndFulfill: fulfill already fulfilled was locked request": "102177",
+  "slash: base case": "100923",
+  "slash: fulfilled request after lock deadline": "80488",
+  "submitRequest: with maxPrice ether": "52621",
+  "submitRequest: without ether": "45778",
+  "submitRootAndFulfill: a batch of 2 requests": "171017",
+  "submitRootAndFulfill: a locked request": "126585",
+  "submitRootAndFulfill: a locked request (locked via prover signature)": "126585",
+  "submitRootAndFulfillAndWithdraw: a locked request": "138301",
+  "submitRootAndPriceAndFulfill: a single request": "143070",
+  "submitRootAndPriceAndFulfill: a single request that was not locked": "143070",
+  "submitRootAndPriceAndFulfill: a single request that was not locked fulfilled by prover not in allow-list": "143070",
   "withdraw: 1 ether": "40314",
   "withdraw: full balance": "40326",
   "withdrawStake: 1 HP balance": "68743",

contracts/snapshots/BoundlessMarketBench.json

@@ -1,22 +1,22 @@
 {
-  "fulfill (with callback): batch of 001": "132142",
-  "fulfill (with callback): batch of 002": "218443",
-  "fulfill (with callback): batch of 004": "392147",
-  "fulfill (with callback): batch of 008": "739579",
-  "fulfill (with callback): batch of 016": "1272464",
-  "fulfill (with callback): batch of 032": "2373148",
-  "fulfill (with selector): batch of 001": "92745",
-  "fulfill (with selector): batch of 002": "139726",
-  "fulfill (with selector): batch of 004": "236258",
-  "fulfill (with selector): batch of 008": "420231",
-  "fulfill (with selector): batch of 016": "790425",
-  "fulfill (with selector): batch of 032": "1558877",
-  "fulfill: batch of 001": "90487",
-  "fulfill: batch of 002": "135232",
-  "fulfill: batch of 004": "227181",
-  "fulfill: batch of 008": "402117",
-  "fulfill: batch of 016": "754179",
-  "fulfill: batch of 032": "1485129",
-  "fulfill: batch of 064": "3014348",
-  "fulfill: batch of 128": "6255291"
+  "fulfill (with callback): batch of 001": "133867",
+  "fulfill (with callback): batch of 002": "221508",
+  "fulfill (with callback): batch of 004": "397945",
+  "fulfill (with callback): batch of 008": "750387",
+  "fulfill (with callback): batch of 016": "1292502",
+  "fulfill (with callback): batch of 032": "2409336",
+  "fulfill (with selector): batch of 001": "94414",
+  "fulfill (with selector): batch of 002": "142699",
+  "fulfill (with selector): batch of 004": "241820",
+  "fulfill (with selector): batch of 008": "430750",
+  "fulfill (with selector): batch of 016": "810306",
+  "fulfill (with selector): batch of 032": "1594177",
+  "fulfill: batch of 001": "92164",
+  "fulfill: batch of 002": "138207",
+  "fulfill: batch of 004": "232791",
+  "fulfill: batch of 008": "412665",
+  "fulfill: batch of 016": "773951",
+  "fulfill: batch of 032": "1520776",
+  "fulfill: batch of 064": "3070189",
+  "fulfill: batch of 128": "6308304"
 }

contracts/src/BoundlessMarket.sol

@@ -24,8 +24,10 @@ import {Account} from "./types/Account.sol";
 import {AssessorJournal} from "./types/AssessorJournal.sol";
 import {AssessorCallback} from "./types/AssessorCallback.sol";
 import {AssessorCommitment} from "./types/AssessorCommitment.sol";
+import {CallbackData} from "./types/CallbackData.sol";
 import {Fulfillment} from "./types/Fulfillment.sol";
 import {AssessorReceipt} from "./types/AssessorReceipt.sol";
+import {PredicateType} from "./types/Predicate.sol";
 import {ProofRequest} from "./types/ProofRequest.sol";
 import {LockRequest, LockRequestLibrary} from "./types/LockRequest.sol";
 import {RequestId} from "./types/RequestId.sol";
@@ -239,6 +241,7 @@ contract BoundlessMarket is
         }
         bytes32[] memory leaves = new bytes32[](fills.length);
         bool[] memory hasSelector = new bool[](fills.length);
+        PredicateType[] memory predicateTypes = new PredicateType[](fills.length);
 
         // Check the selector constraints.
         // NOTE: The assessor guest adds non-zero selector values to the list.
@@ -255,16 +258,16 @@ contract BoundlessMarket is
         // Verify the application receipts.
         for (uint256 i = 0; i < fills.length; i++) {
             Fulfillment calldata fill = fills[i];
+            predicateTypes[i] = fill.predicateType;
 
-            bytes32 claimDigest = ReceiptClaimLib.ok(fill.imageId, sha256(fill.journal)).digest();
-            leaves[i] = AssessorCommitment(i, fill.id, fill.requestDigest, claimDigest).eip712Digest();
+            leaves[i] = AssessorCommitment(i, fill.id, fill.requestDigest, fill.claimDigest).eip712Digest();
 
             // If the requestor did not specify a selector, we verify with DEFAULT_MAX_GAS_FOR_VERIFY gas limit.
             // This ensures that by default, client receive proofs that can be verified cheaply as part of their applications.
             if (!hasSelector[i]) {
-                VERIFIER.verifyIntegrity{gas: DEFAULT_MAX_GAS_FOR_VERIFY}(Receipt(fill.seal, claimDigest));
+                VERIFIER.verifyIntegrity{gas: DEFAULT_MAX_GAS_FOR_VERIFY}(Receipt(fill.seal, fill.claimDigest));
             } else {
-                VERIFIER.verifyIntegrity(Receipt(fill.seal, claimDigest));
+                VERIFIER.verifyIntegrity(Receipt(fill.seal, fill.claimDigest));
             }
         }
 
@@ -278,6 +281,7 @@ contract BoundlessMarket is
                     root: batchRoot,
                     callbacks: assessorReceipt.callbacks,
                     selectors: assessorReceipt.selectors,
+                    predicateTypes: predicateTypes,
                     prover: assessorReceipt.prover
                 })
             )
@@ -333,13 +337,31 @@ contract BoundlessMarket is
             }
 
             uint256 callbackIndexPlusOne = fillToCallbackIndexPlusOne[i];
-            if (callbackIndexPlusOne > 0) {
+            // We do not support callbacks for claim digest matches.
+            if ((fill.predicateType != PredicateType.ClaimDigestMatch) && (callbackIndexPlusOne > 0)) {
+                (bytes32 imageId, bytes calldata journal) = _decodeCallbackData(fill.callbackData);
+
                 AssessorCallback calldata callback = assessorReceipt.callbacks[callbackIndexPlusOne - 1];
-                _executeCallback(fill.id, callback.addr, callback.gasLimit, fill.imageId, fill.journal, fill.seal);
+                _executeCallback(fill.id, callback.addr, callback.gasLimit, imageId, journal, fill.seal);
             }
         }
     }
 
+    function _decodeCallbackData(bytes calldata data) internal pure returns (bytes32 imageId, bytes calldata journal) {
+        assembly {
+            // Extract imageId (first 32 bytes after length)
+            imageId := calldataload(add(data.offset, 0x20))
+
+            // Extract journal offset and create calldata slice
+            let journalOffset := calldataload(add(data.offset, 0x40))
+            let journalPtr := add(data.offset, add(0x20, journalOffset))
+            let journalLength := calldataload(journalPtr)
+
+            journal.offset := add(journalPtr, 0x20)
+            journal.length := journalLength
+        }
+    }
+
     /// @inheritdoc IBoundlessMarket
     function priceAndFulfillAndWithdraw(
         ProofRequest[] calldata requests,

contracts/src/types/AssessorJournal.sol

@@ -5,6 +5,7 @@
 pragma solidity ^0.8.20;
 
 import {AssessorCallback} from "./AssessorCallback.sol";
+import {PredicateType} from "./Predicate.sol";
 import {Selector} from "./Selector.sol";
 
 /// @title Assessor Journal Struct
@@ -17,6 +18,8 @@ struct AssessorJournal {
     /// @notice The (optional) selectors for the requests committed by the assessor.
     /// @dev This is used to verify the fulfillment of the request against its selector's seal.
     Selector[] selectors;
+    /// @notice The list of `PredicateType` for each request.
+    PredicateType[] predicateTypes;
     /// @notice Root of the Merkle tree committing to the set of proven claims.
     /// @dev In the case of a batch of size one, this may simply be the eip712Digest of the `AssessorCommitment`.
     bytes32 root;

contracts/src/types/CallbackData.sol

@@ -0,0 +1,19 @@
+// Copyright 2025 RISC Zero, Inc.
+//
+// Use of this source code is governed by the Business Source License
+// as found in the LICENSE-BSL file.
+pragma solidity ^0.8.24;
+
+using CallbackDataLibrary for CallbackData global;
+
+/// @title Callback Struct and Library
+/// @notice Represents a callback configuration for proof delivery
+struct CallbackData {
+    /// @notice Image ID of the guest that was verifiably executed to satisfy the request.
+    bytes32 imageId;
+    /// @notice Journal committed by the guest program execution.
+    /// @dev The journal is checked to satisfy the predicate specified on the request's requirements.
+    bytes journal;
+}
+
+library CallbackDataLibrary {}

contracts/src/types/Fulfillment.sol

@@ -5,6 +5,7 @@
 pragma solidity ^0.8.20;
 
 import {RequestId} from "./RequestId.sol";
+import {PredicateType} from "./Predicate.sol";
 
 using FulfillmentLibrary for Fulfillment global;
 
@@ -15,16 +16,14 @@ struct Fulfillment {
     RequestId id;
     /// @notice EIP-712 digest of request struct.
     bytes32 requestDigest;
-    /// @notice Image ID of the guest that was verifiably executed to satisfy the request.
-    /// @dev Must match the value in the request's requirements.
-    bytes32 imageId;
-    // TODO: Add a flag in the request to decide whether to post the journal. Note that
-    // if the journal and journal digest do not need to be delivered to the client, imageId will
-    // be replaced with claim digest, since it is captured in the requirements on the request,
-    // checked by the Assessor guest.
-    /// @notice Journal committed by the guest program execution.
-    /// @dev The journal is checked to satisfy the predicate specified on the request's requirements.
-    bytes journal;
+    /// @notice The `PredicateType` of the request that is being fulfilled.
+    /// @dev When the `PredicateType` is `ClaimDigestMatch`, the imageIdOrClaimDigest field is the claim digest,
+    /// and otherwise it is the image ID of the guest that was executed.
+    PredicateType predicateType;
+    /// @notice Claim Digest
+    bytes32 claimDigest;
+    /// @notice The callback data, if requested.
+    bytes callbackData;
     /// @notice Cryptographic proof for the validity of the execution results.
     /// @dev This will be sent to the `IRiscZeroVerifier` associated with this contract.
     bytes seal;