feat(offer): make Offer entity immutable and idempotent

The Offer entity was previously mutable with "latest offer hash wins"
semantics, which didn't match how the entity is actually used. For a
given agreementId, the RCA identifying fields (payer, dataService,
serviceProvider, deadline, nonce) are fixed by the id derivation, so
any duplicate OfferStored event for the same id carries the same
offerHash by construction. There is nothing meaningful to overwrite.

Switch the entity to @entity(immutable: true) and early-return from
handleOfferStored when an entity with the same id already exists.
Writing twice to an immutable entity would halt the subgraph, so the
guard is load-bearing against dipper crash-recovery re-submissions and
chain reorg re-emissions.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: MoonBoi9001

schema.graphql

@@ -74,13 +74,17 @@ type OfferStored @entity(immutable: true) {
   transactionHash: Bytes!
 }
 
-# Latest stored offer per agreementId, keyed by bytes16 agreement ID.
-# indexer-service queries this entity to verify an RCA offer exists on-chain
-# before accepting a DIPs proposal with an empty signature. The offer path
-# (`RecurringCollector.accept(rca, "")`) does not emit an event on cleanup,
-# so this entity is not updated after accept -- downstream consumers must
-# cross-reference IndexingAgreementAccepted if they need "still pending" semantics.
-type Offer @entity(immutable: false) {
+# First stored offer per agreementId, keyed by bytes16 agreement ID.
+# Dipper queries this entity as an idempotency gate -- avoids re-submitting
+# an offer after a crashed-mid-flight restart where the on-chain tx landed
+# but dipper lost track of it.
+#
+# Declared immutable because, for a given agreementId, the RCA identifying
+# fields (payer, dataService, serviceProvider, deadline, nonce) are fixed by
+# the id derivation, so any duplicate OfferStored event for the same id would
+# carry the same offerHash. The handler enforces this by returning early on
+# the second event instead of attempting to overwrite.
+type Offer @entity(immutable: true) {
   id: Bytes!
   payer: Bytes!
   offerType: Int!

src/recurring-collector.ts

@@ -14,13 +14,17 @@ export function handleOfferStored(event: OfferStoredEvent): void {
   log.transactionHash = event.transaction.hash
   log.save()
 
-  // Latest-offer entity keyed by agreementId (bytes16). Overwrites any prior
-  // offer for the same agreement -- the newest stored offer hash wins.
-  // indexer-service queries this entity by id to verify offer existence.
-  let offer = Offer.load(event.params.agreementId)
-  if (offer == null) {
-    offer = new Offer(event.params.agreementId)
+  // First-offer entity keyed by agreementId (bytes16). Immutable: if an
+  // entity already exists, a duplicate OfferStored event for the same
+  // agreement id (e.g. dipper crashed and re-submitted, or a chain reorg
+  // re-emitted) carries the same offerHash by construction and we return
+  // early. Writing to an immutable entity a second time is a graph-node
+  // error that would halt the subgraph, so the guard is load-bearing.
+  let existing = Offer.load(event.params.agreementId)
+  if (existing != null) {
+    return
   }
+  let offer = new Offer(event.params.agreementId)
   offer.payer = event.params.payer
   offer.offerType = event.params.offerType
   offer.offerHash = event.params.offerHash