diff --git a/docs/dips-issuance-merge/AUDIT-REVIEW.md b/docs/dips-issuance-merge/AUDIT-REVIEW.md
new file mode 100644
index 000000000..892f61254
--- /dev/null
+++ b/docs/dips-issuance-merge/AUDIT-REVIEW.md
@@ -0,0 +1,209 @@
+# Audit Review: dips-issuance-merge
+
+This document identifies all contract changes introduced by merging two independently audited branches and the post-merge fixup commits. It separates genuinely new code from relocated or mechanical changes.
+
+## Branch Topology
+
+```
+main
+ └── ma/indexing-payments-audited-reviewed (dips)
+      │   Commits: a7fb8758..0e469bee (18 commits)
+      │   Audit: TRST-* findings (all addressed)
+      │
+      ├── tooling/build/CI commits: 0de8ddb7..1ea8d5b3 (42 commits)
+      │   (Hardhat 3 upgrade, Solidity 0.8.33, interface centralization, lint, etc.)
+      │
+      ├── Merge commit: a11a5324 (issuance-audit → mde/dips-issuance-merge)
+      │   Parent 1: 1ea8d5b3 (dips + tooling)
+      │   Parent 2: 16dbd737 (tip of issuance-audit)
+      │
+      ├── Post-merge fixups: 3c1a2f11..c3f6f075 (7 commits)
+      │
+      ├── Second merge commit: (origin/issuance-audit → mde/dips-issuance-merge)
+      │   Parent 1: c3f6f075 (dips + tooling + first merge fixups)
+      │   Parent 2: aa082308 (tip of issuance-audit, 5 new audit-fix commits)
+      │   New commits: 16dbd737..aa082308
+      │     80f81756 docs: document minimumSubgraphSignal retroactive application issue
+      │     22954a48 docs: improve reward documentation accuracy (TRST-R-2)
+      │     affc8b46 fix: remove redundant subgraphAllocatedTokens check (TRST-R-3)
+      │     5e319051 refactor: rename NO_ALLOCATION to NO_ALLOCATED_TOKENS
+      │     aa082308 fix: reclaim pending rewards on stale allocation resize (TRST-R-1)
+      │
+      └── (current tip)
+```
+
+- **issuance-audit** branch: audited separately (rewards/issuance system)
+- **dips (indexing payments)** branch: audited as TRST-\* (RecurringCollector, IndexingAgreement, etc.)
+- **First merge commit**: combines both into one branch, resolving conflicts
+- **Post-merge commits**: lint, pragma, type extraction -- no logic changes
+- **Second merge commit**: brings in 5 audit-fix commits from issuance-audit (TRST-R-1/R-2/R-3 fixes, rename, docs)
+
+---
+
+## Section 1: Relocated Files (No Logic Changes)
+
+During the merge, interfaces were moved to the centralized `packages/interfaces/` package. Content is identical to the audited versions.
+
+### Interface Relocations
+
+| Old Path                                                                  | New Path                                                              |
+| ------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| `packages/horizon/contracts/interfaces/IRecurringCollector.sol`           | `packages/interfaces/contracts/horizon/IRecurringCollector.sol`       |
+| `packages/subgraph-service/contracts/interfaces/IDisputeManager.sol`      | `packages/interfaces/contracts/subgraph-service/IDisputeManager.sol`  |
+| `packages/subgraph-service/contracts/interfaces/ISubgraphService.sol`     | `packages/interfaces/contracts/subgraph-service/ISubgraphService.sol` |
+| `packages/horizon/contracts/data-service/interfaces/IDataServiceFees.sol` | `packages/interfaces/contracts/data-service/IDataServiceFees.sol`     |
+
+Notes:
+
+- **IRecurringCollector.sol** (480 lines): byte-for-byte identical to the audited version. New file (no pre-existing version in the issuance-audit branch).
+- **IDisputeManager.sol**: `IndexingFeeDispute` enum variant, `createIndexingFeeDisputeV1`, events, and errors added to the centralized interface file. All additions are audited code with only `IndexingAgreement.` → `IIndexingAgreement.` type reference changes.
+- **ISubgraphService.sol**: `setIndexingFeesCut`, `acceptIndexingAgreement`, `updateIndexingAgreement`, `cancelIndexingAgreement`, `cancelIndexingAgreementByPayer`, `getIndexingAgreement` added to the centralized interface file. Same `IndexingAgreement.` → `IIndexingAgreement.` type reference changes.
+- **IDataServiceFees.sol**: `StakeClaim` struct, events, and errors removed (moved to `StakeClaims` library). Only `releaseStake` function signature remains.
+
+### Pragma-Only Changes
+
+These files had conflicts only because both branches changed the pragma. Resolved to `0.8.27 || 0.8.33`. No other changes.
+
+| File                                                                          |
+| ----------------------------------------------------------------------------- |
+| `packages/horizon/contracts/data-service/extensions/DataServicePausable.sol`  |
+| `packages/horizon/contracts/data-service/extensions/DataServiceRescuable.sol` |
+| `packages/horizon/contracts/libraries/Denominations.sol`                      |
+
+### Import Path + Refactor (Non-Overlapping)
+
+These files had changes from both parents but they did not overlap. No merge-specific code was written.
+
+| File                         | From indexing-payments                             | From issuance-audit                                                          |
+| ---------------------------- | -------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `DataServiceFees.sol`        | Import paths to `@graphprotocol/interfaces`        | Extracted private helpers to `StakeClaims` library                           |
+| `DataServiceFeesStorage.sol` | Import `StakeClaims` instead of `IDataServiceFees` | `LinkedList.List` → `ILinkedList.List`                                       |
+| `ProvisionManager.sol`       | Import paths, forge-lint comments                  | `onlyValidProvision` → `_requireValidProvision()`, extracted `_requireLTE()` |
+| `DisputeManager.sol`         | Added `IIndexingAgreement` import                  | Import path changes                                                          |
+| `Directory.sol`              | Added `IRecurringCollector` import                 | Import paths to `@graphprotocol/interfaces`                                  |
+| `SubgraphServiceStorage.sol` | Added `indexingFeesCut` storage variable           | Inherited `ISubgraphService`, added `override` to getters                    |
+
+---
+
+## Section 2: Files with Genuinely New Lines
+
+These files contain lines that did not exist in either audited parent. **Total: ~20 lines, zero business logic.**
+
+### AllocationHandler.sol (186 `++` lines from first merge, ~12 genuinely new)
+
+This library was introduced in the indexing-payments branch. During the merge, reward logic from `AllocationManager.sol` was relocated into this library structure.
+
+**Relocated from `AllocationManager.sol` (faithful port, ~179 lines):**
+
+- `POIPresented` event with `condition` field
+- `RewardsCondition`-based branching in `presentPOI` (STALE_POI, ZERO_POI, ALLOCATION_TOO_YOUNG, SUBGRAPH_DENIED)
+- Three reward paths: CLAIMED (takeRewards), RECLAIMED (reclaimRewards), DEFERRED (early return)
+- `_distributeIndexingRewards()` private helper (delegator/indexer split)
+- `_closeAllocation` calling `reclaimRewards(CLOSE_ALLOCATION, ...)` before closing
+- All adapted from contract-style (`_graphStaking()`, `address(this)`) to library-style (`params.graphStaking`, `params.dataService`)
+
+**Genuinely new lines (~12):**
+
+- `// Scoped for stack management` (2 comments)
+- Condensed natspec on `_closeAllocation` and `_distributeIndexingRewards`
+- `return (0, false)` instead of `return 0` (tuple adaptation for force-close return signature)
+- `emit AllocationHandler.POIPresented(...)` instead of `emit POIPresented(...)` (library-qualified emit)
+- `uint256 _maxPOIStaleness` parameter added to `resizeAllocation()` (second merge: port of stale reclaim from TRST-R-1)
+- `@param _maxPOIStaleness` natspec line
+- `// forge-lint: disable-next-item(mixed-case-variable)` comment on `resizeAllocation`
+
+### IIndexingAgreement.sol (39 lines, ~5 genuinely new)
+
+New interface file extracted from `IndexingAgreement.sol` library during the merge. Types (`IndexingAgreementVersion`, `State`, `AgreementWrapper`) are identical to the audited library.
+
+**Genuinely new:** interface declaration boilerplate and natspec header (~5 lines).
+
+### SubgraphService.sol (2 `++` lines, 1 genuinely new)
+
+- Import path adjustment (relocated)
+- `(uint256 paymentCollected, bool allocationForceClosed) = _presentPoi(` — combines tuple destructuring with the renamed function
+
+### AllocationManager.sol (3 `++` lines from first merge, ~3 genuinely new)
+
+- `See {AllocationHandler-presentPOI} for detailed reward path documentation.` (natspec cross-reference)
+- `Emits a {POIPresented} event.` (natspec note)
+- `maxPOIStaleness` now passed as argument to `AllocationHandler.resizeAllocation()` (second merge: enables stale reclaim port)
+
+---
+
+## Section 3: New Contract Files
+
+These files are entirely new to the branch (not in main). They come from one of the two audited branches.
+
+### From indexing-payments branch (TRST-\* audited)
+
+| File                                                                            | Lines | Description                                                 |
+| ------------------------------------------------------------------------------- | ----- | ----------------------------------------------------------- |
+| `packages/horizon/contracts/payments/collectors/RecurringCollector.sol`         | 643   | Recurring payment collector contract                        |
+| `packages/horizon/contracts/data-service/libraries/StakeClaims.sol`             | 213   | Stake claim management library                              |
+| `packages/subgraph-service/contracts/libraries/AllocationHandler.sol`           | 600   | Allocation logic library (extracted from AllocationManager) |
+| `packages/subgraph-service/contracts/libraries/IndexingAgreement.sol`           | 803   | Indexing agreement lifecycle library                        |
+| `packages/subgraph-service/contracts/libraries/IndexingAgreementDecoder.sol`    | 101   | ABI decoder for indexing agreement metadata                 |
+| `packages/subgraph-service/contracts/libraries/IndexingAgreementDecoderRaw.sol` | 65    | Raw calldata decoder for indexing agreements                |
+
+### From issuance-audit branch (audited)
+
+| File                                                                             | Lines | Description                            |
+| -------------------------------------------------------------------------------- | ----- | -------------------------------------- |
+| `packages/interfaces/contracts/contracts/rewards/RewardsCondition.sol`           | 54    | Rewards condition enum/types           |
+| `packages/interfaces/contracts/contracts/rewards/IRewardsManagerDeprecated.sol`  | 40    | Deprecated rewards manager interface   |
+| `packages/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol` | 165   | Extracted allocation manager interface |
+
+### Created during merge
+
+| File                                                                             | Lines | Description                                          |
+| -------------------------------------------------------------------------------- | ----- | ---------------------------------------------------- |
+| `packages/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol` | 39    | Types extracted from `IndexingAgreement.sol` library |
+
+---
+
+## Section 4: Post-Merge Commits
+
+7 commits after the merge (3c1a2f11..c3f6f075). All mechanical — zero behavioral changes.
+
+| Commit     | Description                                                                               | Non-test .sol files                                                                                                              | Risk                             |
+| ---------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- |
+| `3c1a2f11` | Pragma widening to `0.8.27 \|\| 0.8.33`, import path centralization                       | StakeClaims.sol, imports.sol, RecurringCollector.sol                                                                             | Mechanical                       |
+| `26c6c445` | Extract types from `IndexingAgreement` lib to `IIndexingAgreement` interface              | IndexingAgreement.sol, DisputeManager.sol, SubgraphService.sol, AllocationHandler.sol, AllocationManager.sol                     | Structural (type move, no logic) |
+| `9742dd80` | Rename test constants to UPPER_SNAKE_CASE                                                 | 0 (test-only)                                                                                                                    | N/A                              |
+| `fa57fbc0` | Update expected errors and assertions in tests                                            | 0 (test-only)                                                                                                                    | N/A                              |
+| `89c70100` | Add `--ir-minimum` flag to forge coverage                                                 | 0 (config-only)                                                                                                                  | N/A                              |
+| `4450e9c2` | Add forge-lint disable comments for RCA/POI acronyms                                      | SubgraphService.sol, AllocationHandler.sol, IndexingAgreement.sol, IndexingAgreementDecoder.sol, IndexingAgreementDecoderRaw.sol | Mechanical (comments only)       |
+| `c3f6f075` | Solhint suppression, natspec `@dev`→`@notice`, `memory`→`calldata` on `getCollectionInfo` | RecurringCollector.sol, IRecurringCollector.sol, IDisputeManager.sol, ISubgraphService.sol                                       | Mechanical                       |
+
+The only non-comment code change across all 7 commits: `getCollectionInfo` parameter changed from `AgreementData memory` to `AgreementData calldata` (gas optimization, ABI-compatible).
+
+### Second Merge: origin/issuance-audit (5 audit-fix commits)
+
+Conflict resolution:
+
+| File                    | Resolution                                                                                                                                                                                                |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `AllocationManager.sol` | Resolved to the thin wrapper version. The stale reclaim logic (TRST-R-1) was placed in `AllocationHandler.resizeAllocation()` instead of inline, passing `maxPOIStaleness` as a new parameter.            |
+| `resize.t.sol`          | Resolved with `AllocationHandler` import for error selectors and added `IAllocation` import. Two new test functions (`StaleAllocation_ReclaimsPending`, `NotStale_PreservesPending`) auto-merged cleanly. |
+
+Auto-merged files (verified correct):
+
+| File                     | Description                                                                                                                                                                                                                  |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MockRewardsManager.sol` | `calcRewards` now returns `(_accRewardsPerAllocatedToken * _tokens) / FIXED_POINT_SCALING_FACTOR`. `reclaimRewards` destructures all 6 return values from `getAllocationData` and computes `accRewardsPending + newRewards`. |
+| `SubgraphService.t.sol`  | Pending rewards assertion updated to include `beforeAllocation.accRewardsPending`.                                                                                                                                           |
+
+---
+
+## Summary
+
+| Category                                     | Files                                   | New Logic Lines                                  |
+| -------------------------------------------- | --------------------------------------- | ------------------------------------------------ |
+| Relocated interfaces (path moves)            | 4                                       | 0                                                |
+| Pragma-only conflicts                        | 3                                       | 0                                                |
+| Non-overlapping import/refactor merges       | 6                                       | 0                                                |
+| Genuinely new lines (first merge resolution) | 4                                       | ~15 (natspec, comments, boilerplate)             |
+| Post-merge commits                           | 13 non-test .sol files across 7 commits | 0 (1 `memory`→`calldata` change)                 |
+| Second merge (stale reclaim port)            | 2                                       | ~5 (param plumbing, natspec, forge-lint comment) |
+| **Total new business logic**                 |                                         | **0**                                            |
diff --git a/packages/contracts-test/tests/unit/disputes/poi.test.ts b/packages/contracts-test/tests/unit/disputes/poi.test.ts
index b465f5986..b391dd0d4 100644
--- a/packages/contracts-test/tests/unit/disputes/poi.test.ts
+++ b/packages/contracts-test/tests/unit/disputes/poi.test.ts
@@ -1,4 +1,4 @@
-import { DisputeManager } from '@graphprotocol/contracts'
+import { DisputeManager, IRewardsManager } from '@graphprotocol/contracts'
 import { EpochManager } from '@graphprotocol/contracts'
 import { GraphToken } from '@graphprotocol/contracts'
 import { IStaking } from '@graphprotocol/contracts'
@@ -30,6 +30,7 @@ describe('DisputeManager:POI', () => {
   let epochManager: EpochManager
   let grt: GraphToken
   let staking: IStaking
+  let rewardsManager: IRewardsManager
 
   // Derive some channel keys for each indexer used to sign attestations
   const indexerChannelKey = deriveChannelKey()
@@ -92,10 +93,15 @@ describe('DisputeManager:POI', () => {
     epochManager = contracts.EpochManager as EpochManager
     grt = contracts.GraphToken as GraphToken
     staking = contracts.Staking as IStaking
+    rewardsManager = contracts.RewardsManager as IRewardsManager
 
     // Give some funds to the fisherman
     await grt.connect(governor).mint(fisherman.address, fishermanTokens)
     await grt.connect(fisherman).approve(disputeManager.address, fishermanTokens)
+
+    // HACK: we set the staking contract as the subgraph service to make tests pass.
+    // This is due to the test suite being outdated.
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/disputes/query.test.ts b/packages/contracts-test/tests/unit/disputes/query.test.ts
index 73238b4e0..e411bd028 100644
--- a/packages/contracts-test/tests/unit/disputes/query.test.ts
+++ b/packages/contracts-test/tests/unit/disputes/query.test.ts
@@ -1,5 +1,5 @@
 import { createAttestation, Receipt } from '@graphprotocol/common-ts'
-import { DisputeManager } from '@graphprotocol/contracts'
+import { DisputeManager, IRewardsManager } from '@graphprotocol/contracts'
 import { EpochManager } from '@graphprotocol/contracts'
 import { GraphToken } from '@graphprotocol/contracts'
 import { IStaking } from '@graphprotocol/contracts'
@@ -35,6 +35,7 @@ describe('DisputeManager:Query', () => {
   let epochManager: EpochManager
   let grt: GraphToken
   let staking: IStaking
+  let rewardsManager: IRewardsManager
 
   // Derive some channel keys for each indexer used to sign attestations
   const indexer1ChannelKey = deriveChannelKey()
@@ -121,6 +122,7 @@ describe('DisputeManager:Query', () => {
     epochManager = contracts.EpochManager as EpochManager
     grt = contracts.GraphToken as GraphToken
     staking = contracts.Staking as IStaking
+    rewardsManager = contracts.RewardsManager as IRewardsManager
 
     // Give some funds to the fisherman
     for (const dst of [fisherman, fisherman2]) {
@@ -139,6 +141,10 @@ describe('DisputeManager:Query', () => {
       indexerAddress: indexer.address,
       receipt,
     }
+
+    // HACK: we set the staking contract as the subgraph service to make tests pass.
+    // This is due to the test suite being outdated.
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/l2/l2Curation.test.ts b/packages/contracts-test/tests/unit/l2/l2Curation.test.ts
index 6ee8a5cd3..a680ec28c 100644
--- a/packages/contracts-test/tests/unit/l2/l2Curation.test.ts
+++ b/packages/contracts-test/tests/unit/l2/l2Curation.test.ts
@@ -154,7 +154,7 @@ describe('L2Curation', () => {
   let me: SignerWithAddress
   let governor: SignerWithAddress
   let curator: SignerWithAddress
-  let stakingMock: SignerWithAddress
+  let subgraphServiceMock: SignerWithAddress
   let gnsImpersonator: Signer
 
   let fixture: NetworkFixture
@@ -310,8 +310,8 @@ describe('L2Curation', () => {
     const beforeTotalBalance = await grt.balanceOf(curation.address)
 
     // Source of tokens must be the staking for this to work
-    await grt.connect(stakingMock).transfer(curation.address, tokensToCollect)
-    const tx = curation.connect(stakingMock).collect(subgraphDeploymentID, tokensToCollect)
+    await grt.connect(subgraphServiceMock).transfer(curation.address, tokensToCollect)
+    const tx = curation.connect(subgraphServiceMock).collect(subgraphDeploymentID, tokensToCollect)
     await expect(tx).emit(curation, 'Collected').withArgs(subgraphDeploymentID, tokensToCollect)
 
     // After state
@@ -325,7 +325,7 @@ describe('L2Curation', () => {
 
   before(async function () {
     // Use stakingMock so we can call collect
-    ;[me, curator, stakingMock] = await graph.getTestAccounts()
+    ;[me, curator, subgraphServiceMock] = await graph.getTestAccounts()
     ;({ governor } = await graph.getNamedAccounts())
     fixture = new NetworkFixture(graph.provider)
     contracts = await fixture.load(governor, true)
@@ -343,8 +343,11 @@ describe('L2Curation', () => {
     await grt.connect(gnsImpersonator).approve(curation.address, curatorTokens)
 
     // Give some funds to the staking contract and approve the curation contract
-    await grt.connect(governor).mint(stakingMock.address, tokensToCollect)
-    await grt.connect(stakingMock).approve(curation.address, tokensToCollect)
+    await grt.connect(governor).mint(subgraphServiceMock.address, tokensToCollect)
+    await grt.connect(subgraphServiceMock).approve(curation.address, tokensToCollect)
+
+    // Set the subgraph service
+    await curation.connect(governor).setSubgraphService(subgraphServiceMock.address)
   })
 
   beforeEach(async function () {
@@ -514,10 +517,10 @@ describe('L2Curation', () => {
     context('> not curated', function () {
       it('reject collect tokens distributed to the curation pool', async function () {
         // Source of tokens must be the staking for this to work
-        await controller.connect(governor).setContractProxy(utils.id('Staking'), stakingMock.address)
+        await controller.connect(governor).setContractProxy(utils.id('Staking'), subgraphServiceMock.address)
         await curation.connect(governor).syncAllContracts() // call sync because we change the proxy for staking
 
-        const tx = curation.connect(stakingMock).collect(subgraphDeploymentID, tokensToCollect)
+        const tx = curation.connect(subgraphServiceMock).collect(subgraphDeploymentID, tokensToCollect)
         await expect(tx).revertedWith('Subgraph deployment must be curated to collect fees')
       })
     })
@@ -529,11 +532,11 @@ describe('L2Curation', () => {
 
       it('reject collect tokens distributed from invalid address', async function () {
         const tx = curation.connect(me).collect(subgraphDeploymentID, tokensToCollect)
-        await expect(tx).revertedWith('Caller must be the subgraph service or staking contract')
+        await expect(tx).revertedWith('Caller must be the subgraph service')
       })
 
       it('should collect tokens distributed to the curation pool', async function () {
-        await controller.connect(governor).setContractProxy(utils.id('Staking'), stakingMock.address)
+        await controller.connect(governor).setContractProxy(utils.id('Staking'), subgraphServiceMock.address)
         await curation.connect(governor).syncAllContracts() // call sync because we change the proxy for staking
 
         await shouldCollect(toGRT('1'))
@@ -544,7 +547,7 @@ describe('L2Curation', () => {
       })
 
       it('should collect tokens and then unsignal all', async function () {
-        await controller.connect(governor).setContractProxy(utils.id('Staking'), stakingMock.address)
+        await controller.connect(governor).setContractProxy(utils.id('Staking'), subgraphServiceMock.address)
         await curation.connect(governor).syncAllContracts() // call sync because we change the proxy for staking
 
         // Collect increase the pool reserves
@@ -556,7 +559,7 @@ describe('L2Curation', () => {
       })
 
       it('should collect tokens and then unsignal multiple times', async function () {
-        await controller.connect(governor).setContractProxy(utils.id('Staking'), stakingMock.address)
+        await controller.connect(governor).setContractProxy(utils.id('Staking'), subgraphServiceMock.address)
         await curation.connect(governor).syncAllContracts() // call sync because we change the proxy for staking
 
         // Collect increase the pool reserves
diff --git a/packages/contracts-test/tests/unit/l2/l2GNS.test.ts b/packages/contracts-test/tests/unit/l2/l2GNS.test.ts
index 5b8f1d028..0fd691939 100644
--- a/packages/contracts-test/tests/unit/l2/l2GNS.test.ts
+++ b/packages/contracts-test/tests/unit/l2/l2GNS.test.ts
@@ -2,12 +2,10 @@ import { L2GNS } from '@graphprotocol/contracts'
 import { L2GraphTokenGateway } from '@graphprotocol/contracts'
 import { L2Curation } from '@graphprotocol/contracts'
 import { GraphToken } from '@graphprotocol/contracts'
-import { IL2Staking } from '@graphprotocol/contracts'
 import { L1GNS, L1GraphTokenGateway } from '@graphprotocol/contracts'
 import {
   buildSubgraph,
   buildSubgraphId,
-  deriveChannelKey,
   GraphNetworkContracts,
   helpers,
   PublishSubgraph,
@@ -44,7 +42,6 @@ interface L1SubgraphParams {
 describe('L2GNS', () => {
   const graph = hre.graph()
   let me: SignerWithAddress
-  let attacker: SignerWithAddress
   let other: SignerWithAddress
   let governor: SignerWithAddress
   let fixture: NetworkFixture
@@ -58,7 +55,6 @@ describe('L2GNS', () => {
   let gns: L2GNS
   let curation: L2Curation
   let grt: GraphToken
-  let staking: IL2Staking
 
   let newSubgraph0: PublishSubgraph
   let newSubgraph1: PublishSubgraph
@@ -109,7 +105,7 @@ describe('L2GNS', () => {
 
   before(async function () {
     newSubgraph0 = buildSubgraph()
-    ;[me, attacker, other] = await graph.getTestAccounts()
+    ;[me, other] = await graph.getTestAccounts()
     ;({ governor } = await graph.getNamedAccounts())
 
     fixture = new NetworkFixture(graph.provider)
@@ -118,7 +114,6 @@ describe('L2GNS', () => {
     fixtureContracts = await fixture.load(governor, true)
     l2GraphTokenGateway = fixtureContracts.L2GraphTokenGateway as L2GraphTokenGateway
     gns = fixtureContracts.L2GNS as L2GNS
-    staking = fixtureContracts.L2Staking as unknown as IL2Staking
     curation = fixtureContracts.L2Curation as L2Curation
     grt = fixtureContracts.GraphToken as GraphToken
 
@@ -354,61 +349,6 @@ describe('L2GNS', () => {
         .emit(gns, 'SignalMinted')
         .withArgs(l2SubgraphId, me.address, expectedNSignal, expectedSignal, curatedTokens)
     })
-    it('protects the owner against a rounding attack', async function () {
-      const { l1SubgraphId, curatedTokens, subgraphMetadata, versionMetadata } = await defaultL1SubgraphParams()
-      const collectTokens = curatedTokens.mul(20)
-
-      await staking.connect(governor).setCurationPercentage(100000)
-
-      // Set up an indexer account with some stake
-      await grt.connect(governor).mint(attacker.address, toGRT('1000000'))
-      // Curate 1 wei GRT by minting 1 GRT and burning most of it
-      await grt.connect(attacker).approve(curation.address, toBN(1))
-      await curation.connect(attacker).mint(newSubgraph0.subgraphDeploymentID, toBN(1), 0)
-
-      // Check this actually gave us 1 wei signal
-      expect(await curation.getCurationPoolTokens(newSubgraph0.subgraphDeploymentID)).eq(1)
-      await grt.connect(attacker).approve(staking.address, toGRT('1000000'))
-      await staking.connect(attacker).stake(toGRT('100000'))
-      const channelKey = deriveChannelKey()
-      // Allocate to the same deployment ID
-      await staking
-        .connect(attacker)
-        .allocateFrom(
-          attacker.address,
-          newSubgraph0.subgraphDeploymentID,
-          toGRT('100000'),
-          channelKey.address,
-          randomHexBytes(32),
-          await channelKey.generateProof(attacker.address),
-        )
-      // Spoof some query fees, 10% of which will go to the Curation pool
-      await staking.connect(attacker).collect(collectTokens, channelKey.address)
-      // The curation pool now has 1 wei shares and a lot of tokens, so the rounding attack is prepared
-      // But L2GNS will protect the owner by sending the tokens
-      const callhookData = defaultAbiCoder.encode(['uint8', 'uint256', 'address'], [toBN(0), l1SubgraphId, me.address])
-      await gatewayFinalizeTransfer(l1GNSMock.address, gns.address, curatedTokens, callhookData)
-
-      const l2SubgraphId = await gns.getAliasedL2SubgraphID(l1SubgraphId)
-      const tx = gns
-        .connect(me)
-        .finishSubgraphTransferFromL1(
-          l2SubgraphId,
-          newSubgraph0.subgraphDeploymentID,
-          subgraphMetadata,
-          versionMetadata,
-        )
-      await expect(tx)
-        .emit(gns, 'SubgraphPublished')
-        .withArgs(l2SubgraphId, newSubgraph0.subgraphDeploymentID, DEFAULT_RESERVE_RATIO)
-      await expect(tx).emit(gns, 'SubgraphMetadataUpdated').withArgs(l2SubgraphId, subgraphMetadata)
-      await expect(tx).emit(gns, 'CuratorBalanceReturnedToBeneficiary')
-      await expect(tx).emit(gns, 'SubgraphUpgraded').withArgs(l2SubgraphId, 0, 0, newSubgraph0.subgraphDeploymentID)
-      await expect(tx)
-        .emit(gns, 'SubgraphVersionUpdated')
-        .withArgs(l2SubgraphId, newSubgraph0.subgraphDeploymentID, versionMetadata)
-      await expect(tx).emit(gns, 'SubgraphL2TransferFinalized').withArgs(l2SubgraphId)
-    })
     it('cannot be called by someone other than the subgraph owner', async function () {
       const { l1SubgraphId, curatedTokens, subgraphMetadata, versionMetadata } = await defaultL1SubgraphParams()
       const callhookData = defaultAbiCoder.encode(['uint8', 'uint256', 'address'], [toBN(0), l1SubgraphId, me.address])
@@ -654,50 +594,6 @@ describe('L2GNS', () => {
       expect(gnsBalanceAfter).eq(gnsBalanceBefore)
     })
 
-    it('protects the curator against a rounding attack', async function () {
-      // Transfer a subgraph from L1 with only 1 wei GRT of curated signal
-      const { l1SubgraphId, subgraphMetadata, versionMetadata } = await defaultL1SubgraphParams()
-      const curatedTokens = toBN('1')
-      await transferMockSubgraphFromL1(l1SubgraphId, curatedTokens, subgraphMetadata, versionMetadata)
-      // Prepare the rounding attack by setting up an indexer and collecting a lot of query fees
-      const curatorTokens = toGRT('10000')
-      const collectTokens = curatorTokens.mul(20)
-      await staking.connect(governor).setCurationPercentage(100000)
-      // Set up an indexer account with some stake
-      await grt.connect(governor).mint(attacker.address, toGRT('1000000'))
-
-      await grt.connect(attacker).approve(staking.address, toGRT('1000000'))
-      await staking.connect(attacker).stake(toGRT('100000'))
-      const channelKey = deriveChannelKey()
-      // Allocate to the same deployment ID
-      await staking
-        .connect(attacker)
-        .allocateFrom(
-          attacker.address,
-          newSubgraph0.subgraphDeploymentID,
-          toGRT('100000'),
-          channelKey.address,
-          randomHexBytes(32),
-          await channelKey.generateProof(attacker.address),
-        )
-      // Spoof some query fees, 10% of which will go to the Curation pool
-      await staking.connect(attacker).collect(collectTokens, channelKey.address)
-
-      const callhookData = defaultAbiCoder.encode(['uint8', 'uint256', 'address'], [toBN(1), l1SubgraphId, me.address])
-      const curatorTokensBefore = await grt.balanceOf(me.address)
-      const gnsBalanceBefore = await grt.balanceOf(gns.address)
-      const tx = gatewayFinalizeTransfer(l1GNSMock.address, gns.address, curatorTokens, callhookData)
-      await expect(tx)
-        .emit(gns, 'CuratorBalanceReturnedToBeneficiary')
-        .withArgs(l1SubgraphId, me.address, curatorTokens)
-      const curatorTokensAfter = await grt.balanceOf(me.address)
-      expect(curatorTokensAfter).eq(curatorTokensBefore.add(curatorTokens))
-      const gnsBalanceAfter = await grt.balanceOf(gns.address)
-      // gatewayFinalizeTransfer will mint the tokens that are sent to the curator,
-      // so the GNS balance should be the same
-      expect(gnsBalanceAfter).eq(gnsBalanceBefore)
-    })
-
     it('if a subgraph was deprecated after transfer, it returns the tokens to the beneficiary', async function () {
       const l1GNSMockL2Alias = await helpers.getL2SignerFromL1(l1GNSMock.address)
       // Eth for gas:
diff --git a/packages/contracts-test/tests/unit/l2/l2Staking.test.ts b/packages/contracts-test/tests/unit/l2/l2Staking.test.ts
index 39dc75e7a..cf22eaba0 100644
--- a/packages/contracts-test/tests/unit/l2/l2Staking.test.ts
+++ b/packages/contracts-test/tests/unit/l2/l2Staking.test.ts
@@ -1,4 +1,4 @@
-import { IL2Staking } from '@graphprotocol/contracts'
+import { IL2Staking, IRewardsManager } from '@graphprotocol/contracts'
 import { L2GraphTokenGateway } from '@graphprotocol/contracts'
 import { GraphToken } from '@graphprotocol/contracts'
 import { EpochManager, L1GNS, L1GraphTokenGateway, L1Staking } from '@graphprotocol/contracts'
@@ -35,6 +35,7 @@ describe('L2Staking', () => {
   let l2GraphTokenGateway: L2GraphTokenGateway
   let staking: IL2Staking
   let grt: GraphToken
+  let rewardsManager: IRewardsManager
 
   const tokens10k = toGRT('10000')
   const tokens100k = toGRT('100000')
@@ -88,6 +89,7 @@ describe('L2Staking', () => {
     l1StakingMock = l1MockContracts.L1Staking as L1Staking
     l1GNSMock = l1MockContracts.L1GNS as L1GNS
     l1GRTGatewayMock = l1MockContracts.L1GraphTokenGateway as L1GraphTokenGateway
+    rewardsManager = fixtureContracts.RewardsManager as IRewardsManager
 
     // Deploy L2 arbitrum bridge
     await fixture.loadL2ArbitrumBridge(governor)
@@ -99,6 +101,10 @@ describe('L2Staking', () => {
     await grt.connect(me).approve(staking.address, tokens1m)
     await grt.connect(governor).mint(other.address, tokens1m)
     await grt.connect(other).approve(staking.address, tokens1m)
+
+    // HACK: we set the staking contract as the subgraph service to make tests pass.
+    // This is due to the test suite being outdated.
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/rewards/rewards-calculations.test.ts b/packages/contracts-test/tests/unit/rewards/rewards-calculations.test.ts
index e07717805..168166745 100644
--- a/packages/contracts-test/tests/unit/rewards/rewards-calculations.test.ts
+++ b/packages/contracts-test/tests/unit/rewards/rewards-calculations.test.ts
@@ -146,6 +146,9 @@ describe('Rewards - Calculations', () => {
       await grt.connect(wallet).approve(staking.address, toGRT('1000000'))
       await grt.connect(wallet).approve(curation.address, toGRT('1000000'))
     }
+
+    // Set the staking contract as the subgraph service so it can call takeRewards
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/rewards/rewards-distribution.test.ts b/packages/contracts-test/tests/unit/rewards/rewards-distribution.test.ts
index d4a55c1b9..e34ace2fd 100644
--- a/packages/contracts-test/tests/unit/rewards/rewards-distribution.test.ts
+++ b/packages/contracts-test/tests/unit/rewards/rewards-distribution.test.ts
@@ -85,6 +85,9 @@ describe('Rewards - Distribution', () => {
       await grt.connect(wallet).approve(staking.address, toGRT('1000000'))
       await grt.connect(wallet).approve(curation.address, toGRT('1000000'))
     }
+
+    // Set the staking contract as the subgraph service so it can call takeRewards
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/rewards/rewards-eligibility-oracle.test.ts b/packages/contracts-test/tests/unit/rewards/rewards-eligibility-oracle.test.ts
index ee60c3dd2..f26d5dded 100644
--- a/packages/contracts-test/tests/unit/rewards/rewards-eligibility-oracle.test.ts
+++ b/packages/contracts-test/tests/unit/rewards/rewards-eligibility-oracle.test.ts
@@ -97,6 +97,9 @@ describe('Rewards - Eligibility Oracle', () => {
       await grt.connect(wallet).approve(staking.address, toGRT('1000000'))
       await grt.connect(wallet).approve(curation.address, toGRT('1000000'))
     }
+
+    // Set the staking contract as the subgraph service so it can call takeRewards
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/rewards/rewards-reclaim.test.ts b/packages/contracts-test/tests/unit/rewards/rewards-reclaim.test.ts
index ece4b213d..241da881f 100644
--- a/packages/contracts-test/tests/unit/rewards/rewards-reclaim.test.ts
+++ b/packages/contracts-test/tests/unit/rewards/rewards-reclaim.test.ts
@@ -109,6 +109,9 @@ describe('Rewards - Reclaim Addresses', () => {
       await grt.connect(wallet).approve(staking.address, toGRT('1000000'))
       await grt.connect(wallet).approve(curation.address, toGRT('1000000'))
     }
+
+    // Set the staking contract as the subgraph service so it can call takeRewards
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/rewards/rewards-signal-allocation-update.test.ts b/packages/contracts-test/tests/unit/rewards/rewards-signal-allocation-update.test.ts
index accf1ea60..62097acbb 100644
--- a/packages/contracts-test/tests/unit/rewards/rewards-signal-allocation-update.test.ts
+++ b/packages/contracts-test/tests/unit/rewards/rewards-signal-allocation-update.test.ts
@@ -58,6 +58,9 @@ describe('Rewards: Signal and Allocation Update Accounting', () => {
     curation = contracts.Curation as Curation
     staking = contracts.Staking as IStaking
     rewardsManager = contracts.RewardsManager as RewardsManager
+
+    // Set the staking contract as the subgraph service so it can call takeRewards
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/rewards/rewards.test.ts b/packages/contracts-test/tests/unit/rewards/rewards.test.ts
index 09e5e39a1..3d4139a34 100644
--- a/packages/contracts-test/tests/unit/rewards/rewards.test.ts
+++ b/packages/contracts-test/tests/unit/rewards/rewards.test.ts
@@ -159,6 +159,10 @@ describe('Rewards', () => {
       await grt.connect(wallet).approve(staking.address, toGRT('1000000'))
       await grt.connect(wallet).approve(curation.address, toGRT('1000000'))
     }
+
+    // HACK: we set the staking contract as the subgraph service to make tests pass.
+    // This is due to the test suite being outdated.
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/staking/allocation.test.ts b/packages/contracts-test/tests/unit/staking/allocation.test.ts
index dd28aa73d..76de77a35 100644
--- a/packages/contracts-test/tests/unit/staking/allocation.test.ts
+++ b/packages/contracts-test/tests/unit/staking/allocation.test.ts
@@ -379,6 +379,10 @@ describe('Staking:Allocation', () => {
     // Give some funds to the delegator and approve staking contract to use funds on delegator behalf
     await grt.connect(governor).mint(delegator.address, tokensToDelegate)
     await grt.connect(delegator).approve(staking.address, tokensToDelegate)
+
+    // HACK: we set the staking contract as the subgraph service to make tests pass.
+    // This is due to the test suite being outdated.
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts-test/tests/unit/staking/delegation.test.ts b/packages/contracts-test/tests/unit/staking/delegation.test.ts
index 71f911006..3542e817e 100644
--- a/packages/contracts-test/tests/unit/staking/delegation.test.ts
+++ b/packages/contracts-test/tests/unit/staking/delegation.test.ts
@@ -1,4 +1,4 @@
-import { EpochManager } from '@graphprotocol/contracts'
+import { EpochManager, IRewardsManager } from '@graphprotocol/contracts'
 import { GraphToken } from '@graphprotocol/contracts'
 import { IStaking } from '@graphprotocol/contracts'
 import { deriveChannelKey, GraphNetworkContracts, helpers, randomHexBytes, toBN, toGRT } from '@graphprotocol/sdk'
@@ -29,6 +29,7 @@ describe('Staking::Delegation', () => {
   let epochManager: EpochManager
   let grt: GraphToken
   let staking: IStaking
+  let rewardsManager: IRewardsManager
 
   // Test values
   const poi = randomHexBytes()
@@ -159,6 +160,7 @@ describe('Staking::Delegation', () => {
     epochManager = contracts.EpochManager as EpochManager
     grt = contracts.GraphToken as GraphToken
     staking = contracts.Staking as IStaking
+    rewardsManager = contracts.RewardsManager as IRewardsManager
 
     // Distribute test funds
     for (const wallet of [delegator, delegator2]) {
@@ -173,6 +175,10 @@ describe('Staking::Delegation', () => {
     }
     await grt.connect(governor).mint(assetHolder.address, tokensToCollect)
     await grt.connect(assetHolder).approve(staking.address, tokensToCollect)
+
+    // HACK: we set the staking contract as the subgraph service to make tests pass.
+    // This is due to the test suite being outdated.
+    await rewardsManager.connect(governor).setSubgraphService(staking.address)
   })
 
   beforeEach(async function () {
diff --git a/packages/contracts/contracts/l2/curation/L2Curation.sol b/packages/contracts/contracts/l2/curation/L2Curation.sol
index 56e83c13a..fd26bd2ac 100644
--- a/packages/contracts/contracts/l2/curation/L2Curation.sol
+++ b/packages/contracts/contracts/l2/curation/L2Curation.sol
@@ -171,11 +171,8 @@ contract L2Curation is CurationV3Storage, GraphUpgradeable, IL2Curation {
      * @param _tokens Amount of Graph Tokens to add to reserves
      */
     function collect(bytes32 _subgraphDeploymentID, uint256 _tokens) external override {
-        // Only SubgraphService and Staking contract are authorized as callers
-        require(
-            msg.sender == subgraphService || msg.sender == address(staking()),
-            "Caller must be the subgraph service or staking contract"
-        );
+        // Only SubgraphService is authorized as caller
+        require(msg.sender == subgraphService, "Caller must be the subgraph service");
 
         // Must be curated to accept tokens
         require(isCurated(_subgraphDeploymentID), "Subgraph deployment must be curated to collect fees");
diff --git a/packages/contracts/contracts/rewards/RewardsManager.sol b/packages/contracts/contracts/rewards/RewardsManager.sol
index 0b223429c..bdec89ee0 100644
--- a/packages/contracts/contracts/rewards/RewardsManager.sol
+++ b/packages/contracts/contracts/rewards/RewardsManager.sol
@@ -22,12 +22,22 @@ import { RewardsCondition } from "@graphprotocol/interfaces/contracts/contracts/
 /**
  * @title Rewards Manager Contract
  * @author Edge & Node
- * @notice Manages indexing rewards distribution using a two-level accumulation model:
- * signal → subgraph → allocation. See docs/RewardAccountingSafety.md for details.
+ * @notice Manages rewards distribution for indexers and delegators in the Graph Protocol
+ * @dev Tracks how inflationary GRT rewards should be handed out. Relies on the Curation contract
+ * and the Staking contract. Signaled GRT in Curation determine what percentage of the tokens go
+ * towards each subgraph. Then each Subgraph can have multiple Indexers Staked on it. Thus, the
+ * total rewards for the Subgraph are split up for each Indexer based on much they have Staked on
+ * that Subgraph.
  *
- * @dev Issuance source: `issuanceAllocator` if set, otherwise `issuancePerBlock` storage.
- * Getter functions (getAccRewardsPerSignal, getRewards, etc.) may overestimate until
- * takeRewards is called due to pending state updates.
+ * Note:
+ * The contract provides getter functions to query the state of accrued rewards:
+ * - getAccRewardsPerSignal
+ * - getAccRewardsForSubgraph
+ * - getAccRewardsPerAllocatedToken
+ * - getRewards
+ * These functions may overestimate the actual rewards due to changes in the total supply
+ * until the actual takeRewards function is called.
+ * custom:security-contact Please email security+contracts@ thegraph.com (remove space) if you find any bugs. We might have an active bug bounty program.
  */
 contract RewardsManager is
     GraphUpgradeable,
@@ -446,19 +456,13 @@ contract RewardsManager is
     /**
      * @notice Get total allocated tokens for a subgraph across all issuers
      * @param _subgraphDeploymentID Subgraph deployment
-     * @return Total tokens allocated to this subgraph
-     */
-    function _getSubgraphAllocatedTokens(bytes32 _subgraphDeploymentID) private view returns (uint256) {
-        uint256 subgraphAllocatedTokens = 0;
-        address[2] memory rewardsIssuers = [address(staking()), address(subgraphService)];
-        for (uint256 i = 0; i < rewardsIssuers.length; ++i) {
-            if (rewardsIssuers[i] != address(0)) {
-                subgraphAllocatedTokens += IRewardsIssuer(rewardsIssuers[i]).getSubgraphAllocatedTokens(
-                    _subgraphDeploymentID
-                );
-            }
-        }
-        return subgraphAllocatedTokens;
+     * @return subgraphAllocatedTokens Total tokens allocated to this subgraph
+     */
+    function _getSubgraphAllocatedTokens(
+        bytes32 _subgraphDeploymentID
+    ) private view returns (uint256 subgraphAllocatedTokens) {
+        if (address(subgraphService) != address(0))
+            subgraphAllocatedTokens += subgraphService.getSubgraphAllocatedTokens(_subgraphDeploymentID);
     }
 
     // -- Updates --
@@ -578,7 +582,7 @@ contract RewardsManager is
 
     /**
      * @inheritdoc IRewardsManager
-     * @dev Hook called from the Staking contract on allocate() and close()
+     * @dev Hook called from the IRewardsIssuer contract on allocate() and close()
      *
      * ## Claimability Behavior
      *
@@ -626,10 +630,7 @@ contract RewardsManager is
      * takeRewards().
      */
     function getRewards(address _rewardsIssuer, address _allocationID) external view override returns (uint256) {
-        require(
-            _rewardsIssuer == address(staking()) || _rewardsIssuer == address(subgraphService),
-            "Not a rewards issuer"
-        );
+        require(_rewardsIssuer == address(subgraphService), "Not a rewards issuer");
 
         (
             bool isActive,
@@ -783,7 +784,7 @@ contract RewardsManager is
     /**
      * @inheritdoc IRewardsManager
      * @dev This function can only be called by an authorized rewards issuer which are
-     * the staking contract (for legacy allocations), and the subgraph service (for new allocations).
+     * - the subgraph service (for allocations).
      * Mints 0 tokens if the allocation is not active.
      * @dev First successful reclaim wins - short-circuits on reclaim:
      * - If subgraph denied with reclaim address → reclaim to SUBGRAPH_DENIED address (eligibility NOT checked)
@@ -793,10 +794,7 @@ contract RewardsManager is
      */
     function takeRewards(address _allocationID) external override returns (uint256) {
         address rewardsIssuer = msg.sender;
-        require(
-            rewardsIssuer == address(staking()) || rewardsIssuer == address(subgraphService),
-            "Caller must be a rewards issuer"
-        );
+        require(rewardsIssuer == address(subgraphService), "Caller must be a rewards issuer");
 
         (uint256 rewards, address indexer, bytes32 subgraphDeploymentID) = _calcAllocationRewards(
             rewardsIssuer,
diff --git a/packages/horizon/audits/2025-06-Indexing-Payments.pdf b/packages/horizon/audits/2025-06-Indexing-Payments.pdf
new file mode 100644
index 000000000..bd5325dca
Binary files /dev/null and b/packages/horizon/audits/2025-06-Indexing-Payments.pdf differ
diff --git a/packages/horizon/contracts/data-service/extensions/DataServiceFees.sol b/packages/horizon/contracts/data-service/extensions/DataServiceFees.sol
index 0f8cf3653..839a68925 100644
--- a/packages/horizon/contracts/data-service/extensions/DataServiceFees.sol
+++ b/packages/horizon/contracts/data-service/extensions/DataServiceFees.sol
@@ -6,6 +6,7 @@ import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/interna
 
 import { ProvisionTracker } from "../libraries/ProvisionTracker.sol";
 import { LinkedList } from "../../libraries/LinkedList.sol";
+import { StakeClaims } from "../libraries/StakeClaims.sol";
 
 import { DataService } from "../DataService.sol";
 import { DataServiceFeesV1Storage } from "./DataServiceFeesStorage.sol";
@@ -43,23 +44,17 @@ abstract contract DataServiceFees is DataService, DataServiceFeesV1Storage, IDat
      * @param _unlockTimestamp The timestamp when the tokens can be released
      */
     function _lockStake(address _serviceProvider, uint256 _tokens, uint256 _unlockTimestamp) internal {
-        require(_tokens != 0, DataServiceFeesZeroTokens());
-        feesProvisionTracker.lock(_graphStaking(), _serviceProvider, _tokens, _delegationRatio);
-
-        ILinkedList.List storage claimsList = claimsLists[_serviceProvider];
-
-        // Save item and add to list
-        bytes32 claimId = _buildStakeClaimId(_serviceProvider, claimsList.nonce);
-        claims[claimId] = StakeClaim({
-            tokens: _tokens,
-            createdAt: block.timestamp,
-            releasableAt: _unlockTimestamp,
-            nextClaim: bytes32(0)
-        });
-        if (claimsList.count != 0) claims[claimsList.tail].nextClaim = claimId;
-        claimsList.addTail(claimId);
-
-        emit StakeClaimLocked(_serviceProvider, claimId, _tokens, _unlockTimestamp);
+        StakeClaims.lockStake(
+            feesProvisionTracker,
+            claims,
+            claimsLists,
+            _graphStaking(),
+            address(this),
+            _delegationRatio,
+            _serviceProvider,
+            _tokens,
+            _unlockTimestamp
+        );
     }
 
     /**
@@ -82,7 +77,7 @@ abstract contract DataServiceFees is DataService, DataServiceFeesV1Storage, IDat
             _numClaimsToRelease
         );
 
-        emit StakeClaimsReleased(_serviceProvider, claimsReleased, abi.decode(data, (uint256)));
+        emit StakeClaims.StakeClaimsReleased(_serviceProvider, claimsReleased, abi.decode(data, (uint256)));
     }
 
     /**
@@ -94,23 +89,7 @@ abstract contract DataServiceFees is DataService, DataServiceFeesV1Storage, IDat
      * @return The updated accumulator data
      */
     function _processStakeClaim(bytes32 _claimId, bytes memory _acc) private returns (bool, bytes memory) {
-        StakeClaim memory claim = _getStakeClaim(_claimId);
-
-        // early exit
-        if (claim.releasableAt > block.timestamp) {
-            return (true, LinkedList.NULL_BYTES);
-        }
-
-        // decode
-        (uint256 tokensClaimed, address serviceProvider) = abi.decode(_acc, (uint256, address));
-
-        // process
-        feesProvisionTracker.release(serviceProvider, claim.tokens);
-        emit StakeClaimReleased(serviceProvider, _claimId, claim.tokens, claim.releasableAt);
-
-        // encode
-        _acc = abi.encode(tokensClaimed + claim.tokens, serviceProvider);
-        return (false, _acc);
+        return StakeClaims.processStakeClaim(feesProvisionTracker, claims, _claimId, _acc);
     }
 
     /**
@@ -119,18 +98,7 @@ abstract contract DataServiceFees is DataService, DataServiceFeesV1Storage, IDat
      * @param _claimId The ID of the stake claim to delete
      */
     function _deleteStakeClaim(bytes32 _claimId) private {
-        delete claims[_claimId];
-    }
-
-    /**
-     * @notice Gets the details of a stake claim
-     * @param _claimId The ID of the stake claim
-     * @return The stake claim details
-     */
-    function _getStakeClaim(bytes32 _claimId) private view returns (StakeClaim memory) {
-        StakeClaim memory claim = claims[_claimId];
-        require(claim.createdAt != 0, DataServiceFeesClaimNotFound(_claimId));
-        return claim;
+        StakeClaims.deleteStakeClaim(claims, _claimId);
     }
 
     /**
@@ -140,17 +108,6 @@ abstract contract DataServiceFees is DataService, DataServiceFeesV1Storage, IDat
      * @return The next stake claim ID
      */
     function _getNextStakeClaim(bytes32 _claimId) private view returns (bytes32) {
-        return claims[_claimId].nextClaim;
-    }
-
-    // forge-lint: disable-next-item(asm-keccak256)
-    /**
-     * @notice Builds a stake claim ID
-     * @param _serviceProvider The address of the service provider
-     * @param _nonce A nonce of the stake claim
-     * @return The stake claim ID
-     */
-    function _buildStakeClaimId(address _serviceProvider, uint256 _nonce) private view returns (bytes32) {
-        return keccak256(abi.encodePacked(address(this), _serviceProvider, _nonce));
+        return StakeClaims.getNextStakeClaim(claims, _claimId);
     }
 }
diff --git a/packages/horizon/contracts/data-service/extensions/DataServiceFeesStorage.sol b/packages/horizon/contracts/data-service/extensions/DataServiceFeesStorage.sol
index 384149201..7471bb8a2 100644
--- a/packages/horizon/contracts/data-service/extensions/DataServiceFeesStorage.sol
+++ b/packages/horizon/contracts/data-service/extensions/DataServiceFeesStorage.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.27 || 0.8.33;
 
-import { IDataServiceFees } from "@graphprotocol/interfaces/contracts/data-service/IDataServiceFees.sol";
+import { StakeClaims } from "../libraries/StakeClaims.sol";
 
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 
@@ -17,7 +17,7 @@ abstract contract DataServiceFeesV1Storage {
     mapping(address serviceProvider => uint256 tokens) public feesProvisionTracker;
 
     /// @notice List of all locked stake claims to be released to service providers
-    mapping(bytes32 claimId => IDataServiceFees.StakeClaim claim) public claims;
+    mapping(bytes32 claimId => StakeClaims.StakeClaim claim) public claims;
 
     /// @notice Service providers registered in the data service
     mapping(address serviceProvider => ILinkedList.List list) public claimsLists;
diff --git a/packages/horizon/contracts/data-service/extensions/DataServicePausable.sol b/packages/horizon/contracts/data-service/extensions/DataServicePausable.sol
index 7d0c8c522..1cdac7d17 100644
--- a/packages/horizon/contracts/data-service/extensions/DataServicePausable.sol
+++ b/packages/horizon/contracts/data-service/extensions/DataServicePausable.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.27;
+pragma solidity 0.8.27 || 0.8.33;
 
 import { IDataServicePausable } from "@graphprotocol/interfaces/contracts/data-service/IDataServicePausable.sol";
 
diff --git a/packages/horizon/contracts/data-service/extensions/DataServiceRescuable.sol b/packages/horizon/contracts/data-service/extensions/DataServiceRescuable.sol
deleted file mode 100644
index 9d609a087..000000000
--- a/packages/horizon/contracts/data-service/extensions/DataServiceRescuable.sol
+++ /dev/null
@@ -1,84 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.27;
-
-import { Address } from "@openzeppelin/contracts/utils/Address.sol";
-import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import { IDataServiceRescuable } from "@graphprotocol/interfaces/contracts/data-service/IDataServiceRescuable.sol";
-
-import { DataService } from "../DataService.sol";
-
-import { Denominations } from "../../libraries/Denominations.sol";
-import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-/**
- * @title Rescuable contract
- * @author Edge & Node
- * @notice Allows a contract to have a function to rescue tokens sent by mistake.
- * @dev The contract must implement the external rescueTokens function or similar,
- * that calls this contract's _rescueTokens.
- * @dev Note that this extension does not provide an external function to set
- * rescuers. This should be implemented in the derived contract.
- * @dev This contract inherits from {DataService} which needs to be initialized, please see
- * {DataService} for detailed instructions.
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-abstract contract DataServiceRescuable is DataService, IDataServiceRescuable {
-    /// @notice List of rescuers and their allowed status
-    mapping(address rescuer => bool allowed) public rescuers;
-
-    // forge-lint: disable-next-item(mixed-case-variable)
-    /// @dev Gap to allow adding variables in future upgrades
-    /// Note that this contract is not upgradeable but might be inherited by an upgradeable contract
-    uint256[50] private __gap;
-
-    // forge-lint: disable-next-item(unwrapped-modifier-logic)
-    /**
-     * @notice Checks if the caller is a rescuer.
-     */
-    modifier onlyRescuer() {
-        require(rescuers[msg.sender], DataServiceRescuableNotRescuer(msg.sender));
-        _;
-    }
-
-    // forge-lint: disable-next-item(mixed-case-function)
-    /// @inheritdoc IDataServiceRescuable
-    function rescueGRT(address to, uint256 tokens) external virtual onlyRescuer {
-        _rescueTokens(to, address(_graphToken()), tokens);
-    }
-
-    // forge-lint: disable-next-item(mixed-case-function)
-    /// @inheritdoc IDataServiceRescuable
-    function rescueETH(address payable to, uint256 tokens) external virtual onlyRescuer {
-        _rescueTokens(to, Denominations.NATIVE_TOKEN, tokens);
-    }
-
-    /**
-     * @notice Sets a rescuer.
-     * @dev Internal function to be used by the derived contract to set rescuers.
-     *
-     * Emits a {RescuerSet} event.
-     *
-     * @param _rescuer Address of the rescuer
-     * @param _allowed Allowed status of the rescuer
-     */
-    function _setRescuer(address _rescuer, bool _allowed) internal {
-        rescuers[_rescuer] = _allowed;
-        emit RescuerSet(_rescuer, _allowed);
-    }
-
-    /**
-     * @notice Allows rescuing tokens sent to this contract
-     * @param _to Destination address to send the tokens
-     * @param _token Address of the token being rescued
-     * @param _tokens Amount of tokens to pull
-     */
-    function _rescueTokens(address _to, address _token, uint256 _tokens) internal {
-        require(_tokens != 0, DataServiceRescuableCannotRescueZero());
-
-        if (Denominations.isNativeToken(_token)) Address.sendValue(payable(_to), _tokens);
-        else SafeERC20.safeTransfer(IERC20(_token), _to, _tokens);
-
-        emit TokensRescued(msg.sender, _to, _token, _tokens);
-    }
-}
diff --git a/packages/horizon/contracts/data-service/libraries/StakeClaims.sol b/packages/horizon/contracts/data-service/libraries/StakeClaims.sol
new file mode 100644
index 000000000..1d42538b5
--- /dev/null
+++ b/packages/horizon/contracts/data-service/libraries/StakeClaims.sol
@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.27 || 0.8.33;
+
+import { ProvisionTracker } from "./ProvisionTracker.sol";
+import { IHorizonStaking } from "@graphprotocol/interfaces/contracts/horizon/IHorizonStaking.sol";
+import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
+import { LinkedList } from "../../libraries/LinkedList.sol";
+
+/**
+ * @title StakeClaims library
+ * @author Edge & Node
+ * @notice Manages stake claims for data service fee payments, allowing service providers
+ * to lock and release provisioned stake through linked-list-based claim tracking.
+ */
+library StakeClaims {
+    using ProvisionTracker for mapping(address => uint256);
+    using LinkedList for ILinkedList.List;
+
+    /**
+     * @notice A stake claim, representing provisioned stake that gets locked
+     * to be released to a service provider.
+     * @dev StakeClaims are stored in linked lists by service provider, ordered by
+     * creation timestamp.
+     * @param tokens The amount of tokens to be locked in the claim
+     * @param createdAt The timestamp when the claim was created
+     * @param releasableAt The timestamp when the tokens can be released
+     * @param nextClaim The next claim in the linked list
+     */
+    struct StakeClaim {
+        uint256 tokens;
+        uint256 createdAt;
+        uint256 releasableAt;
+        bytes32 nextClaim;
+    }
+
+    /* solhint-disable gas-indexed-events */
+    /**
+     * @notice Emitted when a stake claim is created and stake is locked.
+     * @param serviceProvider The address of the service provider
+     * @param claimId The id of the stake claim
+     * @param tokens The amount of tokens to lock in the claim
+     * @param unlockTimestamp The timestamp when the tokens can be released
+     */
+    event StakeClaimLocked(
+        address indexed serviceProvider,
+        bytes32 indexed claimId,
+        uint256 tokens,
+        uint256 unlockTimestamp
+    );
+
+    /**
+     * @notice Emitted when a stake claim is released and stake is unlocked.
+     * @param serviceProvider The address of the service provider
+     * @param claimId The id of the stake claim
+     * @param tokens The amount of tokens released
+     * @param releasableAt The timestamp when the tokens were released
+     */
+    event StakeClaimReleased(
+        address indexed serviceProvider,
+        bytes32 indexed claimId,
+        uint256 tokens,
+        uint256 releasableAt
+    );
+
+    /**
+     * @notice Emitted when a series of stake claims are released.
+     * @param serviceProvider The address of the service provider
+     * @param claimsCount The number of stake claims being released
+     * @param tokensReleased The total amount of tokens being released
+     */
+    event StakeClaimsReleased(address indexed serviceProvider, uint256 claimsCount, uint256 tokensReleased);
+    /* solhint-enable gas-indexed-events */
+
+    /**
+     * @notice Thrown when attempting to get a stake claim that does not exist.
+     * @param claimId The id of the stake claim
+     */
+    error StakeClaimsClaimNotFound(bytes32 claimId);
+
+    /**
+     * @notice Emitted when trying to lock zero tokens in a stake claim
+     */
+    error StakeClaimsZeroTokens();
+
+    /**
+     * @notice Locks stake for a service provider to back a payment.
+     * Creates a stake claim, which is stored in a linked list by service provider.
+     * @dev Requirements:
+     * - The associated provision must have enough available tokens to lock the stake.
+     *
+     * Emits a {StakeClaimLocked} event.
+     *
+     * @param feesProvisionTracker The mapping that tracks the provision tokens for each service provider
+     * @param claims The mapping that stores stake claims by their ID
+     * @param claimsLists The mapping that stores linked lists of stake claims by service provider
+     * @param graphStaking The Horizon staking contract used to lock the tokens
+     * @param _dataService The address of the data service
+     * @param _delegationRatio The delegation ratio to use for the stake claim
+     * @param _serviceProvider The address of the service provider
+     * @param _tokens The amount of tokens to lock in the claim
+     * @param _unlockTimestamp The timestamp when the tokens can be released
+     */
+    function lockStake(
+        mapping(address => uint256) storage feesProvisionTracker,
+        mapping(bytes32 => StakeClaim) storage claims,
+        mapping(address serviceProvider => ILinkedList.List list) storage claimsLists,
+        IHorizonStaking graphStaking,
+        address _dataService,
+        uint32 _delegationRatio,
+        address _serviceProvider,
+        uint256 _tokens,
+        uint256 _unlockTimestamp
+    ) external {
+        require(_tokens != 0, StakeClaimsZeroTokens());
+        feesProvisionTracker.lock(graphStaking, _serviceProvider, _tokens, _delegationRatio);
+
+        ILinkedList.List storage claimsList = claimsLists[_serviceProvider];
+
+        // Save item and add to list
+        bytes32 claimId = _buildStakeClaimId(_dataService, _serviceProvider, claimsList.nonce);
+        claims[claimId] = StakeClaim({
+            tokens: _tokens,
+            createdAt: block.timestamp,
+            releasableAt: _unlockTimestamp,
+            nextClaim: bytes32(0)
+        });
+        if (claimsList.count != 0) claims[claimsList.tail].nextClaim = claimId;
+        claimsList.addTail(claimId);
+
+        emit StakeClaimLocked(_serviceProvider, claimId, _tokens, _unlockTimestamp);
+    }
+
+    /**
+     * @notice Processes a stake claim, releasing the tokens if the claim has expired.
+     * @dev This function is used as a callback in the stake claims linked list traversal.
+     * @param feesProvisionTracker The mapping that tracks the provision tokens for each service provider.
+     * @param claims The mapping that stores stake claims by their ID.
+     * @param _claimId The ID of the stake claim to process.
+     * @param _acc The accumulator data, which contains the total tokens claimed and the service provider address.
+     * @return Whether the stake claim is still locked, indicating that the traversal should continue or stop.
+     * @return The updated accumulator data
+     */
+    function processStakeClaim(
+        mapping(address serviceProvider => uint256 tokens) storage feesProvisionTracker,
+        mapping(bytes32 claimId => StakeClaim claim) storage claims,
+        bytes32 _claimId,
+        bytes memory _acc
+    ) external returns (bool, bytes memory) {
+        StakeClaim memory claim = claims[_claimId];
+        require(claim.createdAt != 0, StakeClaimsClaimNotFound(_claimId));
+
+        // early exit
+        if (claim.releasableAt > block.timestamp) {
+            return (true, LinkedList.NULL_BYTES);
+        }
+
+        // decode
+        (uint256 tokensClaimed, address serviceProvider) = abi.decode(_acc, (uint256, address));
+
+        // process
+        feesProvisionTracker.release(serviceProvider, claim.tokens);
+        emit StakeClaimReleased(serviceProvider, _claimId, claim.tokens, claim.releasableAt);
+
+        // encode
+        _acc = abi.encode(tokensClaimed + claim.tokens, serviceProvider);
+        return (false, _acc);
+    }
+
+    /**
+     * @notice Deletes a stake claim.
+     * @dev This function is used as a callback in the stake claims linked list traversal.
+     * @param claims The mapping that stores stake claims by their ID
+     * @param claimId The ID of the stake claim to delete
+     */
+    function deleteStakeClaim(mapping(bytes32 claimId => StakeClaim claim) storage claims, bytes32 claimId) external {
+        delete claims[claimId];
+    }
+
+    /**
+     * @notice Gets the next stake claim in the linked list
+     * @dev This function is used as a callback in the stake claims linked list traversal.
+     * @param claims The mapping that stores stake claims by their ID
+     * @param claimId The ID of the stake claim
+     * @return The next stake claim ID
+     */
+    function getNextStakeClaim(
+        mapping(bytes32 claimId => StakeClaim claim) storage claims,
+        bytes32 claimId
+    ) external view returns (bytes32) {
+        return claims[claimId].nextClaim;
+    }
+
+    /**
+     * @notice Builds a stake claim ID
+     * @param dataService The address of the data service
+     * @param serviceProvider The address of the service provider
+     * @param nonce A nonce of the stake claim
+     * @return The stake claim ID
+     */
+    function buildStakeClaimId(
+        address dataService,
+        address serviceProvider,
+        uint256 nonce
+    ) public pure returns (bytes32) {
+        return _buildStakeClaimId(dataService, serviceProvider, nonce);
+    }
+
+    /**
+     * @notice Builds a stake claim ID
+     * @param _dataService The address of the data service
+     * @param _serviceProvider The address of the service provider
+     * @param _nonce A nonce of the stake claim
+     * @return The stake claim ID
+     */
+    function _buildStakeClaimId(
+        address _dataService,
+        address _serviceProvider,
+        uint256 _nonce
+    ) internal pure returns (bytes32) {
+        // forge-lint: disable-next-line(asm-keccak256)
+        return keccak256(abi.encodePacked(_dataService, _serviceProvider, _nonce));
+    }
+}
diff --git a/packages/horizon/contracts/data-service/utilities/ProvisionManager.sol b/packages/horizon/contracts/data-service/utilities/ProvisionManager.sol
index ec0be49c3..e060bde5b 100644
--- a/packages/horizon/contracts/data-service/utilities/ProvisionManager.sol
+++ b/packages/horizon/contracts/data-service/utilities/ProvisionManager.sol
@@ -132,9 +132,7 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
      * @param serviceProvider The address of the service provider.
      */
     modifier onlyValidProvision(address serviceProvider) virtual {
-        IHorizonStaking.Provision memory provision = _getProvision(serviceProvider);
-        _checkProvisionTokens(provision);
-        _checkProvisionParameters(provision, false);
+        _requireValidProvision(serviceProvider);
         _;
     }
 
@@ -186,7 +184,7 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
      * @param _max The maximum allowed value for the provision tokens.
      */
     function _setProvisionTokensRange(uint256 _min, uint256 _max) internal {
-        require(_min <= _max, ProvisionManagerInvalidRange(_min, _max));
+        _requireLTE(_min, _max);
         _minimumProvisionTokens = _min;
         _maximumProvisionTokens = _max;
         emit ProvisionTokensRangeSet(_min, _max);
@@ -198,7 +196,7 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
      * @param _max The maximum allowed value for the max verifier cut.
      */
     function _setVerifierCutRange(uint32 _min, uint32 _max) internal {
-        require(_min <= _max, ProvisionManagerInvalidRange(_min, _max));
+        _requireLTE(_min, _max);
         require(PPMMath.isValidPPM(_max), ProvisionManagerInvalidRange(_min, _max));
         _minimumVerifierCut = _min;
         _maximumVerifierCut = _max;
@@ -211,12 +209,23 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
      * @param _max The maximum allowed value for the thawing period.
      */
     function _setThawingPeriodRange(uint64 _min, uint64 _max) internal {
-        require(_min <= _max, ProvisionManagerInvalidRange(_min, _max));
+        _requireLTE(_min, _max);
         _minimumThawingPeriod = _min;
         _maximumThawingPeriod = _max;
         emit ThawingPeriodRangeSet(_min, _max);
     }
 
+    /**
+     * @notice Checks if a provision of a service provider is valid according
+     * to the parameter ranges established.
+     * @param _serviceProvider The address of the service provider.
+     */
+    function _requireValidProvision(address _serviceProvider) internal view {
+        IHorizonStaking.Provision memory provision = _getProvision(_serviceProvider);
+        _checkProvisionTokens(provision);
+        _checkProvisionParameters(provision, false);
+    }
+
     // -- checks --
 
     /**
@@ -224,8 +233,7 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
      * @param _serviceProvider The address of the service provider.
      */
     function _checkProvisionTokens(address _serviceProvider) internal view virtual {
-        IHorizonStaking.Provision memory provision = _getProvision(_serviceProvider);
-        _checkProvisionTokens(provision);
+        _checkProvisionTokens(_getProvision(_serviceProvider));
     }
 
     /**
@@ -248,8 +256,7 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
      * @param _checkPending If true, checks the pending provision parameters.
      */
     function _checkProvisionParameters(address _serviceProvider, bool _checkPending) internal view virtual {
-        IHorizonStaking.Provision memory provision = _getProvision(_serviceProvider);
-        _checkProvisionParameters(provision, _checkPending);
+        _checkProvisionParameters(_getProvision(_serviceProvider), _checkPending);
     }
 
     /**
@@ -330,4 +337,13 @@ abstract contract ProvisionManager is Initializable, GraphDirectory, ProvisionMa
     function _checkValueInRange(uint256 _value, uint256 _min, uint256 _max, bytes memory _revertMessage) private pure {
         require(_value.isInRange(_min, _max), ProvisionManagerInvalidValue(_revertMessage, _value, _min, _max));
     }
+
+    /**
+     * @notice Requires that a value is less than or equal to another value.
+     * @param _a The value to check.
+     * @param _b The value to compare against.
+     */
+    function _requireLTE(uint256 _a, uint256 _b) private pure {
+        require(_a <= _b, ProvisionManagerInvalidRange(_a, _b));
+    }
 }
diff --git a/packages/horizon/contracts/libraries/Denominations.sol b/packages/horizon/contracts/libraries/Denominations.sol
deleted file mode 100644
index abd0ac9a6..000000000
--- a/packages/horizon/contracts/libraries/Denominations.sol
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.27;
-
-/**
- * @title Denominations library
- * @author Edge & Node
- * @notice Provides a list of ground denominations for those tokens that cannot be represented by an ERC20
- * For now, the only needed is the native token that could be ETH, MATIC, or other depending on the layer being operated.
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-library Denominations {
-    /// @notice The address of the native token, i.e ETH
-    /// @dev This convention is taken from https://eips.ethereum.org/EIPS/eip-7528
-    address internal constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
-
-    /**
-     * @notice Checks if a token is the native token
-     * @param token The token address to check
-     * @return True if the token is the native token, false otherwise
-     */
-    function isNativeToken(address token) internal pure returns (bool) {
-        return token == NATIVE_TOKEN;
-    }
-}
diff --git a/packages/horizon/contracts/libraries/LibFixedMath.sol b/packages/horizon/contracts/libraries/LibFixedMath.sol
deleted file mode 100644
index f248a513d..000000000
--- a/packages/horizon/contracts/libraries/LibFixedMath.sol
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
-
-  Copyright 2017 Bprotocol Foundation, 2019 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-// SPDX-License-Identifier: Apache-2.0
-
-pragma solidity 0.8.27 || 0.8.33;
-
-// TODO: Re-enable and fix issues when publishing a new version
-// solhint-disable function-max-lines, gas-strict-inequalities
-// forge-lint: disable-start(unsafe-typecast)
-
-/**
- * @title LibFixedMath
- * @author Edge & Node
- * @notice This library provides fixed-point arithmetic operations.
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-library LibFixedMath {
-    // 1
-    int256 private constant FIXED_1 = int256(0x0000000000000000000000000000000080000000000000000000000000000000);
-    // 2**255
-    int256 private constant MIN_FIXED_VAL = type(int256).min;
-    // 0
-    int256 private constant EXP_MAX_VAL = 0;
-    // -63.875
-    int256 private constant EXP_MIN_VAL = -int256(0x0000000000000000000000000000001ff0000000000000000000000000000000);
-
-    /**
-     * @notice Get one as a fixed-point number
-     * @return f The fixed-point representation of one
-     */
-    function one() internal pure returns (int256 f) {
-        f = FIXED_1;
-    }
-
-    /**
-     * @notice Returns the subtraction of two fixed point numbers, reverting on overflow
-     * @param a The first fixed point number
-     * @param b The second fixed point number to subtract
-     * @return c The result of a - b
-     */
-    function sub(int256 a, int256 b) internal pure returns (int256 c) {
-        if (b == MIN_FIXED_VAL) {
-            revert("out-of-bounds");
-        }
-        c = _add(a, -b);
-    }
-
-    /**
-     * @notice Returns the multiplication of two fixed point numbers, reverting on overflow
-     * @param a The first fixed point number
-     * @param b The second fixed point number
-     * @return c The result of a * b
-     */
-    function mul(int256 a, int256 b) internal pure returns (int256 c) {
-        c = _mul(a, b) / FIXED_1;
-    }
-
-    /**
-     * @notice Performs (a * n) / d, without scaling for precision
-     * @param a The first fixed point number
-     * @param n The numerator
-     * @param d The denominator
-     * @return c The result of (a * n) / d
-     */
-    function mulDiv(int256 a, int256 n, int256 d) internal pure returns (int256 c) {
-        c = _div(_mul(a, n), d);
-    }
-
-    /**
-     * @notice Returns the unsigned integer result of multiplying a fixed-point number with an integer
-     * @dev Negative results are clamped to zero. Reverts if the multiplication overflows.
-     * @param f Fixed-point number
-     * @param u Unsigned integer
-     * @return Unsigned integer result, clamped to zero if negative
-     */
-    function uintMul(int256 f, uint256 u) internal pure returns (uint256) {
-        if (int256(u) < int256(0)) {
-            revert("out-of-bounds");
-        }
-        int256 c = _mul(f, int256(u));
-        if (c <= 0) {
-            return 0;
-        }
-        return uint256(uint256(c) >> 127);
-    }
-
-    /**
-     * @notice Convert signed `n` / `d` to a fixed-point number
-     * @param n Numerator
-     * @param d Denominator
-     * @return f Fixed-point representation of n/d
-     */
-    function toFixed(int256 n, int256 d) internal pure returns (int256 f) {
-        f = _div(_mul(n, FIXED_1), d);
-    }
-
-    /**
-     * @notice Convert a fixed-point number to an integer
-     * @param f Fixed-point number
-     * @return n Integer representation
-     */
-    function toInteger(int256 f) internal pure returns (int256 n) {
-        return f / FIXED_1;
-    }
-
-    /**
-     * @notice Compute the natural exponent for a fixed-point number EXP_MIN_VAL <= `x` <= 1
-     * @param x Fixed-point number to compute exponent for
-     * @return r The natural exponent of x
-     */
-    function exp(int256 x) internal pure returns (int256 r) {
-        if (x < EXP_MIN_VAL) {
-            // Saturate to zero below EXP_MIN_VAL.
-            return 0;
-        }
-        if (x == 0) {
-            return FIXED_1;
-        }
-        if (x > EXP_MAX_VAL) {
-            revert("out-of-bounds");
-        }
-
-        // Rewrite the input as a product of natural exponents and a
-        // single residual q, where q is a number of small magnitude.
-        // For example: e^-34.419 = e^(-32 - 2 - 0.25 - 0.125 - 0.044)
-        //              = e^-32 * e^-2 * e^-0.25 * e^-0.125 * e^-0.044
-        //              -> q = -0.044
-
-        // Multiply with the taylor series for e^q
-        int256 y;
-        int256 z;
-        // q = x % 0.125 (the residual)
-        z = y = x % 0x0000000000000000000000000000000010000000000000000000000000000000;
-        z = (z * y) / FIXED_1;
-        r += z * 0x10e1b3be415a0000; // add y^02 * (20! / 02!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x05a0913f6b1e0000; // add y^03 * (20! / 03!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0168244fdac78000; // add y^04 * (20! / 04!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x004807432bc18000; // add y^05 * (20! / 05!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x000c0135dca04000; // add y^06 * (20! / 06!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0001b707b1cdc000; // add y^07 * (20! / 07!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x000036e0f639b800; // add y^08 * (20! / 08!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x00000618fee9f800; // add y^09 * (20! / 09!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000009c197dcc00; // add y^10 * (20! / 10!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000000e30dce400; // add y^11 * (20! / 11!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x000000012ebd1300; // add y^12 * (20! / 12!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000000017499f00; // add y^13 * (20! / 13!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000000001a9d480; // add y^14 * (20! / 14!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x00000000001c6380; // add y^15 * (20! / 15!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x000000000001c638; // add y^16 * (20! / 16!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000000000001ab8; // add y^17 * (20! / 17!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x000000000000017c; // add y^18 * (20! / 18!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000000000000014; // add y^19 * (20! / 19!)
-        z = (z * y) / FIXED_1;
-        r += z * 0x0000000000000001; // add y^20 * (20! / 20!)
-        r = r / 0x21c3677c82b40000 + y + FIXED_1; // divide by 20! and then add y^1 / 1! + y^0 / 0!
-
-        // Multiply with the non-residual terms.
-        x = -x;
-        // e ^ -32
-        if ((x & int256(0x0000000000000000000000000000001000000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x00000000000000000000000000000000000000f1aaddd7742e56d32fb9f99744)) /
-                int256(0x0000000000000000000000000043cbaf42a000812488fc5c220ad7b97bf6e99e); // * e ^ -32
-        }
-        // e ^ -16
-        if ((x & int256(0x0000000000000000000000000000000800000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x00000000000000000000000000000000000afe10820813d65dfe6a33c07f738f)) /
-                int256(0x000000000000000000000000000005d27a9f51c31b7c2f8038212a0574779991); // * e ^ -16
-        }
-        // e ^ -8
-        if ((x & int256(0x0000000000000000000000000000000400000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x0000000000000000000000000000000002582ab704279e8efd15e0265855c47a)) /
-                int256(0x0000000000000000000000000000001b4c902e273a58678d6d3bfdb93db96d02); // * e ^ -8
-        }
-        // e ^ -4
-        if ((x & int256(0x0000000000000000000000000000000200000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x000000000000000000000000000000001152aaa3bf81cb9fdb76eae12d029571)) /
-                int256(0x00000000000000000000000000000003b1cc971a9bb5b9867477440d6d157750); // * e ^ -4
-        }
-        // e ^ -2
-        if ((x & int256(0x0000000000000000000000000000000100000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x000000000000000000000000000000002f16ac6c59de6f8d5d6f63c1482a7c86)) /
-                int256(0x000000000000000000000000000000015bf0a8b1457695355fb8ac404e7a79e3); // * e ^ -2
-        }
-        // e ^ -1
-        if ((x & int256(0x0000000000000000000000000000000080000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x000000000000000000000000000000004da2cbf1be5827f9eb3ad1aa9866ebb3)) /
-                int256(0x00000000000000000000000000000000d3094c70f034de4b96ff7d5b6f99fcd8); // * e ^ -1
-        }
-        // e ^ -0.5
-        if ((x & int256(0x0000000000000000000000000000000040000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x0000000000000000000000000000000063afbe7ab2082ba1a0ae5e4eb1b479dc)) /
-                int256(0x00000000000000000000000000000000a45af1e1f40c333b3de1db4dd55f29a7); // * e ^ -0.5
-        }
-        // e ^ -0.25
-        if ((x & int256(0x0000000000000000000000000000000020000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x0000000000000000000000000000000070f5a893b608861e1f58934f97aea57d)) /
-                int256(0x00000000000000000000000000000000910b022db7ae67ce76b441c27035c6a1); // * e ^ -0.25
-        }
-        // e ^ -0.125
-        if ((x & int256(0x0000000000000000000000000000000010000000000000000000000000000000)) != 0) {
-            r =
-                (r * int256(0x00000000000000000000000000000000783eafef1c0a8f3978c7f81824d62ebf)) /
-                int256(0x0000000000000000000000000000000088415abbe9a76bead8d00cf112e4d4a8); // * e ^ -0.125
-        }
-    }
-
-    /**
-     * @notice Returns the multiplication of two numbers, reverting on overflow
-     * @param a First number
-     * @param b Second number
-     * @return c The result of a * b
-     */
-    function _mul(int256 a, int256 b) private pure returns (int256 c) {
-        if (a == 0 || b == 0) {
-            return 0;
-        }
-        unchecked {
-            c = a * b;
-            if (c / a != b || c / b != a) {
-                revert("overflow");
-            }
-        }
-    }
-
-    /**
-     * @notice Returns the division of two numbers, reverting on division by zero
-     * @param a Dividend
-     * @param b Divisor
-     * @return c The result of a / b
-     */
-    function _div(int256 a, int256 b) private pure returns (int256 c) {
-        if (b == 0) {
-            revert("overflow");
-        }
-        if (a == MIN_FIXED_VAL && b == -1) {
-            revert("overflow");
-        }
-        unchecked {
-            c = a / b;
-        }
-    }
-
-    /**
-     * @notice Adds two numbers, reverting on overflow
-     * @param a First number
-     * @param b Second number
-     * @return c The result of a + b
-     */
-    function _add(int256 a, int256 b) private pure returns (int256 c) {
-        unchecked {
-            c = a + b;
-            if ((a < 0 && b < 0 && c > a) || (a > 0 && b > 0 && c < a)) {
-                revert("overflow");
-            }
-        }
-    }
-}
diff --git a/packages/horizon/contracts/libraries/MathUtils.sol b/packages/horizon/contracts/libraries/MathUtils.sol
deleted file mode 100644
index ec8cc8161..000000000
--- a/packages/horizon/contracts/libraries/MathUtils.sol
+++ /dev/null
@@ -1,56 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// TODO: Re-enable and fix issues when publishing a new version
-// solhint-disable gas-strict-inequalities
-
-pragma solidity 0.8.27 || 0.8.33;
-
-/**
- * @title MathUtils Library
- * @author Edge & Node
- * @notice A collection of functions to perform math operations
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-library MathUtils {
-    /**
-     * @notice Calculates the weighted average of two values pondering each of these
-     * values based on configured weights
-     * @dev The contribution of each value N is
-     * weightN/(weightA + weightB). The calculation rounds up to ensure the result
-     * is always equal or greater than the smallest of the two values.
-     * @param valueA The amount for value A
-     * @param weightA The weight to use for value A
-     * @param valueB The amount for value B
-     * @param weightB The weight to use for value B
-     * @return The weighted average result
-     */
-    function weightedAverageRoundingUp(
-        uint256 valueA,
-        uint256 weightA,
-        uint256 valueB,
-        uint256 weightB
-    ) internal pure returns (uint256) {
-        return ((valueA * weightA) + (valueB * weightB) + (weightA + weightB - 1)) / (weightA + weightB);
-    }
-
-    /**
-     * @notice Returns the minimum of two numbers
-     * @param x The first number
-     * @param y The second number
-     * @return The minimum of the two numbers
-     */
-    function min(uint256 x, uint256 y) internal pure returns (uint256) {
-        return x <= y ? x : y;
-    }
-
-    /**
-     * @notice Returns the difference between two numbers or zero if negative
-     * @param x The first number
-     * @param y The second number
-     * @return The difference between the two numbers or zero if negative
-     */
-    function diffOrZero(uint256 x, uint256 y) internal pure returns (uint256) {
-        return (x > y) ? x - y : 0;
-    }
-}
diff --git a/packages/horizon/contracts/mocks/imports.sol b/packages/horizon/contracts/mocks/imports.sol
index 3a05b2b4d..73a67f3b0 100644
--- a/packages/horizon/contracts/mocks/imports.sol
+++ b/packages/horizon/contracts/mocks/imports.sol
@@ -1,7 +1,7 @@
 // solhint-disable no-global-import
 
 // SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity ^0.7.6 || 0.8.27;
+pragma solidity ^0.7.6 || 0.8.27 || 0.8.33;
 
 // We import these here to force Hardhat to compile them.
 // This ensures that their artifacts are available for Hardhat Ignition to use.
diff --git a/packages/horizon/contracts/payments/collectors/RecurringCollector.sol b/packages/horizon/contracts/payments/collectors/RecurringCollector.sol
new file mode 100644
index 000000000..10c6df60f
--- /dev/null
+++ b/packages/horizon/contracts/payments/collectors/RecurringCollector.sol
@@ -0,0 +1,666 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.33;
+
+import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
+
+import { Authorizable } from "../../utilities/Authorizable.sol";
+import { GraphDirectory } from "../../utilities/GraphDirectory.sol";
+// solhint-disable-next-line no-unused-import
+import { IPaymentsCollector } from "@graphprotocol/interfaces/contracts/horizon/IPaymentsCollector.sol"; // for @inheritdoc
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { PPMMath } from "../../libraries/PPMMath.sol";
+
+/**
+ * @title RecurringCollector contract
+ * @author Edge & Node
+ * @dev Implements the {IRecurringCollector} interface.
+ * @notice A payments collector contract that can be used to collect payments using a RCA (Recurring Collection Agreement).
+ * @custom:security-contact Please email security+contracts@thegraph.com if you find any
+ * bugs. We may have an active bug bounty program.
+ */
+contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringCollector {
+    using PPMMath for uint256;
+
+    /// @notice The minimum number of seconds that must be between two collections
+    uint32 public constant MIN_SECONDS_COLLECTION_WINDOW = 600;
+
+    /* solhint-disable gas-small-strings */
+    /// @notice The EIP712 typehash for the RecurringCollectionAgreement struct
+    bytes32 public constant EIP712_RCA_TYPEHASH =
+        keccak256(
+            "RecurringCollectionAgreement(uint64 deadline,uint64 endsAt,address payer,address dataService,address serviceProvider,uint256 maxInitialTokens,uint256 maxOngoingTokensPerSecond,uint32 minSecondsPerCollection,uint32 maxSecondsPerCollection,uint256 nonce,bytes metadata)"
+        );
+
+    /// @notice The EIP712 typehash for the RecurringCollectionAgreementUpdate struct
+    bytes32 public constant EIP712_RCAU_TYPEHASH =
+        keccak256(
+            "RecurringCollectionAgreementUpdate(bytes16 agreementId,uint64 deadline,uint64 endsAt,uint256 maxInitialTokens,uint256 maxOngoingTokensPerSecond,uint32 minSecondsPerCollection,uint32 maxSecondsPerCollection,uint32 nonce,bytes metadata)"
+        );
+    /* solhint-enable gas-small-strings */
+
+    /// @notice Tracks agreements
+    mapping(bytes16 agreementId => AgreementData data) internal agreements;
+
+    /**
+     * @notice Constructs a new instance of the RecurringCollector contract.
+     * @param eip712Name The name of the EIP712 domain.
+     * @param eip712Version The version of the EIP712 domain.
+     * @param controller The address of the Graph controller.
+     * @param revokeSignerThawingPeriod The duration (in seconds) in which a signer is thawing before they can be revoked.
+     */
+    constructor(
+        string memory eip712Name,
+        string memory eip712Version,
+        address controller,
+        uint256 revokeSignerThawingPeriod
+    ) EIP712(eip712Name, eip712Version) GraphDirectory(controller) Authorizable(revokeSignerThawingPeriod) {}
+
+    /**
+     * @inheritdoc IPaymentsCollector
+     * @notice Initiate a payment collection through the payments protocol.
+     * See {IPaymentsCollector.collect}.
+     * @dev Caller must be the data service the RCA was issued to.
+     */
+    function collect(IGraphPayments.PaymentTypes paymentType, bytes calldata data) external returns (uint256) {
+        try this.decodeCollectData(data) returns (CollectParams memory collectParams) {
+            return _collect(paymentType, collectParams);
+        } catch {
+            revert RecurringCollectorInvalidCollectData(data);
+        }
+    }
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @inheritdoc IRecurringCollector
+     * @notice Accept a Recurring Collection Agreement.
+     * See {IRecurringCollector.accept}.
+     * @dev Caller must be the data service the RCA was issued to.
+     */
+    function accept(SignedRCA calldata signedRCA) external returns (bytes16) {
+        bytes16 agreementId = _generateAgreementId(
+            signedRCA.rca.payer,
+            signedRCA.rca.dataService,
+            signedRCA.rca.serviceProvider,
+            signedRCA.rca.deadline,
+            signedRCA.rca.nonce
+        );
+
+        require(agreementId != bytes16(0), RecurringCollectorAgreementIdZero());
+        require(
+            msg.sender == signedRCA.rca.dataService,
+            RecurringCollectorUnauthorizedCaller(msg.sender, signedRCA.rca.dataService)
+        );
+        /* solhint-disable gas-strict-inequalities */
+        require(
+            signedRCA.rca.deadline >= block.timestamp,
+            RecurringCollectorAgreementDeadlineElapsed(block.timestamp, signedRCA.rca.deadline)
+        );
+        /* solhint-enable gas-strict-inequalities */
+
+        // check that the voucher is signed by the payer (or proxy)
+        _requireAuthorizedRCASigner(signedRCA);
+
+        require(
+            signedRCA.rca.dataService != address(0) &&
+                signedRCA.rca.payer != address(0) &&
+                signedRCA.rca.serviceProvider != address(0),
+            RecurringCollectorAgreementAddressNotSet()
+        );
+
+        _requireValidCollectionWindowParams(
+            signedRCA.rca.endsAt,
+            signedRCA.rca.minSecondsPerCollection,
+            signedRCA.rca.maxSecondsPerCollection
+        );
+
+        AgreementData storage agreement = _getAgreementStorage(agreementId);
+        // check that the agreement is not already accepted
+        require(
+            agreement.state == AgreementState.NotAccepted,
+            RecurringCollectorAgreementIncorrectState(agreementId, agreement.state)
+        );
+
+        // accept the agreement
+        agreement.acceptedAt = uint64(block.timestamp);
+        agreement.state = AgreementState.Accepted;
+        agreement.dataService = signedRCA.rca.dataService;
+        agreement.payer = signedRCA.rca.payer;
+        agreement.serviceProvider = signedRCA.rca.serviceProvider;
+        agreement.endsAt = signedRCA.rca.endsAt;
+        agreement.maxInitialTokens = signedRCA.rca.maxInitialTokens;
+        agreement.maxOngoingTokensPerSecond = signedRCA.rca.maxOngoingTokensPerSecond;
+        agreement.minSecondsPerCollection = signedRCA.rca.minSecondsPerCollection;
+        agreement.maxSecondsPerCollection = signedRCA.rca.maxSecondsPerCollection;
+        agreement.updateNonce = 0;
+
+        emit AgreementAccepted(
+            agreement.dataService,
+            agreement.payer,
+            agreement.serviceProvider,
+            agreementId,
+            agreement.acceptedAt,
+            agreement.endsAt,
+            agreement.maxInitialTokens,
+            agreement.maxOngoingTokensPerSecond,
+            agreement.minSecondsPerCollection,
+            agreement.maxSecondsPerCollection
+        );
+
+        return agreementId;
+    }
+    /* solhint-enable function-max-lines */
+
+    /**
+     * @inheritdoc IRecurringCollector
+     * @notice Cancel a Recurring Collection Agreement.
+     * See {IRecurringCollector.cancel}.
+     * @dev Caller must be the data service for the agreement.
+     */
+    function cancel(bytes16 agreementId, CancelAgreementBy by) external {
+        AgreementData storage agreement = _getAgreementStorage(agreementId);
+        require(
+            agreement.state == AgreementState.Accepted,
+            RecurringCollectorAgreementIncorrectState(agreementId, agreement.state)
+        );
+        require(
+            agreement.dataService == msg.sender,
+            RecurringCollectorDataServiceNotAuthorized(agreementId, msg.sender)
+        );
+        agreement.canceledAt = uint64(block.timestamp);
+        if (by == CancelAgreementBy.Payer) {
+            agreement.state = AgreementState.CanceledByPayer;
+        } else {
+            agreement.state = AgreementState.CanceledByServiceProvider;
+        }
+
+        emit AgreementCanceled(
+            agreement.dataService,
+            agreement.payer,
+            agreement.serviceProvider,
+            agreementId,
+            agreement.canceledAt,
+            by
+        );
+    }
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @inheritdoc IRecurringCollector
+     * @notice Update a Recurring Collection Agreement.
+     * See {IRecurringCollector.update}.
+     * @dev Caller must be the data service for the agreement.
+     * @dev Note: Updated pricing terms apply immediately and will affect the next collection
+     * for the entire period since lastCollectionAt.
+     */
+    function update(SignedRCAU calldata signedRCAU) external {
+        /* solhint-disable gas-strict-inequalities */
+        require(
+            signedRCAU.rcau.deadline >= block.timestamp,
+            RecurringCollectorAgreementDeadlineElapsed(block.timestamp, signedRCAU.rcau.deadline)
+        );
+        /* solhint-enable gas-strict-inequalities */
+
+        AgreementData storage agreement = _getAgreementStorage(signedRCAU.rcau.agreementId);
+        require(
+            agreement.state == AgreementState.Accepted,
+            RecurringCollectorAgreementIncorrectState(signedRCAU.rcau.agreementId, agreement.state)
+        );
+        require(
+            agreement.dataService == msg.sender,
+            RecurringCollectorDataServiceNotAuthorized(signedRCAU.rcau.agreementId, msg.sender)
+        );
+
+        // check that the voucher is signed by the payer (or proxy)
+        _requireAuthorizedRCAUSigner(signedRCAU, agreement.payer);
+
+        // validate nonce to prevent replay attacks
+        uint32 expectedNonce = agreement.updateNonce + 1;
+        require(
+            signedRCAU.rcau.nonce == expectedNonce,
+            RecurringCollectorInvalidUpdateNonce(signedRCAU.rcau.agreementId, expectedNonce, signedRCAU.rcau.nonce)
+        );
+
+        _requireValidCollectionWindowParams(
+            signedRCAU.rcau.endsAt,
+            signedRCAU.rcau.minSecondsPerCollection,
+            signedRCAU.rcau.maxSecondsPerCollection
+        );
+
+        // update the agreement
+        agreement.endsAt = signedRCAU.rcau.endsAt;
+        agreement.maxInitialTokens = signedRCAU.rcau.maxInitialTokens;
+        agreement.maxOngoingTokensPerSecond = signedRCAU.rcau.maxOngoingTokensPerSecond;
+        agreement.minSecondsPerCollection = signedRCAU.rcau.minSecondsPerCollection;
+        agreement.maxSecondsPerCollection = signedRCAU.rcau.maxSecondsPerCollection;
+        agreement.updateNonce = signedRCAU.rcau.nonce;
+
+        emit AgreementUpdated(
+            agreement.dataService,
+            agreement.payer,
+            agreement.serviceProvider,
+            signedRCAU.rcau.agreementId,
+            uint64(block.timestamp),
+            agreement.endsAt,
+            agreement.maxInitialTokens,
+            agreement.maxOngoingTokensPerSecond,
+            agreement.minSecondsPerCollection,
+            agreement.maxSecondsPerCollection
+        );
+    }
+    /* solhint-enable function-max-lines */
+
+    /// @inheritdoc IRecurringCollector
+    function recoverRCASigner(SignedRCA calldata signedRCA) external view returns (address) {
+        return _recoverRCASigner(signedRCA);
+    }
+
+    /// @inheritdoc IRecurringCollector
+    function recoverRCAUSigner(SignedRCAU calldata signedRCAU) external view returns (address) {
+        return _recoverRCAUSigner(signedRCAU);
+    }
+
+    /// @inheritdoc IRecurringCollector
+    function hashRCA(RecurringCollectionAgreement calldata rca) external view returns (bytes32) {
+        return _hashRCA(rca);
+    }
+
+    /// @inheritdoc IRecurringCollector
+    function hashRCAU(RecurringCollectionAgreementUpdate calldata rcau) external view returns (bytes32) {
+        return _hashRCAU(rcau);
+    }
+
+    /// @inheritdoc IRecurringCollector
+    function getAgreement(bytes16 agreementId) external view returns (AgreementData memory) {
+        return _getAgreement(agreementId);
+    }
+
+    /// @inheritdoc IRecurringCollector
+    function getCollectionInfo(
+        AgreementData calldata agreement
+    ) external view returns (bool isCollectable, uint256 collectionSeconds, AgreementNotCollectableReason reason) {
+        return _getCollectionInfo(agreement);
+    }
+
+    /// @inheritdoc IRecurringCollector
+    function generateAgreementId(
+        address payer,
+        address dataService,
+        address serviceProvider,
+        uint64 deadline,
+        uint256 nonce
+    ) external pure returns (bytes16) {
+        return _generateAgreementId(payer, dataService, serviceProvider, deadline, nonce);
+    }
+
+    /**
+     * @notice Decodes the collect data.
+     * @param data The encoded collect parameters.
+     * @return The decoded collect parameters.
+     */
+    function decodeCollectData(bytes calldata data) public pure returns (CollectParams memory) {
+        return abi.decode(data, (CollectParams));
+    }
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @notice Collect payment through the payments protocol.
+     * @dev Caller must be the data service the RCA was issued to.
+     *
+     * Emits {PaymentCollected} and {RCACollected} events.
+     *
+     * @param _paymentType The type of payment to collect
+     * @param _params The decoded parameters for the collection
+     * @return The amount of tokens collected
+     */
+    function _collect(
+        IGraphPayments.PaymentTypes _paymentType,
+        CollectParams memory _params
+    ) private returns (uint256) {
+        AgreementData storage agreement = _getAgreementStorage(_params.agreementId);
+
+        // Check if agreement is collectable first
+        (bool isCollectable, uint256 collectionSeconds, AgreementNotCollectableReason reason) = _getCollectionInfo(
+            agreement
+        );
+        require(isCollectable, RecurringCollectorAgreementNotCollectable(_params.agreementId, reason));
+
+        require(
+            msg.sender == agreement.dataService,
+            RecurringCollectorDataServiceNotAuthorized(_params.agreementId, msg.sender)
+        );
+
+        // Check the service provider has an active provision with the data service
+        // This prevents an attack where the payer can deny the service provider from collecting payments
+        // by using a signer as data service to syphon off the tokens in the escrow to an account they control
+        {
+            uint256 tokensAvailable = _graphStaking().getProviderTokensAvailable(
+                agreement.serviceProvider,
+                agreement.dataService
+            );
+            require(tokensAvailable > 0, RecurringCollectorUnauthorizedDataService(agreement.dataService));
+        }
+
+        uint256 tokensToCollect = 0;
+        if (_params.tokens != 0) {
+            tokensToCollect = _requireValidCollect(agreement, _params.agreementId, _params.tokens, collectionSeconds);
+
+            uint256 slippage = _params.tokens - tokensToCollect;
+            /* solhint-disable gas-strict-inequalities */
+            require(
+                slippage <= _params.maxSlippage,
+                RecurringCollectorExcessiveSlippage(_params.tokens, tokensToCollect, _params.maxSlippage)
+            );
+            /* solhint-enable gas-strict-inequalities */
+        }
+        agreement.lastCollectionAt = uint64(block.timestamp);
+
+        if (tokensToCollect > 0) {
+            _graphPaymentsEscrow().collect(
+                _paymentType,
+                agreement.payer,
+                agreement.serviceProvider,
+                tokensToCollect,
+                agreement.dataService,
+                _params.dataServiceCut,
+                _params.receiverDestination
+            );
+        }
+
+        emit PaymentCollected(
+            _paymentType,
+            _params.collectionId,
+            agreement.payer,
+            agreement.serviceProvider,
+            agreement.dataService,
+            tokensToCollect
+        );
+
+        emit RCACollected(
+            agreement.dataService,
+            agreement.payer,
+            agreement.serviceProvider,
+            _params.agreementId,
+            _params.collectionId,
+            tokensToCollect,
+            _params.dataServiceCut
+        );
+
+        return tokensToCollect;
+    }
+    /* solhint-enable function-max-lines */
+
+    /**
+     * @notice Requires that the collection window parameters are valid.
+     *
+     * @param _endsAt The end time of the agreement
+     * @param _minSecondsPerCollection The minimum seconds per collection
+     * @param _maxSecondsPerCollection The maximum seconds per collection
+     */
+    function _requireValidCollectionWindowParams(
+        uint64 _endsAt,
+        uint32 _minSecondsPerCollection,
+        uint32 _maxSecondsPerCollection
+    ) private view {
+        // Agreement needs to end in the future
+        require(_endsAt > block.timestamp, RecurringCollectorAgreementElapsedEndsAt(block.timestamp, _endsAt));
+
+        // Collection window needs to be at least MIN_SECONDS_COLLECTION_WINDOW
+        require(
+            _maxSecondsPerCollection > _minSecondsPerCollection &&
+                // solhint-disable-next-line gas-strict-inequalities
+                (_maxSecondsPerCollection - _minSecondsPerCollection >= MIN_SECONDS_COLLECTION_WINDOW),
+            RecurringCollectorAgreementInvalidCollectionWindow(
+                MIN_SECONDS_COLLECTION_WINDOW,
+                _minSecondsPerCollection,
+                _maxSecondsPerCollection
+            )
+        );
+
+        // Agreement needs to last at least one min collection window
+        require(
+            // solhint-disable-next-line gas-strict-inequalities
+            _endsAt - block.timestamp >= _minSecondsPerCollection + MIN_SECONDS_COLLECTION_WINDOW,
+            RecurringCollectorAgreementInvalidDuration(
+                _minSecondsPerCollection + MIN_SECONDS_COLLECTION_WINDOW,
+                _endsAt - block.timestamp
+            )
+        );
+    }
+
+    /**
+     * @notice Requires that the collection params are valid.
+     * @param _agreement The agreement data
+     * @param _agreementId The ID of the agreement
+     * @param _tokens The number of tokens to collect
+     * @param _collectionSeconds Collection duration from _getCollectionInfo()
+     * @return The number of tokens that can be collected
+     */
+    function _requireValidCollect(
+        AgreementData memory _agreement,
+        bytes16 _agreementId,
+        uint256 _tokens,
+        uint256 _collectionSeconds
+    ) private view returns (uint256) {
+        bool canceledOrElapsed = _agreement.state == AgreementState.CanceledByPayer ||
+            block.timestamp > _agreement.endsAt;
+        if (!canceledOrElapsed) {
+            require(
+                // solhint-disable-next-line gas-strict-inequalities
+                _collectionSeconds >= _agreement.minSecondsPerCollection,
+                RecurringCollectorCollectionTooSoon(
+                    _agreementId,
+                    // casting to uint32 is safe because _collectionSeconds < minSecondsPerCollection (uint32)
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    uint32(_collectionSeconds),
+                    _agreement.minSecondsPerCollection
+                )
+            );
+        }
+        require(
+            // solhint-disable-next-line gas-strict-inequalities
+            _collectionSeconds <= _agreement.maxSecondsPerCollection,
+            RecurringCollectorCollectionTooLate(
+                _agreementId,
+                // casting to uint64 is safe because _collectionSeconds <= block.timestamp which fits in uint64
+                // forge-lint: disable-next-line(unsafe-typecast)
+                uint64(_collectionSeconds),
+                _agreement.maxSecondsPerCollection
+            )
+        );
+
+        uint256 maxTokens = _agreement.maxOngoingTokensPerSecond * _collectionSeconds;
+        maxTokens += _agreement.lastCollectionAt == 0 ? _agreement.maxInitialTokens : 0;
+
+        return Math.min(_tokens, maxTokens);
+    }
+
+    /**
+     * @notice See {recoverRCASigner}
+     * @param _signedRCA The signed RCA to recover the signer from
+     * @return The address of the signer
+     */
+    function _recoverRCASigner(SignedRCA memory _signedRCA) private view returns (address) {
+        bytes32 messageHash = _hashRCA(_signedRCA.rca);
+        return ECDSA.recover(messageHash, _signedRCA.signature);
+    }
+
+    /**
+     * @notice See {recoverRCAUSigner}
+     * @param _signedRCAU The signed RCAU to recover the signer from
+     * @return The address of the signer
+     */
+    function _recoverRCAUSigner(SignedRCAU memory _signedRCAU) private view returns (address) {
+        bytes32 messageHash = _hashRCAU(_signedRCAU.rcau);
+        return ECDSA.recover(messageHash, _signedRCAU.signature);
+    }
+
+    /**
+     * @notice See {hashRCA}
+     * @param _rca The RCA to hash
+     * @return The EIP712 hash of the RCA
+     */
+    function _hashRCA(RecurringCollectionAgreement memory _rca) private view returns (bytes32) {
+        return
+            _hashTypedDataV4(
+                keccak256(
+                    abi.encode(
+                        EIP712_RCA_TYPEHASH,
+                        _rca.deadline,
+                        _rca.endsAt,
+                        _rca.payer,
+                        _rca.dataService,
+                        _rca.serviceProvider,
+                        _rca.maxInitialTokens,
+                        _rca.maxOngoingTokensPerSecond,
+                        _rca.minSecondsPerCollection,
+                        _rca.maxSecondsPerCollection,
+                        _rca.nonce,
+                        keccak256(_rca.metadata)
+                    )
+                )
+            );
+    }
+
+    /**
+     * @notice See {hashRCAU}
+     * @param _rcau The RCAU to hash
+     * @return The EIP712 hash of the RCAU
+     */
+    function _hashRCAU(RecurringCollectionAgreementUpdate memory _rcau) private view returns (bytes32) {
+        return
+            _hashTypedDataV4(
+                keccak256(
+                    abi.encode(
+                        EIP712_RCAU_TYPEHASH,
+                        _rcau.agreementId,
+                        _rcau.deadline,
+                        _rcau.endsAt,
+                        _rcau.maxInitialTokens,
+                        _rcau.maxOngoingTokensPerSecond,
+                        _rcau.minSecondsPerCollection,
+                        _rcau.maxSecondsPerCollection,
+                        _rcau.nonce,
+                        keccak256(_rcau.metadata)
+                    )
+                )
+            );
+    }
+
+    /**
+     * @notice Requires that the signer for the RCA is authorized
+     * by the payer of the RCA.
+     * @param _signedRCA The signed RCA to verify
+     * @return The address of the authorized signer
+     */
+    function _requireAuthorizedRCASigner(SignedRCA memory _signedRCA) private view returns (address) {
+        address signer = _recoverRCASigner(_signedRCA);
+        require(_isAuthorized(_signedRCA.rca.payer, signer), RecurringCollectorInvalidSigner());
+
+        return signer;
+    }
+
+    /**
+     * @notice Requires that the signer for the RCAU is authorized
+     * by the payer.
+     * @param _signedRCAU The signed RCAU to verify
+     * @param _payer The address of the payer
+     * @return The address of the authorized signer
+     */
+    function _requireAuthorizedRCAUSigner(
+        SignedRCAU memory _signedRCAU,
+        address _payer
+    ) private view returns (address) {
+        address signer = _recoverRCAUSigner(_signedRCAU);
+        require(_isAuthorized(_payer, signer), RecurringCollectorInvalidSigner());
+
+        return signer;
+    }
+
+    /**
+     * @notice Gets an agreement to be updated.
+     * @param _agreementId The ID of the agreement to get
+     * @return The storage reference to the agreement data
+     */
+    function _getAgreementStorage(bytes16 _agreementId) private view returns (AgreementData storage) {
+        return agreements[_agreementId];
+    }
+
+    /**
+     * @notice See {getAgreement}
+     * @param _agreementId The ID of the agreement to get
+     * @return The agreement data
+     */
+    function _getAgreement(bytes16 _agreementId) private view returns (AgreementData memory) {
+        return agreements[_agreementId];
+    }
+
+    /**
+     * @notice Internal function to get collection info for an agreement
+     * @dev This is the single source of truth for collection window logic
+     * @param _agreement The agreement data
+     * @return isCollectable Whether the agreement can be collected from
+     * @return collectionSeconds The valid collection duration in seconds (0 if not collectable)
+     * @return reason The reason why the agreement is not collectable (None if collectable)
+     */
+    function _getCollectionInfo(
+        AgreementData memory _agreement
+    ) private view returns (bool, uint256, AgreementNotCollectableReason) {
+        // Check if agreement is in collectable state
+        bool hasValidState = _agreement.state == AgreementState.Accepted ||
+            _agreement.state == AgreementState.CanceledByPayer;
+
+        if (!hasValidState) {
+            return (false, 0, AgreementNotCollectableReason.InvalidAgreementState);
+        }
+
+        bool canceledOrElapsed = _agreement.state == AgreementState.CanceledByPayer ||
+            block.timestamp > _agreement.endsAt;
+        uint256 canceledOrNow = _agreement.state == AgreementState.CanceledByPayer
+            ? _agreement.canceledAt
+            : block.timestamp;
+
+        uint256 collectionEnd = canceledOrElapsed ? Math.min(canceledOrNow, _agreement.endsAt) : block.timestamp;
+        uint256 collectionStart = _agreementCollectionStartAt(_agreement);
+
+        if (collectionEnd < collectionStart) {
+            return (false, 0, AgreementNotCollectableReason.InvalidTemporalWindow);
+        }
+
+        if (collectionStart == collectionEnd) {
+            return (false, 0, AgreementNotCollectableReason.ZeroCollectionSeconds);
+        }
+
+        return (true, collectionEnd - collectionStart, AgreementNotCollectableReason.None);
+    }
+
+    /**
+     * @notice Gets the start time for the collection of an agreement.
+     * @param _agreement The agreement data
+     * @return The start time for the collection of the agreement
+     */
+    function _agreementCollectionStartAt(AgreementData memory _agreement) private pure returns (uint256) {
+        return _agreement.lastCollectionAt > 0 ? _agreement.lastCollectionAt : _agreement.acceptedAt;
+    }
+
+    /**
+     * @notice Internal function to generate deterministic agreement ID
+     * @param _payer The address of the payer
+     * @param _dataService The address of the data service
+     * @param _serviceProvider The address of the service provider
+     * @param _deadline The deadline for accepting the agreement
+     * @param _nonce A unique nonce for preventing collisions
+     * @return agreementId The deterministically generated agreement ID
+     */
+    function _generateAgreementId(
+        address _payer,
+        address _dataService,
+        address _serviceProvider,
+        uint64 _deadline,
+        uint256 _nonce
+    ) private pure returns (bytes16) {
+        return bytes16(keccak256(abi.encode(_payer, _dataService, _serviceProvider, _deadline, _nonce)));
+    }
+}
diff --git a/packages/horizon/contracts/staking/HorizonStaking.sol b/packages/horizon/contracts/staking/HorizonStaking.sol
index 7040ac343..574111b32 100644
--- a/packages/horizon/contracts/staking/HorizonStaking.sol
+++ b/packages/horizon/contracts/staking/HorizonStaking.sol
@@ -9,12 +9,11 @@ pragma solidity 0.8.27 || 0.8.33;
 
 import { IGraphToken } from "@graphprotocol/interfaces/contracts/contracts/token/IGraphToken.sol";
 import { IHorizonStakingMain } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol";
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 
 import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
-import { MathUtils } from "../libraries/MathUtils.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
 import { PPMMath } from "../libraries/PPMMath.sol";
 import { LinkedList } from "../libraries/LinkedList.sol";
 
@@ -28,9 +27,6 @@ import { HorizonStakingBase } from "./HorizonStakingBase.sol";
  * @dev Implements the {IHorizonStakingMain} interface.
  * @dev This is the main Staking contract in The Graph protocol after the Horizon upgrade.
  * It is designed to be deployed as an upgrade to the L2Staking contract from the legacy contracts package.
- * @dev It uses a {HorizonStakingExtension} contract to implement the full {IHorizonStaking} interface through delegatecalls.
- * This is due to the contract size limit on Arbitrum (24kB). The extension contract implements functionality to support
- * the legacy staking functions. It can be eventually removed without affecting the main staking contract.
  * @custom:security-contact Please email security+contracts@thegraph.com if you find any
  * bugs. We may have an active bug bounty program.
  */
@@ -42,9 +38,6 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
     /// @dev Maximum number of simultaneous stake thaw requests (per provision) or undelegations (per delegation)
     uint256 private constant MAX_THAW_REQUESTS = 1_000;
 
-    /// @dev Address of the staking extension contract
-    address private immutable STAKING_EXTENSION_ADDRESS;
-
     /// @dev Minimum amount of delegation.
     uint256 private constant MIN_DELEGATION = 1e18;
 
@@ -79,50 +72,12 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
     /**
      * @notice The staking contract is upgradeable however we still use the constructor to set a few immutable variables
      * @param controller The address of the Graph controller contract
-     * @param stakingExtensionAddress The address of the staking extension contract
      * @param subgraphDataServiceAddress The address of the subgraph data service
      */
     constructor(
         address controller,
-        address stakingExtensionAddress,
         address subgraphDataServiceAddress
-    ) HorizonStakingBase(controller, subgraphDataServiceAddress) {
-        STAKING_EXTENSION_ADDRESS = stakingExtensionAddress;
-    }
-
-    /**
-     * @notice Delegates the current call to the StakingExtension implementation.
-     * @dev This function does not return to its internal call site, it will return directly to the
-     * external caller.
-     */
-    fallback() external {
-        // solhint-disable-previous-line payable-fallback, no-complex-fallback
-        address extensionImpl = STAKING_EXTENSION_ADDRESS;
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            // (a) get free memory pointer
-            let ptr := mload(0x40)
-
-            // (1) copy incoming call data
-            calldatacopy(ptr, 0, calldatasize())
-
-            // (2) forward call to logic contract
-            let result := delegatecall(gas(), extensionImpl, ptr, calldatasize(), 0, 0)
-            let size := returndatasize()
-
-            // (3) retrieve return data
-            returndatacopy(ptr, 0, size)
-
-            // (4) forward return data back to caller
-            switch result
-            case 0 {
-                revert(ptr, size)
-            }
-            default {
-                return(ptr, size)
-            }
-        }
-    }
+    ) HorizonStakingBase(controller, subgraphDataServiceAddress) {}
 
     /*
      * STAKING
@@ -158,6 +113,11 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         _withdraw(msg.sender);
     }
 
+    /// @inheritdoc IHorizonStakingMain
+    function forceWithdraw(address serviceProvider) external override notPaused {
+        _withdraw(serviceProvider);
+    }
+
     /*
      * PROVISIONS
      */
@@ -258,6 +218,11 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         require(prov.createdAt != 0, HorizonStakingInvalidProvision(serviceProvider, verifier));
 
         if ((prov.maxVerifierCutPending != prov.maxVerifierCut) || (prov.thawingPeriodPending != prov.thawingPeriod)) {
+            // Re-validate thawing period in case governor reduced _maxThawingPeriod after staging
+            require(
+                prov.thawingPeriodPending <= _maxThawingPeriod,
+                HorizonStakingInvalidThawingPeriod(prov.thawingPeriodPending, _maxThawingPeriod)
+            );
             prov.maxVerifierCut = prov.maxVerifierCutPending;
             prov.thawingPeriod = prov.thawingPeriodPending;
             emit ProvisionParametersSet(serviceProvider, verifier, prov.maxVerifierCut, prov.thawingPeriod);
@@ -369,33 +334,15 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         address serviceProvider,
         address // deprecated - kept for backwards compatibility
     ) external override notPaused returns (uint256) {
-        // Get the delegation pool of the indexer
-        address delegator = msg.sender;
-        DelegationPoolInternal storage pool = _legacyDelegationPools[serviceProvider];
-        DelegationInternal storage delegation = pool.delegators[delegator];
-
-        // Validation
-        uint256 tokensToWithdraw = 0;
-        uint256 currentEpoch = _graphEpochManager().currentEpoch();
-        if (
-            delegation.__DEPRECATED_tokensLockedUntil > 0 && currentEpoch >= delegation.__DEPRECATED_tokensLockedUntil
-        ) {
-            tokensToWithdraw = delegation.__DEPRECATED_tokensLocked;
-        }
-        require(tokensToWithdraw > 0, HorizonStakingNothingToWithdraw());
-
-        // Reset lock
-        delegation.__DEPRECATED_tokensLocked = 0;
-        delegation.__DEPRECATED_tokensLockedUntil = 0;
-
-        emit StakeDelegatedWithdrawn(serviceProvider, delegator, tokensToWithdraw);
-
-        // -- Interactions --
-
-        // Return tokens to the delegator
-        _graphToken().pushTokens(delegator, tokensToWithdraw);
+        return _withdrawDelegatedLegacy(serviceProvider, msg.sender);
+    }
 
-        return tokensToWithdraw;
+    /// @inheritdoc IHorizonStakingMain
+    function forceWithdrawDelegated(
+        address serviceProvider,
+        address delegator
+    ) external override notPaused returns (uint256) {
+        return _withdrawDelegatedLegacy(serviceProvider, delegator);
     }
 
     /*
@@ -409,33 +356,18 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         uint256 tokensVerifier,
         address verifierDestination
     ) external override notPaused {
-        // TRANSITION PERIOD: remove after the transition period
-        // Check if sender is authorized to slash on the deprecated list
-        if (__DEPRECATED_slashers[msg.sender]) {
-            // Forward call to staking extension
-            // solhint-disable-next-line avoid-low-level-calls
-            (bool success, ) = STAKING_EXTENSION_ADDRESS.delegatecall(
-                abi.encodeCall(
-                    IHorizonStakingExtension.legacySlash,
-                    (serviceProvider, tokens, tokensVerifier, verifierDestination)
-                )
-            );
-            require(success, HorizonStakingLegacySlashFailed());
-            return;
-        }
-
         address verifier = msg.sender;
         Provision storage prov = _provisions[serviceProvider][verifier];
         DelegationPoolInternal storage pool = _getDelegationPool(serviceProvider, verifier);
         uint256 tokensProvisionTotal = prov.tokens + pool.tokens;
         require(tokensProvisionTotal != 0, HorizonStakingNoTokensToSlash());
 
-        uint256 tokensToSlash = MathUtils.min(tokens, tokensProvisionTotal);
+        uint256 tokensToSlash = Math.min(tokens, tokensProvisionTotal);
 
         // Slash service provider first
         // - A portion goes to verifier as reward
         // - A portion gets burned
-        uint256 providerTokensSlashed = MathUtils.min(prov.tokens, tokensToSlash);
+        uint256 providerTokensSlashed = Math.min(prov.tokens, tokensToSlash);
         if (providerTokensSlashed > 0) {
             // Pay verifier reward - must be within the maxVerifierCut percentage
             uint256 maxVerifierTokens = providerTokensSlashed.mulPPM(prov.maxVerifierCut);
@@ -540,12 +472,6 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         emit DelegationSlashingEnabled();
     }
 
-    /// @inheritdoc IHorizonStakingMain
-    function clearThawingPeriod() external override onlyGovernor {
-        __DEPRECATED_thawingPeriod = 0;
-        emit ThawingPeriodCleared();
-    }
-
     /// @inheritdoc IHorizonStakingMain
     function setMaxThawingPeriod(uint64 maxThawingPeriod) external override onlyGovernor {
         _maxThawingPeriod = maxThawingPeriod;
@@ -571,18 +497,29 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
     }
 
     /*
-     * GETTERS
+     * LEGACY
      */
 
     /// @inheritdoc IHorizonStakingMain
-    function getStakingExtension() external view override returns (address) {
-        return STAKING_EXTENSION_ADDRESS;
+    function isAllocation(address allocationID) external view override returns (bool) {
+        return _getLegacyAllocationState(allocationID) != LegacyAllocationState.Null;
     }
 
     /*
      * PRIVATE FUNCTIONS
      */
 
+    /**
+     * @notice Deposit tokens into the service provider stake.
+     * Emits a {HorizonStakeDeposited} event.
+     * @param _serviceProvider The address of the service provider.
+     * @param _tokens The amount of tokens to deposit.
+     */
+    function _stake(address _serviceProvider, uint256 _tokens) internal {
+        _serviceProviders[_serviceProvider].tokensStaked = _serviceProviders[_serviceProvider].tokensStaked + _tokens;
+        emit HorizonStakeDeposited(_serviceProvider, _tokens);
+    }
+
     /**
      * @notice Deposit tokens on the service provider stake, on behalf of the service provider.
      * @dev Pulls tokens from the caller.
@@ -601,12 +538,7 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
 
     /**
      * @notice Move idle stake back to the owner's account.
-     * Stake is removed from the protocol:
-     * - During the transition period it's locked for a period of time before it can be withdrawn
-     *   by calling {withdraw}.
-     * - After the transition period it's immediately withdrawn.
-     * Note that after the transition period if there are tokens still locked they will have to be
-     * withdrawn by calling {withdraw}.
+     * Stake is immediately removed from the protocol.
      * @param _tokens Amount of tokens to unstake
      */
     function _unstake(uint256 _tokens) private {
@@ -616,45 +548,19 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         require(_tokens <= tokensIdle, HorizonStakingInsufficientIdleStake(_tokens, tokensIdle));
 
         ServiceProviderInternal storage sp = _serviceProviders[serviceProvider];
-        uint256 stakedTokens = sp.tokensStaked;
-
-        // This is also only during the transition period: we need
-        // to ensure tokens stay locked after closing legacy allocations.
-        // After sufficient time (56 days?) we should remove the closeAllocation function
-        // and set the thawing period to 0.
-        uint256 lockingPeriod = __DEPRECATED_thawingPeriod;
-        if (lockingPeriod == 0) {
-            sp.tokensStaked = stakedTokens - _tokens;
-            _graphToken().pushTokens(serviceProvider, _tokens);
-            emit HorizonStakeWithdrawn(serviceProvider, _tokens);
-        } else {
-            // Before locking more tokens, withdraw any unlocked ones if possible
-            if (sp.__DEPRECATED_tokensLocked != 0 && block.number >= sp.__DEPRECATED_tokensLockedUntil) {
-                _withdraw(serviceProvider);
-            }
-            // TRANSITION PERIOD: remove after the transition period
-            // Take into account period averaging for multiple unstake requests
-            if (sp.__DEPRECATED_tokensLocked > 0) {
-                lockingPeriod = MathUtils.weightedAverageRoundingUp(
-                    MathUtils.diffOrZero(sp.__DEPRECATED_tokensLockedUntil, block.number), // Remaining thawing period
-                    sp.__DEPRECATED_tokensLocked, // Weighted by remaining unstaked tokens
-                    lockingPeriod, // Thawing period
-                    _tokens // Weighted by new tokens to unstake
-                );
-            }
+        sp.tokensStaked -= _tokens;
 
-            // Update balances
-            sp.__DEPRECATED_tokensLocked = sp.__DEPRECATED_tokensLocked + _tokens;
-            sp.__DEPRECATED_tokensLockedUntil = block.number + lockingPeriod;
-            emit HorizonStakeLocked(serviceProvider, sp.__DEPRECATED_tokensLocked, sp.__DEPRECATED_tokensLockedUntil);
-        }
+        _graphToken().pushTokens(serviceProvider, _tokens);
+        emit HorizonStakeWithdrawn(serviceProvider, _tokens);
     }
 
     /**
      * @notice Withdraw service provider tokens once the thawing period (initiated by {unstake}) has passed.
      * All thawed tokens are withdrawn.
-     * @dev TRANSITION PERIOD: This is only needed during the transition period while we still have
-     * a global lock. After that, unstake() will automatically withdraw.
+     * This function is for backwards compatibility with the legacy staking contract.
+     * It only allows withdrawing tokens unstaked before horizon upgrade.
+     * @dev This function can't be removed in case there are still pre-horizon unstakes.
+     * Note that it's assumed unstakes have already passed their thawing period.
      * @param _serviceProvider Address of service provider to withdraw funds from
      */
     function _withdraw(address _serviceProvider) private {
@@ -662,10 +568,6 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         ServiceProviderInternal storage sp = _serviceProviders[_serviceProvider];
         uint256 tokensToWithdraw = sp.__DEPRECATED_tokensLocked;
         require(tokensToWithdraw != 0, HorizonStakingInvalidZeroTokens());
-        require(
-            block.number >= sp.__DEPRECATED_tokensLockedUntil,
-            HorizonStakingStillThawing(sp.__DEPRECATED_tokensLockedUntil)
-        );
 
         // Reset locked tokens
         sp.__DEPRECATED_tokensLocked = 0;
@@ -685,8 +587,6 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
      * service, where the data service is the verifier.
      * This function can be called by the service provider or by an operator authorized by the provider
      * for this specific verifier.
-     * @dev TRANSITION PERIOD: During the transition period, only the subgraph data service can be used as a verifier. This
-     * prevents an escape hatch for legacy allocation stake.
      * @param _serviceProvider The service provider address
      * @param _tokens The amount of tokens that will be locked and slashable
      * @param _verifier The verifier address for which the tokens are provisioned (who will be able to slash the tokens)
@@ -701,11 +601,6 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         uint64 _thawingPeriod
     ) private {
         require(_tokens > 0, HorizonStakingInvalidZeroTokens());
-        // TRANSITION PERIOD: Remove this after the transition period - it prevents an early escape hatch for legacy allocations
-        require(
-            _verifier == SUBGRAPH_DATA_SERVICE_ADDRESS || __DEPRECATED_thawingPeriod == 0,
-            HorizonStakingInvalidVerifier(_verifier)
-        );
         require(PPMMath.isValidPPM(_maxVerifierCut), HorizonStakingInvalidMaxVerifierCut(_maxVerifierCut));
         require(
             _thawingPeriod <= _maxThawingPeriod,
@@ -958,8 +853,8 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
      * @dev The parameter `nThawRequests` can be set to a non zero value to fulfill a specific number of thaw
      * requests in the event that fulfilling all of them results in a gas limit error. Otherwise, the function
      * will attempt to fulfill all thaw requests until the first one that is not yet expired is found.
-     * @dev If the delegation pool was completely slashed before withdrawing, calling this function will fulfill
-     * the thaw requests with an amount equal to zero.
+     * @dev If the delegation pool was completely slashed before withdrawing, calling this function will revert
+     * until the pool state is repaired with {IHorizonStakingMain-addToDelegationPool}.
      * @param _serviceProvider The service provider address
      * @param _verifier The verifier address
      * @param _newServiceProvider The new service provider address
@@ -1231,6 +1126,39 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         emit OperatorSet(msg.sender, _verifier, _operator, _allowed);
     }
 
+    /**
+     * @notice Withdraw legacy undelegated tokens for a delegator.
+     * @dev This function handles pre-Horizon undelegations where tokens are locked
+     * in the legacy delegation pool.
+     * @param _serviceProvider The service provider address
+     * @param _delegator The delegator address
+     * @return The amount of tokens withdrawn
+     */
+    function _withdrawDelegatedLegacy(address _serviceProvider, address _delegator) private returns (uint256) {
+        DelegationPoolInternal storage pool = _legacyDelegationPools[_serviceProvider];
+        DelegationInternal storage delegation = pool.delegators[_delegator];
+
+        // Validation
+        uint256 tokensToWithdraw = 0;
+        if (delegation.__DEPRECATED_tokensLockedUntil > 0) {
+            tokensToWithdraw = delegation.__DEPRECATED_tokensLocked;
+        }
+        require(tokensToWithdraw > 0, HorizonStakingNothingToWithdraw());
+
+        // Reset lock
+        delegation.__DEPRECATED_tokensLocked = 0;
+        delegation.__DEPRECATED_tokensLockedUntil = 0;
+
+        emit StakeDelegatedWithdrawn(_serviceProvider, _delegator, tokensToWithdraw);
+
+        // -- Interactions --
+
+        // Return tokens to the delegator
+        _graphToken().pushTokens(_delegator, tokensToWithdraw);
+
+        return tokensToWithdraw;
+    }
+
     /**
      * @notice Check if an operator is authorized for the caller on a specific verifier / data service.
      * @dev Note that this function handles the special case where the verifier is the subgraph data service,
@@ -1251,6 +1179,25 @@ contract HorizonStaking is HorizonStakingBase, IHorizonStakingMain {
         }
     }
 
+    /**
+     * @notice Return the current state of a legacy allocation
+     * @param _allocationID Allocation identifier
+     * @return LegacyAllocationState enum with the state of the allocation
+     */
+    function _getLegacyAllocationState(address _allocationID) private view returns (LegacyAllocationState) {
+        LegacyAllocation storage alloc = __DEPRECATED_allocations[_allocationID];
+
+        if (alloc.indexer == address(0)) {
+            return LegacyAllocationState.Null;
+        }
+
+        if (alloc.createdAtEpoch != 0 && alloc.closedAtEpoch == 0) {
+            return LegacyAllocationState.Active;
+        }
+
+        return LegacyAllocationState.Closed;
+    }
+
     /**
      * @notice Determines the correct callback function for `deleteItem` based on the request type.
      * @param _requestType The type of thaw request (Provision or Delegation).
diff --git a/packages/horizon/contracts/staking/HorizonStakingBase.sol b/packages/horizon/contracts/staking/HorizonStakingBase.sol
index 615de4994..af92c1ce7 100644
--- a/packages/horizon/contracts/staking/HorizonStakingBase.sol
+++ b/packages/horizon/contracts/staking/HorizonStakingBase.sol
@@ -10,7 +10,7 @@ import { IHorizonStakingBase } from "@graphprotocol/interfaces/contracts/horizon
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 
-import { MathUtils } from "../libraries/MathUtils.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
 import { LinkedList } from "../libraries/LinkedList.sol";
 
 import { Multicall } from "@openzeppelin/contracts/utils/Multicall.sol";
@@ -23,9 +23,7 @@ import { HorizonStakingV1Storage } from "./HorizonStakingStorage.sol";
  * @author Edge & Node
  * @notice This contract is the base staking contract implementing storage getters for both internal
  * and external use.
- * @dev Implementation of the {IHorizonStakingBase} interface.
- * @dev It's meant to be inherited by the {HorizonStaking} and {HorizonStakingExtension}
- * contracts so some internal functions are also included here.
+ * @dev Implementation of the {IHorizonStakingBase} interface, meant to be inherited by {HorizonStaking}.
  * @custom:security-contact Please email security+contracts@thegraph.com if you find any
  * bugs. We may have an active bug bounty program.
  */
@@ -54,6 +52,11 @@ abstract contract HorizonStakingBase is
         SUBGRAPH_DATA_SERVICE_ADDRESS = subgraphDataServiceAddress;
     }
 
+    /// @inheritdoc IHorizonStakingBase
+    function getSubgraphService() external view override returns (address) {
+        return SUBGRAPH_DATA_SERVICE_ADDRESS;
+    }
+
     /// @inheritdoc IHorizonStakingBase
     /// @dev Removes deprecated fields from the return value.
     function getServiceProvider(address serviceProvider) external view override returns (ServiceProvider memory) {
@@ -127,7 +130,7 @@ abstract contract HorizonStakingBase is
         uint256 tokensAvailableDelegated = _getDelegatedTokensAvailable(serviceProvider, verifier);
 
         uint256 tokensDelegatedMax = tokensAvailableProvider * (uint256(delegationRatio));
-        uint256 tokensDelegatedCapacity = MathUtils.min(tokensAvailableDelegated, tokensDelegatedMax);
+        uint256 tokensDelegatedCapacity = Math.min(tokensAvailableDelegated, tokensDelegatedMax);
 
         return tokensAvailableProvider + tokensDelegatedCapacity;
     }
@@ -179,14 +182,26 @@ abstract contract HorizonStakingBase is
         }
 
         uint256 thawedTokens = 0;
-        Provision storage prov = _provisions[serviceProvider][verifier];
-        uint256 tokensThawing = prov.tokensThawing;
-        uint256 sharesThawing = prov.sharesThawing;
+        uint256 tokensThawing;
+        uint256 sharesThawing;
+        uint256 thawingNonce;
+
+        if (requestType == ThawRequestType.Provision) {
+            Provision storage prov = _provisions[serviceProvider][verifier];
+            tokensThawing = prov.tokensThawing;
+            sharesThawing = prov.sharesThawing;
+            thawingNonce = prov.thawingNonce;
+        } else {
+            DelegationPoolInternal storage pool = _getDelegationPool(serviceProvider, verifier);
+            tokensThawing = pool.tokensThawing;
+            sharesThawing = pool.sharesThawing;
+            thawingNonce = pool.thawingNonce;
+        }
 
         bytes32 thawRequestId = thawRequestList.head;
         while (thawRequestId != bytes32(0)) {
             ThawRequest storage thawRequest = _getThawRequest(requestType, thawRequestId);
-            if (thawRequest.thawingNonce == prov.thawingNonce) {
+            if (thawRequest.thawingNonce == thawingNonce) {
                 if (thawRequest.thawingUntil <= block.timestamp) {
                     // sharesThawing cannot be zero if there is a valid thaw request so the next division is safe
                     uint256 tokens = (thawRequest.shares * tokensThawing) / sharesThawing;
@@ -218,31 +233,18 @@ abstract contract HorizonStakingBase is
         return _delegationSlashingEnabled;
     }
 
-    /**
-     * @notice Deposit tokens into the service provider stake.
-     * @dev TRANSITION PERIOD: After transition period move to IHorizonStakingMain. Temporarily it
-     * needs to be here since it's used by both {HorizonStaking} and {HorizonStakingExtension}.
-     *
-     * Emits a {HorizonStakeDeposited} event.
-     * @param _serviceProvider The address of the service provider.
-     * @param _tokens The amount of tokens to deposit.
-     */
-    function _stake(address _serviceProvider, uint256 _tokens) internal {
-        _serviceProviders[_serviceProvider].tokensStaked = _serviceProviders[_serviceProvider].tokensStaked + _tokens;
-        emit HorizonStakeDeposited(_serviceProvider, _tokens);
-    }
-
     /**
      * @notice Gets the service provider's idle stake which is the stake that is not being
      * used for any provision. Note that this only includes service provider's self stake.
-     * @dev Note that the calculation considers tokens that were locked in the legacy staking contract.
-     * @dev TRANSITION PERIOD: update the calculation after the transition period.
+     * @dev Note that the calculation:
+     * - assumes tokens that were allocated to a subgraph deployment pre-horizon were all unallocated.
+     * - considers tokens that were locked in the legacy staking contract and never withdrawn.
+     *
      * @param _serviceProvider The address of the service provider.
      * @return The amount of tokens that are idle.
      */
     function _getIdleStake(address _serviceProvider) internal view returns (uint256) {
         uint256 tokensUsed = _serviceProviders[_serviceProvider].tokensProvisioned +
-            _serviceProviders[_serviceProvider].__DEPRECATED_tokensAllocated +
             _serviceProviders[_serviceProvider].__DEPRECATED_tokensLocked;
         uint256 tokensStaked = _serviceProviders[_serviceProvider].tokensStaked;
         return tokensStaked > tokensUsed ? tokensStaked - tokensUsed : 0;
diff --git a/packages/horizon/contracts/staking/HorizonStakingExtension.sol b/packages/horizon/contracts/staking/HorizonStakingExtension.sol
deleted file mode 100644
index 3258381b2..000000000
--- a/packages/horizon/contracts/staking/HorizonStakingExtension.sol
+++ /dev/null
@@ -1,485 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-pragma solidity 0.8.27 || 0.8.33;
-
-// TODO: Re-enable and fix issues when publishing a new version
-// solhint-disable function-max-lines, gas-strict-inequalities
-// forge-lint: disable-start(mixed-case-variable, mixed-case-function, unwrapped-modifier-logic)
-
-import { ICuration } from "@graphprotocol/interfaces/contracts/contracts/curation/ICuration.sol";
-import { IGraphToken } from "@graphprotocol/interfaces/contracts/contracts/token/IGraphToken.sol";
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
-import { IRewardsIssuer } from "@graphprotocol/interfaces/contracts/contracts/rewards/IRewardsIssuer.sol";
-
-import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
-import { MathUtils } from "../libraries/MathUtils.sol";
-import { ExponentialRebates } from "./libraries/ExponentialRebates.sol";
-import { PPMMath } from "../libraries/PPMMath.sol";
-
-import { HorizonStakingBase } from "./HorizonStakingBase.sol";
-
-/**
- * @title Horizon Staking extension contract
- * @author Edge & Node
- * @notice The {HorizonStakingExtension} contract implements the legacy functionality required to support the transition
- * to the Horizon Staking contract. It allows indexers to close allocations and collect pending query fees, but it
- * does not allow for the creation of new allocations. This should allow indexers to migrate to a subgraph data service
- * without losing rewards or having service interruptions.
- * @dev TRANSITION PERIOD: Once the transition period passes this contract can be removed (note that an upgrade to the
- * RewardsManager will also be required). It's expected the transition period to last for at least a full allocation cycle
- * (28 epochs).
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-contract HorizonStakingExtension is HorizonStakingBase, IHorizonStakingExtension {
-    using TokenUtils for IGraphToken;
-    using PPMMath for uint256;
-
-    /**
-     * @dev Check if the caller is the slasher.
-     */
-    modifier onlySlasher() {
-        require(__DEPRECATED_slashers[msg.sender], "!slasher");
-        _;
-    }
-
-    /**
-     * @notice The staking contract is upgradeable however we still use the constructor to set a few immutable variables
-     * @param controller The address of the Graph controller contract
-     * @param subgraphDataServiceAddress The address of the subgraph data service
-     */
-    constructor(
-        address controller,
-        address subgraphDataServiceAddress
-    ) HorizonStakingBase(controller, subgraphDataServiceAddress) {}
-
-    /// @inheritdoc IHorizonStakingExtension
-    function closeAllocation(address allocationID, bytes32 poi) external override notPaused {
-        _closeAllocation(allocationID, poi);
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function collect(uint256 tokens, address allocationID) external override notPaused {
-        // Allocation identifier validation
-        require(allocationID != address(0), "!alloc");
-
-        // Allocation must exist
-        AllocationState allocState = _getAllocationState(allocationID);
-        require(allocState != AllocationState.Null, "!collect");
-
-        // If the query fees are zero, we don't want to revert
-        // but we also don't need to do anything, so just return
-        if (tokens == 0) {
-            return;
-        }
-
-        Allocation storage alloc = __DEPRECATED_allocations[allocationID];
-        bytes32 subgraphDeploymentID = alloc.subgraphDeploymentID;
-
-        uint256 queryFees = tokens; // Tokens collected from the channel
-        uint256 protocolTax = 0; // Tokens burnt as protocol tax
-        uint256 curationFees = 0; // Tokens distributed to curators as curation fees
-        uint256 queryRebates = 0; // Tokens to distribute to indexer
-        uint256 delegationRewards = 0; // Tokens to distribute to delegators
-
-        {
-            // -- Pull tokens from the sender --
-            _graphToken().pullTokens(msg.sender, queryFees);
-
-            // -- Collect protocol tax --
-            protocolTax = _collectTax(queryFees, __DEPRECATED_protocolPercentage);
-            queryFees = queryFees - protocolTax;
-
-            // -- Collect curation fees --
-            // Only if the subgraph deployment is curated
-            curationFees = _collectCurationFees(subgraphDeploymentID, queryFees, __DEPRECATED_curationPercentage);
-            queryFees = queryFees - curationFees;
-
-            // -- Process rebate reward --
-            // Using accumulated fees and subtracting previously distributed rebates
-            // allows for multiple vouchers to be collected while following the rebate formula
-            alloc.collectedFees = alloc.collectedFees + queryFees;
-
-            // No rebates if indexer has no stake or if lambda is zero
-            uint256 newRebates = (alloc.tokens == 0 || __DEPRECATED_lambdaNumerator == 0)
-                ? 0
-                : ExponentialRebates.exponentialRebates(
-                    alloc.collectedFees,
-                    alloc.tokens,
-                    __DEPRECATED_alphaNumerator,
-                    __DEPRECATED_alphaDenominator,
-                    __DEPRECATED_lambdaNumerator,
-                    __DEPRECATED_lambdaDenominator
-                );
-
-            //  -- Ensure rebates to distribute are within bounds --
-            // Indexers can become under or over rebated if rebate parameters (alpha, lambda)
-            // change between successive collect calls for the same allocation
-
-            // Ensure rebates to distribute are not negative (indexer is over-rebated)
-            queryRebates = MathUtils.diffOrZero(newRebates, alloc.distributedRebates);
-
-            // Ensure rebates to distribute are not greater than available (indexer is under-rebated)
-            queryRebates = MathUtils.min(queryRebates, queryFees);
-
-            // -- Burn rebates remanent --
-            _graphToken().burnTokens(queryFees - queryRebates);
-
-            // -- Distribute rebates --
-            if (queryRebates > 0) {
-                alloc.distributedRebates = alloc.distributedRebates + queryRebates;
-
-                // -- Collect delegation rewards into the delegation pool --
-                delegationRewards = _collectDelegationQueryRewards(alloc.indexer, queryRebates);
-                queryRebates = queryRebates - delegationRewards;
-
-                // -- Transfer or restake rebates --
-                _sendRewards(queryRebates, alloc.indexer, __DEPRECATED_rewardsDestination[alloc.indexer] == address(0));
-            }
-        }
-
-        emit RebateCollected(
-            msg.sender,
-            alloc.indexer,
-            subgraphDeploymentID,
-            allocationID,
-            _graphEpochManager().currentEpoch(),
-            tokens,
-            protocolTax,
-            curationFees,
-            queryFees,
-            queryRebates,
-            delegationRewards
-        );
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function legacySlash(
-        address indexer,
-        uint256 tokens,
-        uint256 reward,
-        address beneficiary
-    ) external override onlySlasher notPaused {
-        ServiceProviderInternal storage indexerStake = _serviceProviders[indexer];
-
-        // Only able to slash a non-zero number of tokens
-        require(tokens > 0, "!tokens");
-
-        // Rewards comes from tokens slashed balance
-        require(tokens >= reward, "rewards>slash");
-
-        // Cannot slash stake of an indexer without any or enough stake
-        require(indexerStake.tokensStaked > 0, "!stake");
-        require(tokens <= indexerStake.tokensStaked, "slash>stake");
-
-        // Validate beneficiary of slashed tokens
-        require(beneficiary != address(0), "!beneficiary");
-
-        // Slashing tokens that are already provisioned would break provision accounting, we need to limit
-        // the slash amount. This can be compensated for, by slashing with the main slash function if needed.
-        uint256 slashableStake = indexerStake.tokensStaked - indexerStake.tokensProvisioned;
-        if (slashableStake == 0) {
-            emit StakeSlashed(indexer, 0, 0, beneficiary);
-            return;
-        }
-        if (tokens > slashableStake) {
-            reward = (reward * slashableStake) / tokens;
-            tokens = slashableStake;
-        }
-
-        // Slashing more tokens than freely available (over allocation condition)
-        // Unlock locked tokens to avoid the indexer to withdraw them
-        uint256 tokensUsed = indexerStake.__DEPRECATED_tokensAllocated + indexerStake.__DEPRECATED_tokensLocked;
-        uint256 tokensAvailable = tokensUsed > indexerStake.tokensStaked ? 0 : indexerStake.tokensStaked - tokensUsed;
-        if (tokens > tokensAvailable && indexerStake.__DEPRECATED_tokensLocked > 0) {
-            uint256 tokensOverAllocated = tokens - tokensAvailable;
-            uint256 tokensToUnlock = MathUtils.min(tokensOverAllocated, indexerStake.__DEPRECATED_tokensLocked);
-            indexerStake.__DEPRECATED_tokensLocked = indexerStake.__DEPRECATED_tokensLocked - tokensToUnlock;
-            if (indexerStake.__DEPRECATED_tokensLocked == 0) {
-                indexerStake.__DEPRECATED_tokensLockedUntil = 0;
-            }
-        }
-
-        // Remove tokens to slash from the stake
-        indexerStake.tokensStaked = indexerStake.tokensStaked - tokens;
-
-        // -- Interactions --
-
-        // Set apart the reward for the beneficiary and burn remaining slashed stake
-        _graphToken().burnTokens(tokens - reward);
-
-        // Give the beneficiary a reward for slashing
-        _graphToken().pushTokens(beneficiary, reward);
-
-        emit StakeSlashed(indexer, tokens, reward, beneficiary);
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function isAllocation(address allocationID) external view override returns (bool) {
-        return _getAllocationState(allocationID) != AllocationState.Null;
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function getAllocation(address allocationID) external view override returns (Allocation memory) {
-        return __DEPRECATED_allocations[allocationID];
-    }
-
-    /// @inheritdoc IRewardsIssuer
-    function getAllocationData(
-        address allocationID
-    ) external view override returns (bool, address, bytes32, uint256, uint256, uint256) {
-        Allocation memory allo = __DEPRECATED_allocations[allocationID];
-        bool isActive = _getAllocationState(allocationID) == AllocationState.Active;
-        return (isActive, allo.indexer, allo.subgraphDeploymentID, allo.tokens, allo.accRewardsPerAllocatedToken, 0);
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function getAllocationState(address allocationID) external view override returns (AllocationState) {
-        return _getAllocationState(allocationID);
-    }
-
-    /// @inheritdoc IRewardsIssuer
-    function getSubgraphAllocatedTokens(bytes32 subgraphDeploymentID) external view override returns (uint256) {
-        return __DEPRECATED_subgraphAllocations[subgraphDeploymentID];
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function getIndexerStakedTokens(address indexer) external view override returns (uint256) {
-        return _serviceProviders[indexer].tokensStaked;
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function getSubgraphService() external view override returns (address) {
-        return SUBGRAPH_DATA_SERVICE_ADDRESS;
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function hasStake(address indexer) external view override returns (bool) {
-        return _serviceProviders[indexer].tokensStaked > 0;
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function __DEPRECATED_getThawingPeriod() external view returns (uint64) {
-        return __DEPRECATED_thawingPeriod;
-    }
-
-    /// @inheritdoc IHorizonStakingExtension
-    function isOperator(address operator, address serviceProvider) public view override returns (bool) {
-        return _legacyOperatorAuth[serviceProvider][operator];
-    }
-
-    /**
-     * @notice Collect tax to burn for an amount of tokens
-     * @param _tokens Total tokens received used to calculate the amount of tax to collect
-     * @param _percentage Percentage of tokens to burn as tax
-     * @return Amount of tax charged
-     */
-    function _collectTax(uint256 _tokens, uint256 _percentage) private returns (uint256) {
-        uint256 tax = _tokens.mulPPMRoundUp(_percentage);
-        _graphToken().burnTokens(tax); // Burn tax if any
-        return tax;
-    }
-
-    /**
-     * @notice Triggers an update of rewards due to a change in allocations
-     * @param _subgraphDeploymentID Subgraph deployment updated
-     */
-    function _updateRewards(bytes32 _subgraphDeploymentID) private {
-        _graphRewardsManager().onSubgraphAllocationUpdate(_subgraphDeploymentID);
-    }
-
-    /**
-     * @notice Assign rewards for the closed allocation to indexer and delegators
-     * @param _allocationID Allocation
-     * @param _indexer Address of the indexer that did the allocation
-     */
-    function _distributeRewards(address _allocationID, address _indexer) private {
-        // Automatically triggers update of rewards snapshot as allocation will change
-        // after this call. Take rewards mint tokens for the Staking contract to distribute
-        // between indexer and delegators
-        uint256 totalRewards = _graphRewardsManager().takeRewards(_allocationID);
-        if (totalRewards == 0) {
-            return;
-        }
-
-        // Calculate delegation rewards and add them to the delegation pool
-        uint256 delegationRewards = _collectDelegationIndexingRewards(_indexer, totalRewards);
-        uint256 indexerRewards = totalRewards - delegationRewards;
-
-        // Send the indexer rewards
-        _sendRewards(indexerRewards, _indexer, __DEPRECATED_rewardsDestination[_indexer] == address(0));
-    }
-
-    /**
-     * @notice Send rewards to the appropriate destination
-     * @param _tokens Number of rewards tokens
-     * @param _beneficiary Address of the beneficiary of rewards
-     * @param _restake Whether to restake or not
-     */
-    function _sendRewards(uint256 _tokens, address _beneficiary, bool _restake) private {
-        if (_tokens == 0) return;
-
-        if (_restake) {
-            // Restake to place fees into the indexer stake
-            _stake(_beneficiary, _tokens);
-        } else {
-            // Transfer funds to the beneficiary's designated rewards destination if set
-            address destination = __DEPRECATED_rewardsDestination[_beneficiary];
-            _graphToken().pushTokens(destination == address(0) ? _beneficiary : destination, _tokens);
-        }
-    }
-
-    /**
-     * @notice Close an allocation and free the staked tokens
-     * @param _allocationID The allocation identifier
-     * @param _poi Proof of indexing submitted for the allocated period
-     */
-    function _closeAllocation(address _allocationID, bytes32 _poi) private {
-        // Allocation must exist and be active
-        AllocationState allocState = _getAllocationState(_allocationID);
-        require(allocState == AllocationState.Active, "!active");
-
-        // Get allocation
-        Allocation memory alloc = __DEPRECATED_allocations[_allocationID];
-
-        // Validate that an allocation cannot be closed before one epoch
-        alloc.closedAtEpoch = _graphEpochManager().currentEpoch();
-        uint256 epochs = MathUtils.diffOrZero(alloc.closedAtEpoch, alloc.createdAtEpoch);
-
-        // Indexer or operator can close an allocation
-        // Anyone is allowed to close ONLY under two concurrent conditions
-        // - After maxAllocationEpochs passed
-        // - When the allocation is for non-zero amount of tokens
-        bool isIndexerOrOperator = msg.sender == alloc.indexer || isOperator(msg.sender, alloc.indexer);
-        if (epochs <= __DEPRECATED_maxAllocationEpochs || alloc.tokens == 0) {
-            require(isIndexerOrOperator, "!auth");
-        }
-
-        // -- Rewards Distribution --
-
-        // Process non-zero-allocation rewards tracking
-        if (alloc.tokens > 0) {
-            // Distribute rewards if proof of indexing was presented by the indexer or operator
-            if (isIndexerOrOperator && _poi != 0 && epochs > 0) {
-                _distributeRewards(_allocationID, alloc.indexer);
-            } else {
-                _updateRewards(alloc.subgraphDeploymentID);
-            }
-
-            // Free allocated tokens from use
-            _serviceProviders[alloc.indexer].__DEPRECATED_tokensAllocated =
-                _serviceProviders[alloc.indexer].__DEPRECATED_tokensAllocated - alloc.tokens;
-
-            // Track total allocations per subgraph
-            // Used for rewards calculations
-            __DEPRECATED_subgraphAllocations[alloc.subgraphDeploymentID] =
-                __DEPRECATED_subgraphAllocations[alloc.subgraphDeploymentID] - alloc.tokens;
-        }
-
-        // Close the allocation
-        // Note that this breaks CEI pattern. We update after the rewards distribution logic as it expects the allocation
-        // to still be active. There shouldn't be reentrancy risk here as all internal calls are to trusted contracts.
-        __DEPRECATED_allocations[_allocationID].closedAtEpoch = alloc.closedAtEpoch;
-
-        emit AllocationClosed(
-            alloc.indexer,
-            alloc.subgraphDeploymentID,
-            alloc.closedAtEpoch,
-            alloc.tokens,
-            _allocationID,
-            msg.sender,
-            _poi,
-            !isIndexerOrOperator
-        );
-    }
-
-    /**
-     * @notice Collect the delegation rewards for query fees
-     * @dev This function will assign the collected fees to the delegation pool
-     * @param _indexer Indexer to which the tokens to distribute are related
-     * @param _tokens Total tokens received used to calculate the amount of fees to collect
-     * @return Amount of delegation rewards
-     */
-    function _collectDelegationQueryRewards(address _indexer, uint256 _tokens) private returns (uint256) {
-        uint256 delegationRewards = 0;
-        DelegationPoolInternal storage pool = _legacyDelegationPools[_indexer];
-        if (pool.tokens > 0 && uint256(pool.__DEPRECATED_queryFeeCut).isValidPPM()) {
-            uint256 indexerCut = uint256(pool.__DEPRECATED_queryFeeCut).mulPPM(_tokens);
-            delegationRewards = _tokens - indexerCut;
-            pool.tokens = pool.tokens + delegationRewards;
-        }
-        return delegationRewards;
-    }
-
-    /**
-     * @notice Collect the delegation rewards for indexing
-     * @dev This function will assign the collected fees to the delegation pool
-     * @param _indexer Indexer to which the tokens to distribute are related
-     * @param _tokens Total tokens received used to calculate the amount of fees to collect
-     * @return Amount of delegation rewards
-     */
-    function _collectDelegationIndexingRewards(address _indexer, uint256 _tokens) private returns (uint256) {
-        uint256 delegationRewards = 0;
-        DelegationPoolInternal storage pool = _legacyDelegationPools[_indexer];
-        if (pool.tokens > 0 && uint256(pool.__DEPRECATED_indexingRewardCut).isValidPPM()) {
-            uint256 indexerCut = uint256(pool.__DEPRECATED_indexingRewardCut).mulPPM(_tokens);
-            delegationRewards = _tokens - indexerCut;
-            pool.tokens = pool.tokens + delegationRewards;
-        }
-        return delegationRewards;
-    }
-
-    /**
-     * @notice Collect the curation fees for a subgraph deployment from an amount of tokens
-     * @dev This function transfer curation fees to the Curation contract by calling Curation.collect
-     * @param _subgraphDeploymentID Subgraph deployment to which the curation fees are related
-     * @param _tokens Total tokens received used to calculate the amount of fees to collect
-     * @param _curationCut Percentage of tokens to collect as fees
-     * @return Amount of curation fees
-     */
-    function _collectCurationFees(
-        bytes32 _subgraphDeploymentID,
-        uint256 _tokens,
-        uint256 _curationCut
-    ) private returns (uint256) {
-        if (_tokens == 0) {
-            return 0;
-        }
-
-        ICuration curation = _graphCuration();
-        bool isCurationEnabled = _curationCut > 0 && address(curation) != address(0);
-
-        if (isCurationEnabled && curation.isCurated(_subgraphDeploymentID)) {
-            uint256 curationFees = _tokens.mulPPMRoundUp(_curationCut);
-            if (curationFees > 0) {
-                // Transfer and call collect()
-                // This function transfer tokens to a trusted protocol contracts
-                // Then we call collect() to do the transfer Bookkeeping
-                _graphRewardsManager().onSubgraphSignalUpdate(_subgraphDeploymentID);
-                _graphToken().pushTokens(address(curation), curationFees);
-                curation.collect(_subgraphDeploymentID, curationFees);
-            }
-            return curationFees;
-        }
-        return 0;
-    }
-
-    /**
-     * @notice Return the current state of an allocation
-     * @param _allocationID Allocation identifier
-     * @return AllocationState enum with the state of the allocation
-     */
-    function _getAllocationState(address _allocationID) private view returns (AllocationState) {
-        Allocation storage alloc = __DEPRECATED_allocations[_allocationID];
-
-        if (alloc.indexer == address(0)) {
-            return AllocationState.Null;
-        }
-
-        if (alloc.createdAtEpoch != 0 && alloc.closedAtEpoch == 0) {
-            return AllocationState.Active;
-        }
-
-        return AllocationState.Closed;
-    }
-}
diff --git a/packages/horizon/contracts/staking/HorizonStakingStorage.sol b/packages/horizon/contracts/staking/HorizonStakingStorage.sol
index 1469d27a2..7f4818725 100644
--- a/packages/horizon/contracts/staking/HorizonStakingStorage.sol
+++ b/packages/horizon/contracts/staking/HorizonStakingStorage.sol
@@ -5,7 +5,6 @@ pragma solidity 0.8.27 || 0.8.33;
 // TODO: Re-enable and fix issues when publishing a new version
 // forge-lint: disable-start(mixed-case-variable)
 
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
 import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
@@ -64,8 +63,9 @@ abstract contract HorizonStakingV1Storage {
     mapping(address serviceProvider => IHorizonStakingTypes.ServiceProviderInternal details) internal _serviceProviders;
 
     /// @dev Allocation details.
-    /// Deprecated, now applied on the subgraph data service
-    mapping(address allocationId => IHorizonStakingExtension.Allocation allocation) internal __DEPRECATED_allocations;
+    /// Deprecated, now applied on the subgraph data service.
+    /// Kept for storage compatibility and to check for allocation id collisions.
+    mapping(address allocationId => IHorizonStakingTypes.LegacyAllocation allocation) internal __DEPRECATED_allocations;
 
     /// @dev Subgraph allocations, tracks the tokens allocated to a subgraph deployment
     /// Deprecated, now applied on the SubgraphService
@@ -92,7 +92,7 @@ abstract contract HorizonStakingV1Storage {
     uint32 internal __DEPRECATED_delegationParametersCooldown;
 
     /// @dev Time in epochs a delegator needs to wait to withdraw delegated stake
-    /// Deprecated, now only enforced during a transition period
+    /// Deprecated, enforced by each data service as needed.
     uint32 internal __DEPRECATED_delegationUnbondingPeriod;
 
     /// @dev Percentage of tokens to tax a delegation deposit
diff --git a/packages/horizon/contracts/staking/libraries/ExponentialRebates.sol b/packages/horizon/contracts/staking/libraries/ExponentialRebates.sol
deleted file mode 100644
index 9e2544533..000000000
--- a/packages/horizon/contracts/staking/libraries/ExponentialRebates.sol
+++ /dev/null
@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-pragma solidity 0.8.27 || 0.8.33;
-
-// TODO: Re-enable and fix issues when publishing a new version
-// forge-lint: disable-start(unsafe-typecast)
-
-import { LibFixedMath } from "../../libraries/LibFixedMath.sol";
-
-/**
- * @title ExponentialRebates library
- * @author Edge & Node
- * @notice A library to compute query fee rebates using an exponential formula
- * @dev This is only used for backwards compatibility in HorizonStaking, and should
- * be removed after the transition period.
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-library ExponentialRebates {
-    /// @dev Maximum value of the exponent for which to compute the exponential before clamping to zero.
-    uint32 private constant MAX_EXPONENT = 15;
-
-    /**
-     * @notice The exponential formula used to compute fee-based rewards for staking pools in a given epoch
-     * @dev This function does not perform bounds checking on the inputs, but the following conditions
-     * need to be true:
-     *    0 <= alphaNumerator / alphaDenominator <= 1
-     *    0 < lambdaNumerator / lambdaDenominator
-     * The exponential rebates function has the form:
-     * `(1 - alpha * exp ^ (-lambda * stake / fees)) * fees`
-     * @param fees Fees generated by indexer in the staking pool
-     * @param stake Stake attributed to the indexer in the staking pool
-     * @param alphaNumerator Numerator of `alpha` in the rebates function
-     * @param alphaDenominator Denominator of `alpha` in the rebates function
-     * @param lambdaNumerator Numerator of `lambda` in the rebates function
-     * @param lambdaDenominator Denominator of `lambda` in the rebates function
-     * @return rewards Rewards owed to the staking pool
-     */
-    function exponentialRebates(
-        uint256 fees,
-        uint256 stake,
-        uint32 alphaNumerator,
-        uint32 alphaDenominator,
-        uint32 lambdaNumerator,
-        uint32 lambdaDenominator
-    ) external pure returns (uint256) {
-        // If alpha is zero indexer gets 100% fees rebate
-        int256 alpha = LibFixedMath.toFixed(int32(alphaNumerator), int32(alphaDenominator));
-        if (alpha == 0) {
-            return fees;
-        }
-
-        // No rebates if no fees...
-        if (fees == 0) {
-            return 0;
-        }
-
-        // Award all fees as rebate if the exponent is too large
-        int256 lambda = LibFixedMath.toFixed(int32(lambdaNumerator), int32(lambdaDenominator));
-        int256 exponent = LibFixedMath.mulDiv(lambda, int256(stake), int256(fees));
-        if (LibFixedMath.toInteger(exponent) > int256(uint256(MAX_EXPONENT))) {
-            return fees;
-        }
-
-        // Compute `1 - alpha * exp ^(-exponent)`
-        int256 factor = LibFixedMath.sub(LibFixedMath.one(), LibFixedMath.mul(alpha, LibFixedMath.exp(-exponent)));
-
-        // Weight the fees by the factor
-        return LibFixedMath.uintMul(factor, fees);
-    }
-}
diff --git a/packages/horizon/contracts/utilities/GraphDirectory.sol b/packages/horizon/contracts/utilities/GraphDirectory.sol
index 0534ca3c7..14355b36d 100644
--- a/packages/horizon/contracts/utilities/GraphDirectory.sol
+++ b/packages/horizon/contracts/utilities/GraphDirectory.sol
@@ -13,8 +13,6 @@ import { IRewardsManager } from "@graphprotocol/interfaces/contracts/contracts/r
 import { ITokenGateway } from "@graphprotocol/interfaces/contracts/contracts/arbitrum/ITokenGateway.sol";
 import { IGraphProxyAdmin } from "@graphprotocol/interfaces/contracts/contracts/upgrades/IGraphProxyAdmin.sol";
 
-import { ICuration } from "@graphprotocol/interfaces/contracts/contracts/curation/ICuration.sol";
-
 /**
  * @title GraphDirectory contract
  * @author Edge & Node
@@ -55,13 +53,6 @@ abstract contract GraphDirectory {
     /// @notice The Graph Proxy Admin contract address
     IGraphProxyAdmin private immutable GRAPH_PROXY_ADMIN;
 
-    // -- Legacy Graph contracts --
-    // These are required for backwards compatibility on HorizonStakingExtension
-    // TRANSITION PERIOD: remove these once HorizonStakingExtension is removed
-
-    /// @notice The Curation contract address
-    ICuration private immutable GRAPH_CURATION;
-
     /**
      * @notice Emitted when the GraphDirectory is initialized
      * @param graphToken The Graph Token contract address
@@ -73,7 +64,6 @@ abstract contract GraphDirectory {
      * @param graphRewardsManager The Rewards Manager contract address
      * @param graphTokenGateway The Token Gateway contract address
      * @param graphProxyAdmin The Graph Proxy Admin contract address
-     * @param graphCuration The Curation contract address
      */
     event GraphDirectoryInitialized(
         address indexed graphToken,
@@ -84,8 +74,7 @@ abstract contract GraphDirectory {
         address graphEpochManager,
         address graphRewardsManager,
         address graphTokenGateway,
-        address graphProxyAdmin,
-        address graphCuration
+        address graphProxyAdmin
     );
 
     /**
@@ -116,7 +105,6 @@ abstract contract GraphDirectory {
         GRAPH_REWARDS_MANAGER = IRewardsManager(_getContractFromController("RewardsManager"));
         GRAPH_TOKEN_GATEWAY = ITokenGateway(_getContractFromController("GraphTokenGateway"));
         GRAPH_PROXY_ADMIN = IGraphProxyAdmin(_getContractFromController("GraphProxyAdmin"));
-        GRAPH_CURATION = ICuration(_getContractFromController("Curation"));
 
         emit GraphDirectoryInitialized(
             address(GRAPH_TOKEN),
@@ -127,8 +115,7 @@ abstract contract GraphDirectory {
             address(GRAPH_EPOCH_MANAGER),
             address(GRAPH_REWARDS_MANAGER),
             address(GRAPH_TOKEN_GATEWAY),
-            address(GRAPH_PROXY_ADMIN),
-            address(GRAPH_CURATION)
+            address(GRAPH_PROXY_ADMIN)
         );
     }
 
@@ -204,14 +191,6 @@ abstract contract GraphDirectory {
         return GRAPH_PROXY_ADMIN;
     }
 
-    /**
-     * @notice Get the Curation contract
-     * @return The Curation contract
-     */
-    function _graphCuration() internal view returns (ICuration) {
-        return GRAPH_CURATION;
-    }
-
     /**
      * @notice Get a contract address from the controller
      * @dev Requirements:
diff --git a/packages/horizon/foundry.toml b/packages/horizon/foundry.toml
index 5c800d92c..ecc629b51 100644
--- a/packages/horizon/foundry.toml
+++ b/packages/horizon/foundry.toml
@@ -14,3 +14,4 @@ no_match_coverage = "(^test/|/mocks/)"
 # Lint configuration
 [lint]
 ignore = ["contracts/mocks/imports.sol"]
+exclude_lints = ["mixed-case-function", "mixed-case-variable"]
diff --git a/packages/horizon/hardhat.config.ts b/packages/horizon/hardhat.config.ts
index d9b1334e4..a0d6f20b3 100644
--- a/packages/horizon/hardhat.config.ts
+++ b/packages/horizon/hardhat.config.ts
@@ -18,13 +18,26 @@ const baseConfig = hardhatBaseConfig(require)
 const config: HardhatUserConfig = {
   ...baseConfig,
   solidity: {
-    version: '0.8.27',
-    settings: {
-      optimizer: {
-        enabled: true,
-        runs: 20,
+    compilers: [
+      {
+        version: '0.8.27',
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 20,
+          },
+        },
       },
-    },
+      {
+        version: '0.8.33',
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 20,
+          },
+        },
+      },
+    ],
   },
   etherscan: {
     ...baseConfig.etherscan,
diff --git a/packages/horizon/ignition/modules/core/HorizonStaking.ts b/packages/horizon/ignition/modules/core/HorizonStaking.ts
index c4044b0af..a7bec9076 100644
--- a/packages/horizon/ignition/modules/core/HorizonStaking.ts
+++ b/packages/horizon/ignition/modules/core/HorizonStaking.ts
@@ -3,8 +3,6 @@ import GraphProxyAdminArtifact from '@graphprotocol/contracts/artifacts/contract
 import { buildModule } from '@nomicfoundation/hardhat-ignition/modules'
 
 import HorizonStakingArtifact from '../../../build/contracts/contracts/staking/HorizonStaking.sol/HorizonStaking.json'
-import HorizonStakingExtensionArtifact from '../../../build/contracts/contracts/staking/HorizonStakingExtension.sol/HorizonStakingExtension.json'
-import ExponentialRebatesArtifact from '../../../build/contracts/contracts/staking/libraries/ExponentialRebates.sol/ExponentialRebates.json'
 import GraphPeripheryModule, { MigratePeripheryModule } from '../periphery/periphery'
 import { upgradeGraphProxy } from '../proxy/GraphProxy'
 import { deployImplementation } from '../proxy/implementation'
@@ -17,25 +15,11 @@ export default buildModule('HorizonStaking', (m) => {
   const subgraphServiceAddress = m.getParameter('subgraphServiceAddress')
   const maxThawingPeriod = m.getParameter('maxThawingPeriod')
 
-  // Deploy HorizonStakingExtension - requires periphery and proxies to be registered in the controller
-  const ExponentialRebates = m.library('ExponentialRebates', ExponentialRebatesArtifact)
-  const HorizonStakingExtension = m.contract(
-    'HorizonStakingExtension',
-    HorizonStakingExtensionArtifact,
-    [Controller, subgraphServiceAddress],
-    {
-      libraries: {
-        ExponentialRebates: ExponentialRebates,
-      },
-      after: [GraphPeripheryModule, HorizonProxiesModule],
-    },
-  )
-
   // Deploy HorizonStaking implementation
   const HorizonStakingImplementation = deployImplementation(m, {
     name: 'HorizonStaking',
     artifact: HorizonStakingArtifact,
-    constructorArgs: [Controller, HorizonStakingExtension, subgraphServiceAddress],
+    constructorArgs: [Controller, subgraphServiceAddress],
   })
 
   // Upgrade proxy to implementation contract
@@ -61,24 +45,11 @@ export const MigrateHorizonStakingDeployerModule = buildModule('HorizonStakingDe
 
   const HorizonStakingProxy = m.contractAt('HorizonStakingProxy', GraphProxyArtifact, horizonStakingAddress)
 
-  // Deploy HorizonStakingExtension - requires periphery and proxies to be registered in the controller
-  const ExponentialRebates = m.library('ExponentialRebates', ExponentialRebatesArtifact)
-  const HorizonStakingExtension = m.contract(
-    'HorizonStakingExtension',
-    HorizonStakingExtensionArtifact,
-    [Controller, subgraphServiceAddress],
-    {
-      libraries: {
-        ExponentialRebates: ExponentialRebates,
-      },
-    },
-  )
-
   // Deploy HorizonStaking implementation
   const HorizonStakingImplementation = deployImplementation(m, {
     name: 'HorizonStaking',
     artifact: HorizonStakingArtifact,
-    constructorArgs: [Controller, HorizonStakingExtension, subgraphServiceAddress],
+    constructorArgs: [Controller, subgraphServiceAddress],
   })
 
   return { HorizonStakingProxy, HorizonStakingImplementation }
diff --git a/packages/horizon/package.json b/packages/horizon/package.json
index f030d63b0..175f9031b 100644
--- a/packages/horizon/package.json
+++ b/packages/horizon/package.json
@@ -23,7 +23,7 @@
     "lint": "pnpm lint:ts; pnpm lint:sol; pnpm lint:forge; pnpm lint:md; pnpm lint:json",
     "lint:ts": "eslint --fix --cache '**/*.{js,ts,cjs,mjs,jsx,tsx}'; prettier -w --cache --log-level warn '**/*.{js,ts,cjs,mjs,jsx,tsx}'",
     "lint:sol": "solhint --fix --noPrompt --noPoster 'contracts/**/*.sol'; prettier -w --cache --log-level warn '**/*.sol'",
-    "lint:forge": "forge lint",
+    "lint:forge": "forge lint contracts/",
     "lint:md": "markdownlint --fix --ignore-path ../../.gitignore '**/*.md'; prettier -w --cache --log-level warn '**/*.md'",
     "lint:json": "prettier -w --cache --log-level warn '**/*.json'",
     "clean": "rm -rf build dist cache cache_forge typechain-types",
diff --git a/packages/horizon/scripts/integration b/packages/horizon/scripts/integration
index baf48cf5e..c92a85ee8 100755
--- a/packages/horizon/scripts/integration
+++ b/packages/horizon/scripts/integration
@@ -100,12 +100,6 @@ npx hardhat deploy:migrate --network localhost --horizon-config integration --st
 # Step 4 - Governor
 npx hardhat deploy:migrate --network localhost --horizon-config integration --step 4 --patch-config --account-index 1 --hide-banner --standalone
 
-# Run integration tests - During transition period
-npx hardhat test:integration --phase during-transition-period --network localhost
-
-# Clear thawing period
-npx hardhat transition:clear-thawing --network localhost
-
 # Run integration tests - After transition period
 npx hardhat test:integration --phase after-transition-period --network localhost
 
diff --git a/packages/horizon/tasks/test/integration.ts b/packages/horizon/tasks/test/integration.ts
index 95b2ea230..bba9fa1c2 100644
--- a/packages/horizon/tasks/test/integration.ts
+++ b/packages/horizon/tasks/test/integration.ts
@@ -4,13 +4,9 @@ import { TASK_TEST } from 'hardhat/builtin-tasks/task-names'
 import { task } from 'hardhat/config'
 
 task('test:integration', 'Runs all integration tests')
-  .addParam(
-    'phase',
-    'Test phase to run: "during-transition-period", "after-transition-period", "after-delegation-slashing-enabled"',
-  )
+  .addParam('phase', 'Test phase to run: "after-transition-period", "after-delegation-slashing-enabled"')
   .setAction(async (taskArgs, hre) => {
     // Get test files for each phase
-    const duringTransitionPeriodFiles = await glob('test/integration/during-transition-period/**/*.{js,ts}')
     const afterTransitionPeriodFiles = await glob('test/integration/after-transition-period/**/*.{js,ts}')
     const afterDelegationSlashingEnabledFiles = await glob(
       'test/integration/after-delegation-slashing-enabled/**/*.{js,ts}',
@@ -20,9 +16,6 @@ task('test:integration', 'Runs all integration tests')
     printBanner(taskArgs.phase, 'INTEGRATION TESTS: ')
 
     switch (taskArgs.phase) {
-      case 'during-transition-period':
-        await hre.run(TASK_TEST, { testFiles: duringTransitionPeriodFiles })
-        break
       case 'after-transition-period':
         await hre.run(TASK_TEST, { testFiles: afterTransitionPeriodFiles })
         break
@@ -31,7 +24,7 @@ task('test:integration', 'Runs all integration tests')
         break
       default:
         throw new Error(
-          'Invalid phase. Must be "during-transition-period", "after-transition-period", "after-delegation-slashing-enabled", or "all"',
+          'Invalid phase. Must be "after-transition-period", "after-delegation-slashing-enabled", or "all"',
         )
     }
   })
diff --git a/packages/horizon/tasks/transitions/thawing-period.ts b/packages/horizon/tasks/transitions/thawing-period.ts
deleted file mode 100644
index e21e2bad2..000000000
--- a/packages/horizon/tasks/transitions/thawing-period.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { requireLocalNetwork } from '@graphprotocol/toolshed/hardhat'
-import { printBanner } from '@graphprotocol/toolshed/utils'
-import { task, types } from 'hardhat/config'
-
-task('transition:clear-thawing', 'Clears the thawing period in HorizonStaking')
-  .addOptionalParam('governorIndex', 'Derivation path index for the governor account', 1, types.int)
-  .addFlag('skipNetworkCheck', 'Skip the network check (use with caution)')
-  .setAction(async (taskArgs, hre) => {
-    printBanner('CLEARING THAWING PERIOD')
-
-    if (!taskArgs.skipNetworkCheck) {
-      requireLocalNetwork(hre)
-    }
-
-    const graph = hre.graph()
-    const governor = await graph.accounts.getGovernor(taskArgs.governorIndex)
-    const horizonStaking = graph.horizon.contracts.HorizonStaking
-
-    console.log('Clearing thawing period...')
-    await horizonStaking.connect(governor).clearThawingPeriod()
-    console.log('Thawing period cleared')
-  })
diff --git a/packages/horizon/test/deployment/HorizonStaking.test.ts b/packages/horizon/test/deployment/HorizonStaking.test.ts
index fed2af75f..f60d92b52 100644
--- a/packages/horizon/test/deployment/HorizonStaking.test.ts
+++ b/packages/horizon/test/deployment/HorizonStaking.test.ts
@@ -1,5 +1,5 @@
 import { loadConfig } from '@graphprotocol/toolshed/hardhat'
-import { assert, expect } from 'chai'
+import { expect } from 'chai'
 import hre from 'hardhat'
 
 import { graphProxyTests } from './lib/GraphProxy.test'
@@ -27,16 +27,6 @@ describe('HorizonStaking', function () {
     expect(delegationSlashingEnabled).to.equal(false)
   })
 
-  testIf(4)('should set a non zero thawing period', async function () {
-    if (process.env.IGNITION_DEPLOYMENT_TYPE === 'protocol') {
-      assert.fail('Deployment type "protocol": no historical state available')
-    }
-    const thawingPeriod = await HorizonStaking.__DEPRECATED_getThawingPeriod()
-    expect(thawingPeriod).to.not.equal(0)
-  })
-
-  it.skip('should set the right staking extension address')
-
   testIf(4)('should set the right subgraph data service address', async function () {
     const subgraphDataServiceAddress = await HorizonStaking.getSubgraphService()
     expect(subgraphDataServiceAddress).to.equal(config.$global.subgraphServiceAddress)
diff --git a/packages/horizon/test/integration/during-transition-period/delegator.test.ts b/packages/horizon/test/integration/during-transition-period/delegator.test.ts
deleted file mode 100644
index 352599f18..000000000
--- a/packages/horizon/test/integration/during-transition-period/delegator.test.ts
+++ /dev/null
@@ -1,143 +0,0 @@
-import { ZERO_ADDRESS } from '@graphprotocol/toolshed'
-import { delegators } from '@graphprotocol/toolshed/fixtures'
-import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import hre from 'hardhat'
-import { ethers } from 'hardhat'
-
-describe('Delegator', () => {
-  let snapshotId: string
-
-  const thawingPeriod = 2419200n // 28 days
-
-  // Subgraph service address is not set for integration tests
-  const subgraphServiceAddress = '0x0000000000000000000000000000000000000000'
-
-  const graph = hre.graph()
-  const horizonStaking = graph.horizon.contracts.HorizonStaking
-  const graphToken = graph.horizon.contracts.L2GraphToken
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Existing Protocol Users', () => {
-    describe('User undelegated before horizon was deployed', () => {
-      let indexer: HardhatEthersSigner
-      let delegator: HardhatEthersSigner
-      let tokens: bigint
-
-      before(async () => {
-        const delegatorFixture = delegators[2]
-        const delegationFixture = delegatorFixture.delegations[0]
-
-        // Verify delegator is undelegated
-        expect(delegatorFixture.undelegate).to.be.true
-
-        // Get signers
-        indexer = await ethers.getSigner(delegationFixture.indexerAddress)
-        delegator = await ethers.getSigner(delegatorFixture.address)
-
-        // Get tokens
-        tokens = delegationFixture.tokens
-      })
-
-      it('should be able to withdraw their tokens after the thawing period', async () => {
-        // Get the thawing period
-        const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-        // Mine remaining blocks to complete thawing period
-        for (let i = 0; i < Number(thawingPeriod) + 1; i++) {
-          await ethers.provider.send('evm_mine', [])
-        }
-
-        // Get delegator balance before withdrawing
-        const balanceBefore = await graphToken.balanceOf(delegator.address)
-
-        // Withdraw tokens
-        await horizonStaking.connect(delegator)['withdrawDelegated(address,address)'](indexer.address, ZERO_ADDRESS)
-
-        // Get delegator balance after withdrawing
-        const balanceAfter = await graphToken.balanceOf(delegator.address)
-
-        // Expected balance after is the balance before plus the tokens minus the 0.5% delegation tax
-        const expectedBalanceAfter = balanceBefore + tokens - (tokens * 5000n) / 1000000n
-
-        // Verify tokens are withdrawn
-        expect(balanceAfter).to.equal(expectedBalanceAfter)
-      })
-
-      it('should revert if the thawing period has not passed', async () => {
-        // Withdraw tokens
-        await expect(
-          horizonStaking.connect(delegator)['withdrawDelegated(address,address)'](indexer.address, ZERO_ADDRESS),
-        ).to.be.revertedWithCustomError(horizonStaking, 'HorizonStakingNothingToWithdraw')
-      })
-    })
-
-    describe('Transition period is over', () => {
-      let governor: HardhatEthersSigner
-      let indexer: HardhatEthersSigner
-      let delegator: HardhatEthersSigner
-      let tokens: bigint
-
-      before(async () => {
-        const delegatorFixture = delegators[0]
-        const delegationFixture = delegatorFixture.delegations[0]
-
-        // Get signers
-        governor = await graph.accounts.getGovernor()
-        indexer = await ethers.getSigner(delegationFixture.indexerAddress)
-        delegator = await ethers.getSigner(delegatorFixture.address)
-
-        // Get tokens
-        tokens = delegationFixture.tokens
-      })
-
-      it('should be able to undelegate during transition period and withdraw after transition period', async () => {
-        // Get delegator's delegation
-        const delegation = await horizonStaking.getDelegation(
-          indexer.address,
-          subgraphServiceAddress,
-          delegator.address,
-        )
-
-        // Undelegate tokens
-        await horizonStaking
-          .connect(delegator)
-          ['undelegate(address,address,uint256)'](indexer.address, subgraphServiceAddress, delegation.shares)
-
-        // Wait for thawing period
-        await ethers.provider.send('evm_increaseTime', [Number(thawingPeriod) + 1])
-        await ethers.provider.send('evm_mine', [])
-
-        // Clear thawing period
-        await horizonStaking.connect(governor).clearThawingPeriod()
-
-        // Get delegator balance before withdrawing
-        const balanceBefore = await graphToken.balanceOf(delegator.address)
-
-        // Withdraw tokens
-        await horizonStaking
-          .connect(delegator)
-          ['withdrawDelegated(address,address,uint256)'](indexer.address, ZERO_ADDRESS, BigInt(1))
-
-        // Get delegator balance after withdrawing
-        const balanceAfter = await graphToken.balanceOf(delegator.address)
-
-        // Expected balance after is the balance before plus the tokens minus the 0.5% delegation tax
-        // because the delegation was before the horizon upgrade, after the upgrade there is no tax
-        const expectedBalanceAfter = balanceBefore + tokens - (tokens * 5000n) / 1000000n
-
-        // Verify tokens are withdrawn
-        expect(balanceAfter).to.equal(expectedBalanceAfter)
-      })
-    })
-  })
-})
diff --git a/packages/horizon/test/integration/during-transition-period/multicall.test.ts b/packages/horizon/test/integration/during-transition-period/multicall.test.ts
deleted file mode 100644
index 948cd8f5f..000000000
--- a/packages/horizon/test/integration/during-transition-period/multicall.test.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-import { ONE_MILLION, PaymentTypes } from '@graphprotocol/toolshed'
-import { setGRTBalance } from '@graphprotocol/toolshed/hardhat'
-import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import hre from 'hardhat'
-import { ethers } from 'hardhat'
-
-describe('Service Provider', () => {
-  let snapshotId: string
-
-  const maxVerifierCut = 50_000n
-  const thawingPeriod = 2419200n
-
-  const graph = hre.graph()
-  const horizonStaking = graph.horizon.contracts.HorizonStaking
-  const graphToken = graph.horizon.contracts.L2GraphToken
-
-  const subgraphServiceAddress = '0x0000000000000000000000000000000000000000'
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('New Protocol Users', () => {
-    let serviceProvider: HardhatEthersSigner
-
-    before(async () => {
-      ;[, , serviceProvider] = await graph.accounts.getTestAccounts()
-      await setGRTBalance(graph.provider, graphToken.target, serviceProvider.address, ONE_MILLION)
-    })
-
-    it('should allow multicalling stake+provision calls', async () => {
-      const tokensToStake = ethers.parseEther('1000')
-      const tokensToProvision = ethers.parseEther('100')
-
-      // check state before
-      const beforeProvision = await horizonStaking.getProvision(serviceProvider.address, subgraphServiceAddress)
-      expect(beforeProvision.tokens).to.equal(0)
-      expect(beforeProvision.maxVerifierCut).to.equal(0)
-      expect(beforeProvision.thawingPeriod).to.equal(0)
-      expect(beforeProvision.createdAt).to.equal(0)
-
-      // multicall
-      await graphToken.connect(serviceProvider).approve(horizonStaking.target, tokensToStake)
-      const stakeCalldata = horizonStaking.interface.encodeFunctionData('stake', [tokensToStake])
-      const provisionCalldata = horizonStaking.interface.encodeFunctionData('provision', [
-        serviceProvider.address,
-        subgraphServiceAddress,
-        tokensToProvision,
-        maxVerifierCut,
-        thawingPeriod,
-      ])
-      await horizonStaking.connect(serviceProvider).multicall([stakeCalldata, provisionCalldata])
-
-      // check state after
-      const block = await graph.provider.getBlock('latest')
-      const afterProvision = await horizonStaking.getProvision(serviceProvider.address, subgraphServiceAddress)
-      expect(afterProvision.tokens).to.equal(tokensToProvision)
-      expect(afterProvision.maxVerifierCut).to.equal(maxVerifierCut)
-      expect(afterProvision.thawingPeriod).to.equal(thawingPeriod)
-      expect(afterProvision.createdAt).to.equal(block?.timestamp)
-    })
-
-    it('should allow multicalling delegation parameter set calls', async () => {
-      // check state before
-      const beforeIndexingRewards = await horizonStaking.getDelegationFeeCut(
-        serviceProvider.address,
-        subgraphServiceAddress,
-        PaymentTypes.IndexingRewards,
-      )
-      const beforeQueryFee = await horizonStaking.getDelegationFeeCut(
-        serviceProvider.address,
-        subgraphServiceAddress,
-        PaymentTypes.QueryFee,
-      )
-      expect(beforeIndexingRewards).to.equal(0)
-      expect(beforeQueryFee).to.equal(0)
-
-      // multicall
-      const indexingRewardsCalldata = horizonStaking.interface.encodeFunctionData('setDelegationFeeCut', [
-        serviceProvider.address,
-        subgraphServiceAddress,
-        PaymentTypes.IndexingRewards,
-        10_000n,
-      ])
-      const queryFeeCalldata = horizonStaking.interface.encodeFunctionData('setDelegationFeeCut', [
-        serviceProvider.address,
-        subgraphServiceAddress,
-        PaymentTypes.QueryFee,
-        12_345n,
-      ])
-      await horizonStaking.connect(serviceProvider).multicall([indexingRewardsCalldata, queryFeeCalldata])
-
-      // check state after
-      const afterIndexingRewards = await horizonStaking.getDelegationFeeCut(
-        serviceProvider.address,
-        subgraphServiceAddress,
-        PaymentTypes.IndexingRewards,
-      )
-      const afterQueryFee = await horizonStaking.getDelegationFeeCut(
-        serviceProvider.address,
-        subgraphServiceAddress,
-        PaymentTypes.QueryFee,
-      )
-      expect(afterIndexingRewards).to.equal(10_000n)
-      expect(afterQueryFee).to.equal(12_345n)
-    })
-  })
-})
diff --git a/packages/horizon/test/integration/during-transition-period/operator.test.ts b/packages/horizon/test/integration/during-transition-period/operator.test.ts
deleted file mode 100644
index ab5b26ebf..000000000
--- a/packages/horizon/test/integration/during-transition-period/operator.test.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { generatePOI } from '@graphprotocol/toolshed'
-import { indexers } from '@graphprotocol/toolshed/fixtures'
-import { getEventData } from '@graphprotocol/toolshed/hardhat'
-import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import hre from 'hardhat'
-import { ethers } from 'hardhat'
-
-describe('Operator', () => {
-  let snapshotId: string
-
-  // Subgraph service address is not set for integration tests
-  const subgraphServiceAddress = '0x0000000000000000000000000000000000000000'
-
-  const graph = hre.graph()
-  const horizonStaking = graph.horizon.contracts.HorizonStaking
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Existing Protocol Users', () => {
-    let indexer: HardhatEthersSigner
-    let operator: HardhatEthersSigner
-    let allocationID: string
-    let allocationTokens: bigint
-    let delegationIndexingCut: number
-
-    before(async () => {
-      const indexerFixture = indexers[0]
-      const allocationFixture = indexerFixture.allocations[0]
-
-      // Get signers
-      indexer = await ethers.getSigner(indexerFixture.address)
-      ;[operator] = await graph.accounts.getTestAccounts()
-
-      // Get allocation details
-      allocationID = allocationFixture.allocationID
-      allocationTokens = allocationFixture.tokens
-      delegationIndexingCut = indexerFixture.indexingRewardCut
-
-      // Set the operator
-      await horizonStaking.connect(indexer).setOperator(subgraphServiceAddress, operator.address, true)
-    })
-
-    it('should allow the operator to close an open legacy allocation and collect rewards', async () => {
-      // Use a non-zero POI
-      const poi = generatePOI('poi')
-      const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-      // Get delegation pool before closing allocation
-      const delegationPoolBefore = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-      const delegationPoolTokensBefore = delegationPoolBefore.tokens
-
-      // Mine blocks to simulate time passing
-      const halfThawingPeriod = Number(thawingPeriod) / 2
-      for (let i = 0; i < halfThawingPeriod; i++) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Get idle stake before closing allocation
-      const idleStakeBefore = await horizonStaking.getIdleStake(indexer.address)
-
-      // Close allocation
-      const tx = await horizonStaking.connect(operator).closeAllocation(allocationID, poi)
-      const eventData = await getEventData(
-        tx,
-        'event HorizonRewardsAssigned(address indexed indexer, address indexed allocationID, uint256 amount)',
-      )
-      const rewards = eventData[2]
-
-      // Verify rewards are not zero
-      expect(rewards).to.not.equal(0, 'Rewards were not transferred to service provider')
-
-      // Verify rewards minus delegation cut are restaked
-      const idleStakeAfter = await horizonStaking.getIdleStake(indexer.address)
-      const idleStakeRewardsTokens = (rewards * BigInt(delegationIndexingCut)) / 1000000n
-      expect(idleStakeAfter).to.equal(
-        idleStakeBefore + allocationTokens + idleStakeRewardsTokens,
-        'Rewards were not restaked',
-      )
-
-      // Verify delegators cut is added to delegation pool
-      const delegationPool = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-      const delegationPoolTokensAfter = delegationPool.tokens
-      const delegationRewardsTokens = rewards - idleStakeRewardsTokens
-      expect(delegationPoolTokensAfter).to.equal(
-        delegationPoolTokensBefore + delegationRewardsTokens,
-        'Delegators cut was not added to delegation pool',
-      )
-    })
-  })
-})
diff --git a/packages/horizon/test/integration/during-transition-period/permissionless.test.ts b/packages/horizon/test/integration/during-transition-period/permissionless.test.ts
deleted file mode 100644
index a7d13e302..000000000
--- a/packages/horizon/test/integration/during-transition-period/permissionless.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { generatePOI } from '@graphprotocol/toolshed'
-import { indexers } from '@graphprotocol/toolshed/fixtures'
-import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import hre from 'hardhat'
-import { ethers } from 'hardhat'
-
-describe('Permissionless', () => {
-  let snapshotId: string
-
-  const graph = hre.graph()
-  const horizonStaking = graph.horizon.contracts.HorizonStaking
-  const epochManager = graph.horizon.contracts.EpochManager
-  const subgraphServiceAddress = '0x0000000000000000000000000000000000000000'
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('After max allocation epochs', () => {
-    let indexer: HardhatEthersSigner
-    let anySigner: HardhatEthersSigner
-    let allocationID: string
-    let allocationTokens: bigint
-
-    before(async () => {
-      // Get signers
-      indexer = await ethers.getSigner(indexers[0].address)
-      ;[anySigner] = await graph.accounts.getTestAccounts()
-
-      // ensure anySigner is not operator for the indexer
-      await horizonStaking.connect(indexer).setOperator(subgraphServiceAddress, anySigner.address, false)
-
-      // Get allocation details
-      allocationID = indexers[0].allocations[0].allocationID
-      allocationTokens = indexers[0].allocations[0].tokens
-    })
-
-    it('should allow any user to close an allocation after 28 epochs', async () => {
-      // Get indexer's idle stake before closing allocation
-      const idleStakeBefore = await horizonStaking.getIdleStake(indexer.address)
-
-      // Mine blocks to simulate 28 epochs passing
-      const startingEpoch = await epochManager.currentEpoch()
-      while ((await epochManager.currentEpoch()) - startingEpoch < 28) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Close allocation
-      const poi = generatePOI('poi')
-      await horizonStaking.connect(anySigner).closeAllocation(allocationID, poi)
-
-      // Get indexer's idle stake after closing allocation
-      const idleStakeAfter = await horizonStaking.getIdleStake(indexer.address)
-
-      // Verify allocation tokens were added to indexer's idle stake but no rewards were collected
-      expect(idleStakeAfter).to.be.equal(idleStakeBefore + allocationTokens)
-    })
-  })
-})
diff --git a/packages/horizon/test/integration/during-transition-period/service-provider.test.ts b/packages/horizon/test/integration/during-transition-period/service-provider.test.ts
deleted file mode 100644
index 0be3c6112..000000000
--- a/packages/horizon/test/integration/during-transition-period/service-provider.test.ts
+++ /dev/null
@@ -1,521 +0,0 @@
-import { generatePOI, ONE_MILLION } from '@graphprotocol/toolshed'
-import { indexers } from '@graphprotocol/toolshed/fixtures'
-import { getEventData, setGRTBalance } from '@graphprotocol/toolshed/hardhat'
-import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import hre from 'hardhat'
-import { ethers } from 'hardhat'
-
-describe('Service Provider', () => {
-  let snapshotId: string
-
-  const graph = hre.graph()
-  const { stake, collect } = graph.horizon.actions
-  const horizonStaking = graph.horizon.contracts.HorizonStaking
-  const graphToken = graph.horizon.contracts.L2GraphToken
-
-  // Subgraph service address is not set for integration tests
-  const subgraphServiceAddress = '0x0000000000000000000000000000000000000000'
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('New Protocol Users', () => {
-    let serviceProvider: HardhatEthersSigner
-    let tokensToStake = ethers.parseEther('1000')
-
-    before(async () => {
-      ;[, , serviceProvider] = await graph.accounts.getTestAccounts()
-      await setGRTBalance(graph.provider, graphToken.target, serviceProvider.address, ONE_MILLION)
-
-      // Stake tokens to service provider
-      await stake(serviceProvider, [tokensToStake])
-    })
-
-    it('should allow service provider to unstake and withdraw after thawing period', async () => {
-      const tokensToUnstake = ethers.parseEther('100')
-      const balanceBefore = await graphToken.balanceOf(serviceProvider.address)
-
-      // First unstake request
-      await horizonStaking.connect(serviceProvider).unstake(tokensToUnstake)
-
-      // During transition period, tokens are locked by thawing period
-      const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-      // Mine remaining blocks to complete thawing period
-      for (let i = 0; i < Number(thawingPeriod) + 1; i++) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Now we can withdraw
-      await horizonStaking.connect(serviceProvider).withdraw()
-      const balanceAfter = await graphToken.balanceOf(serviceProvider.address)
-
-      expect(balanceAfter).to.equal(
-        balanceBefore + tokensToUnstake,
-        'Tokens were not transferred back to service provider',
-      )
-    })
-
-    it('should handle multiple unstake requests correctly', async () => {
-      // Make multiple unstake requests
-      const request1 = ethers.parseEther('50')
-      const request2 = ethers.parseEther('75')
-
-      const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-      // First unstake request
-      await horizonStaking.connect(serviceProvider).unstake(request1)
-
-      // Mine half of thawing period blocks
-      const halfThawingPeriod = Number(thawingPeriod) / 2
-      for (let i = 0; i < halfThawingPeriod; i++) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Second unstake request
-      await horizonStaking.connect(serviceProvider).unstake(request2)
-
-      // Mine remaining blocks to complete first unstake thawing period
-      for (let i = 0; i < halfThawingPeriod; i++) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Check that withdraw reverts since thawing period is not complete
-      await expect(horizonStaking.connect(serviceProvider).withdraw()).to.be.revertedWithCustomError(
-        horizonStaking,
-        'HorizonStakingStillThawing',
-      )
-
-      // Mine remaining blocks to complete thawing period
-      for (let i = 0; i < halfThawingPeriod + 1; i++) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Get balance before withdrawing
-      const balanceBefore = await graphToken.balanceOf(serviceProvider.address)
-
-      // Withdraw all thawed tokens
-      await horizonStaking.connect(serviceProvider).withdraw()
-
-      // Verify all tokens are withdrawn and transferred back to service provider
-      const balanceAfter = await graphToken.balanceOf(serviceProvider.address)
-      expect(balanceAfter).to.equal(
-        balanceBefore + request1 + request2,
-        'Tokens were not transferred back to service provider',
-      )
-    })
-
-    describe('Transition period is over', () => {
-      let governor: HardhatEthersSigner
-      let tokensToUnstake: bigint
-
-      before(async () => {
-        // Get governor
-        governor = await graph.accounts.getGovernor()
-
-        // Set tokens
-        tokensToStake = ethers.parseEther('100000')
-        tokensToUnstake = ethers.parseEther('10000')
-      })
-
-      it('should be able to withdraw tokens that were unstaked during transition period', async () => {
-        // Stake tokens
-        await stake(serviceProvider, [tokensToStake])
-
-        // Unstake tokens
-        await horizonStaking.connect(serviceProvider).unstake(tokensToUnstake)
-
-        // Get balance before withdrawing
-        const balanceBefore = await graphToken.balanceOf(serviceProvider.address)
-
-        // Get thawing period
-        const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-        // Clear thawing period
-        await horizonStaking.connect(governor).clearThawingPeriod()
-
-        // Mine blocks to complete thawing period
-        for (let i = 0; i < Number(thawingPeriod) + 1; i++) {
-          await ethers.provider.send('evm_mine', [])
-        }
-
-        // Withdraw tokens
-        await horizonStaking.connect(serviceProvider).withdraw()
-
-        // Get balance after withdrawing
-        const balanceAfter = await graphToken.balanceOf(serviceProvider.address)
-        expect(balanceAfter).to.equal(
-          balanceBefore + tokensToUnstake,
-          'Tokens were not transferred back to service provider',
-        )
-      })
-
-      it('should be able to unstake tokens without a thawing period', async () => {
-        // Stake tokens
-        await stake(serviceProvider, [tokensToStake])
-
-        // Clear thawing period
-        await horizonStaking.connect(governor).clearThawingPeriod()
-
-        // Get balance before withdrawing
-        const balanceBefore = await graphToken.balanceOf(serviceProvider.address)
-
-        // Unstake tokens
-        await horizonStaking.connect(serviceProvider).unstake(tokensToUnstake)
-
-        // Get balance after withdrawing
-        const balanceAfter = await graphToken.balanceOf(serviceProvider.address)
-        expect(balanceAfter).to.equal(
-          balanceBefore + tokensToUnstake,
-          'Tokens were not transferred back to service provider',
-        )
-      })
-    })
-  })
-
-  describe('Existing Protocol Users', () => {
-    let indexer: HardhatEthersSigner
-    let tokensUnstaked: bigint
-
-    before(async () => {
-      const indexerFixture = indexers[0]
-      indexer = await ethers.getSigner(indexerFixture.address)
-      tokensUnstaked = indexerFixture.tokensToUnstake || 0n
-
-      await setGRTBalance(graph.provider, graphToken.target, indexer.address, ONE_MILLION)
-    })
-
-    it('should allow service provider to withdraw their locked tokens after thawing period passes', async () => {
-      // Get balance before withdrawing
-      const balanceBefore = await graphToken.balanceOf(indexer.address)
-
-      // Get thawing period
-      const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-      // Mine blocks to complete thawing period
-      for (let i = 0; i < Number(thawingPeriod) + 1; i++) {
-        await ethers.provider.send('evm_mine', [])
-      }
-
-      // Withdraw tokens
-      await horizonStaking.connect(indexer).withdraw()
-
-      // Verify tokens are transferred back to service provider
-      const balanceAfter = await graphToken.balanceOf(indexer.address)
-      expect(balanceAfter).to.equal(
-        balanceBefore + tokensUnstaked,
-        'Tokens were not transferred back to service provider',
-      )
-    })
-
-    describe('Legacy allocations', () => {
-      describe('Restaking', () => {
-        let delegationIndexingCut: number
-        let delegationQueryFeeCut: number
-        let allocationID: string
-        let allocationTokens: bigint
-        let gateway: HardhatEthersSigner
-
-        beforeEach(async () => {
-          const indexerFixture = indexers[0]
-          indexer = await ethers.getSigner(indexerFixture.address)
-          delegationIndexingCut = indexerFixture.indexingRewardCut
-          delegationQueryFeeCut = indexerFixture.queryFeeCut
-          allocationID = indexerFixture.allocations[0].allocationID
-          allocationTokens = indexerFixture.allocations[0].tokens
-          gateway = await graph.accounts.getGateway()
-          await setGRTBalance(graph.provider, graphToken.target, gateway.address, ONE_MILLION)
-        })
-
-        it('should be able to close an open legacy allocation and collect rewards', async () => {
-          // Use a non-zero POI
-          const poi = generatePOI('poi')
-          const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-          // Get delegation pool before closing allocation
-          const delegationPoolBefore = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensBefore = delegationPoolBefore.tokens
-
-          // Mine blocks to simulate time passing
-          const halfThawingPeriod = Number(thawingPeriod) / 2
-          for (let i = 0; i < halfThawingPeriod; i++) {
-            await ethers.provider.send('evm_mine', [])
-          }
-
-          // Get idle stake before closing allocation
-          const idleStakeBefore = await horizonStaking.getIdleStake(indexer.address)
-
-          // Close allocation
-          const tx = await horizonStaking.connect(indexer).closeAllocation(allocationID, poi)
-          const eventData = await getEventData(
-            tx,
-            'event HorizonRewardsAssigned(address indexed indexer, address indexed allocationID, uint256 amount)',
-          )
-          const rewards = eventData[2]
-
-          // Verify rewards are not zero
-          expect(rewards).to.not.equal(0, 'Rewards were not transferred to service provider')
-
-          // Verify rewards minus delegation cut are restaked
-          const idleStakeAfter = await horizonStaking.getIdleStake(indexer.address)
-          const idleStakeRewardsTokens = (rewards * BigInt(delegationIndexingCut)) / 1000000n
-          expect(idleStakeAfter).to.equal(
-            idleStakeBefore + allocationTokens + idleStakeRewardsTokens,
-            'Rewards were not restaked',
-          )
-
-          // Verify delegators cut is added to delegation pool
-          const delegationPool = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensAfter = delegationPool.tokens
-          const delegationRewardsTokens = rewards - idleStakeRewardsTokens
-          expect(delegationPoolTokensAfter).to.equal(
-            delegationPoolTokensBefore + delegationRewardsTokens,
-            'Delegators cut was not added to delegation pool',
-          )
-        })
-
-        it('should be able to collect query fees', async () => {
-          const tokensToCollect = ethers.parseEther('1000')
-
-          // Get idle stake before collecting
-          const idleStakeBefore = await horizonStaking.getIdleStake(indexer.address)
-
-          // Get delegation pool before collecting
-          const delegationPoolBefore = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensBefore = delegationPoolBefore.tokens
-
-          // Collect query fees
-          await collect(gateway, [tokensToCollect, allocationID])
-
-          // Get idle stake after collecting
-          const idleStakeAfter = await horizonStaking.getIdleStake(indexer.address)
-
-          // Subtract protocol tax (1%) and curation fees (10% after the protocol tax deduction)
-          const protocolTax = (tokensToCollect * 1n) / 100n
-          const curationFees = (tokensToCollect * 99n) / 1000n
-          const remainingTokens = tokensToCollect - protocolTax - curationFees
-
-          // Verify tokens minus delegators cut are restaked
-          const indexerCutTokens = (remainingTokens * BigInt(delegationQueryFeeCut)) / 1000000n
-          expect(idleStakeAfter).to.equal(idleStakeBefore + indexerCutTokens, 'Indexer cut was not restaked')
-
-          // Verify delegators cut is added to delegation pool
-          const delegationPool = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensAfter = delegationPool.tokens
-          const delegationCutTokens = remainingTokens - indexerCutTokens
-          expect(delegationPoolTokensAfter).to.equal(
-            delegationPoolTokensBefore + delegationCutTokens,
-            'Delegators cut was not added to delegation pool',
-          )
-        })
-
-        it('should be able to close an allocation and collect query fees for the closed allocation', async () => {
-          // Use a non-zero POI
-          const poi = generatePOI('poi')
-          const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-          // Mine blocks to simulate time passing
-          const halfThawingPeriod = Number(thawingPeriod) / 2
-          for (let i = 0; i < halfThawingPeriod; i++) {
-            await ethers.provider.send('evm_mine', [])
-          }
-
-          // Close allocation
-          await horizonStaking.connect(indexer).closeAllocation(allocationID, poi)
-
-          // Tokens to collect
-          const tokensToCollect = ethers.parseEther('1000')
-
-          // Get idle stake before collecting
-          const idleStakeBefore = await horizonStaking.getIdleStake(indexer.address)
-
-          // Get delegation pool before collecting
-          const delegationPoolBefore = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensBefore = delegationPoolBefore.tokens
-
-          // Collect query fees
-          await collect(gateway, [tokensToCollect, allocationID])
-
-          // Get idle stake after collecting
-          const idleStakeAfter = await horizonStaking.getIdleStake(indexer.address)
-
-          // Subtract protocol tax (1%) and curation fees (10% after the protocol tax deduction)
-          const protocolTax = (tokensToCollect * 1n) / 100n
-          const curationFees = (tokensToCollect * 99n) / 1000n
-          const remainingTokens = tokensToCollect - protocolTax - curationFees
-
-          // Verify tokens minus delegators cut are restaked
-          const indexerCutTokens = (remainingTokens * BigInt(delegationQueryFeeCut)) / 1000000n
-          expect(idleStakeAfter).to.equal(idleStakeBefore + indexerCutTokens, 'Indexer cut was not restaked')
-
-          // Verify delegators cut is added to delegation pool
-          const delegationPool = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensAfter = delegationPool.tokens
-          const delegationCutTokens = remainingTokens - indexerCutTokens
-          expect(delegationPoolTokensAfter).to.equal(
-            delegationPoolTokensBefore + delegationCutTokens,
-            'Delegators cut was not added to delegation pool',
-          )
-        })
-      })
-
-      describe('With rewardsDestination set', () => {
-        let delegationIndexingCut: number
-        let delegationQueryFeeCut: number
-        let rewardsDestination: string
-        let allocationID: string
-        let gateway: HardhatEthersSigner
-
-        beforeEach(async () => {
-          const indexerFixture = indexers[1]
-          indexer = await ethers.getSigner(indexerFixture.address)
-          delegationIndexingCut = indexerFixture.indexingRewardCut
-          delegationQueryFeeCut = indexerFixture.queryFeeCut
-          rewardsDestination = indexerFixture.rewardsDestination!
-          allocationID = indexerFixture.allocations[0].allocationID
-          gateway = await graph.accounts.getGateway()
-          await setGRTBalance(graph.provider, graphToken.target, gateway.address, ONE_MILLION)
-        })
-
-        it('should be able to close an open allocation and collect rewards', async () => {
-          // Use a non-zero POI
-          const poi = generatePOI('poi')
-          const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-          // Get delegation tokens before
-          const delegationPoolBefore = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensBefore = delegationPoolBefore.tokens
-
-          // Mine blocks to simulate time passing
-          const halfThawingPeriod = Number(thawingPeriod) / 2
-          for (let i = 0; i < halfThawingPeriod; i++) {
-            await ethers.provider.send('evm_mine', [])
-          }
-
-          // Get rewards destination balance before closing allocation
-          const balanceBefore = await graphToken.balanceOf(rewardsDestination)
-
-          // Close allocation
-          const tx = await horizonStaking.connect(indexer).closeAllocation(allocationID, poi)
-          const eventData = await getEventData(
-            tx,
-            'event HorizonRewardsAssigned(address indexed indexer, address indexed allocationID, uint256 amount)',
-          )
-          const rewards = eventData[2]
-
-          // Verify rewards are not zero
-          expect(rewards).to.not.equal(0, 'Rewards were not transferred to rewards destination')
-
-          // Verify indexer rewards cut is transferred to rewards destination
-          const balanceAfter = await graphToken.balanceOf(rewardsDestination)
-          const indexerCutTokens = (rewards * BigInt(delegationIndexingCut)) / 1000000n
-          expect(balanceAfter).to.equal(
-            balanceBefore + indexerCutTokens,
-            'Indexer cut was not transferred to rewards destination',
-          )
-
-          // Verify delegators cut is added to delegation pool
-          const delegationPoolAfter = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensAfter = delegationPoolAfter.tokens
-          const delegationCutTokens = rewards - indexerCutTokens
-          expect(delegationPoolTokensAfter).to.equal(
-            delegationPoolTokensBefore + delegationCutTokens,
-            'Delegators cut was not added to delegation pool',
-          )
-        })
-
-        it('should be able to collect query fees', async () => {
-          const tokensToCollect = ethers.parseEther('1000')
-
-          // Get rewards destination balance before collecting
-          const balanceBefore = await graphToken.balanceOf(rewardsDestination)
-
-          // Get delegation tokens before
-          const delegationPoolBefore = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensBefore = delegationPoolBefore.tokens
-
-          // Collect query fees
-          await collect(gateway, [tokensToCollect, allocationID])
-
-          // Get rewards destination balance after collecting
-          const balanceAfter = await graphToken.balanceOf(rewardsDestination)
-
-          // Subtract protocol tax (1%) and curation fees (10% after the protocol tax deduction)
-          const protocolTax = (tokensToCollect * 1n) / 100n
-          const curationFees = (tokensToCollect * 99n) / 1000n
-          const remainingTokens = tokensToCollect - protocolTax - curationFees
-
-          // Verify indexer cut is transferred to rewards destination
-          const indexerCutTokens = (remainingTokens * BigInt(delegationQueryFeeCut)) / 1000000n
-          expect(balanceAfter).to.equal(
-            balanceBefore + indexerCutTokens,
-            'Indexer cut was not transferred to rewards destination',
-          )
-
-          // Verify delegators cut is added to delegation pool
-          const delegationPoolAfter = await horizonStaking.getDelegationPool(indexer.address, subgraphServiceAddress)
-          const delegationPoolTokensAfter = delegationPoolAfter.tokens
-          const delegationCutTokens = remainingTokens - indexerCutTokens
-          expect(delegationPoolTokensAfter).to.equal(
-            delegationPoolTokensBefore + delegationCutTokens,
-            'Delegators cut was not added to delegation pool',
-          )
-        })
-      })
-    })
-
-    describe('Transition period is over', () => {
-      let governor: HardhatEthersSigner
-      let tokensToUnstake: bigint
-
-      before(async () => {
-        // Get governor
-        governor = await graph.accounts.getGovernor()
-
-        // Get indexer
-        const indexerFixture = indexers[2]
-        indexer = await ethers.getSigner(indexerFixture.address)
-
-        // Set tokens
-        tokensToUnstake = ethers.parseEther('10000')
-      })
-
-      it('should be able to withdraw tokens that were unstaked during transition period', async () => {
-        // Unstake tokens during transition period
-        await horizonStaking.connect(indexer).unstake(tokensToUnstake)
-
-        // Get thawing period
-        const thawingPeriod = await horizonStaking.__DEPRECATED_getThawingPeriod()
-
-        // Clear thawing period
-        await horizonStaking.connect(governor).clearThawingPeriod()
-
-        // Mine blocks to complete thawing period
-        for (let i = 0; i < Number(thawingPeriod) + 1; i++) {
-          await ethers.provider.send('evm_mine', [])
-        }
-
-        // Get balance before withdrawing
-        const balanceBefore = await graphToken.balanceOf(indexer.address)
-
-        // Withdraw tokens
-        await horizonStaking.connect(indexer).withdraw()
-
-        // Get balance after withdrawing
-        const balanceAfter = await graphToken.balanceOf(indexer.address)
-        expect(balanceAfter).to.equal(
-          balanceBefore + tokensToUnstake,
-          'Tokens were not transferred back to service provider',
-        )
-      })
-    })
-  })
-})
diff --git a/packages/horizon/test/integration/during-transition-period/slasher.test.ts b/packages/horizon/test/integration/during-transition-period/slasher.test.ts
deleted file mode 100644
index 47ced0883..000000000
--- a/packages/horizon/test/integration/during-transition-period/slasher.test.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { indexers } from '@graphprotocol/toolshed/fixtures'
-import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import hre from 'hardhat'
-import { ethers } from 'hardhat'
-
-describe('Slasher', () => {
-  let snapshotId: string
-
-  let indexer: string
-  let slasher: HardhatEthersSigner
-  let tokensToSlash: bigint
-
-  const graph = hre.graph()
-  const horizonStaking = graph.horizon.contracts.HorizonStaking
-  const graphToken = graph.horizon.contracts.L2GraphToken
-
-  before(async () => {
-    slasher = await graph.accounts.getArbitrator()
-  })
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Available tokens', () => {
-    before(() => {
-      const indexerFixture = indexers[0]
-      indexer = indexerFixture.address
-      tokensToSlash = ethers.parseEther('10000')
-    })
-
-    it('should be able to slash indexer stake', async () => {
-      // Before slash state
-      const idleStakeBeforeSlash = await horizonStaking.getIdleStake(indexer)
-      const tokensVerifier = tokensToSlash / 2n
-      const slasherBeforeBalance = await graphToken.balanceOf(slasher.address)
-
-      // Slash tokens
-      await horizonStaking.connect(slasher).slash(indexer, tokensToSlash, tokensVerifier, slasher.address)
-
-      // Indexer's stake should have decreased
-      const idleStakeAfterSlash = await horizonStaking.getIdleStake(indexer)
-      expect(idleStakeAfterSlash).to.equal(idleStakeBeforeSlash - tokensToSlash, 'Indexer stake should have decreased')
-
-      // Slasher should have received the tokens
-      const slasherAfterBalance = await graphToken.balanceOf(slasher.address)
-      expect(slasherAfterBalance).to.equal(
-        slasherBeforeBalance + tokensVerifier,
-        'Slasher should have received the tokens',
-      )
-    })
-  })
-
-  describe('Locked tokens', () => {
-    before(() => {
-      const indexerFixture = indexers[1]
-      indexer = indexerFixture.address
-      tokensToSlash = indexerFixture.stake
-    })
-
-    it('should be able to slash locked tokens', async () => {
-      // Before slash state
-      const tokensVerifier = tokensToSlash / 2n
-      const slasherBeforeBalance = await graphToken.balanceOf(slasher.address)
-
-      // Slash tokens
-      await horizonStaking.connect(slasher).slash(indexer, tokensToSlash, tokensVerifier, slasher.address)
-
-      // Indexer's entire stake should have been slashed
-      const indexerStakeAfterSlash = await horizonStaking.getServiceProvider(indexer)
-      expect(indexerStakeAfterSlash.tokensStaked).to.equal(0n, 'Indexer stake should have been slashed')
-
-      // Slasher should have received the tokens
-      const slasherAfterBalance = await graphToken.balanceOf(slasher.address)
-      expect(slasherAfterBalance).to.equal(
-        slasherBeforeBalance + tokensVerifier,
-        'Slasher should have received the tokens',
-      )
-    })
-  })
-})
diff --git a/packages/horizon/test/unit/GraphBase.t.sol b/packages/horizon/test/unit/GraphBase.t.sol
index 7fa450295..98b33b80a 100644
--- a/packages/horizon/test/unit/GraphBase.t.sol
+++ b/packages/horizon/test/unit/GraphBase.t.sol
@@ -12,7 +12,6 @@ import { GraphPayments } from "contracts/payments/GraphPayments.sol";
 import { GraphTallyCollector } from "contracts/payments/collectors/GraphTallyCollector.sol";
 import { IHorizonStaking } from "@graphprotocol/interfaces/contracts/horizon/IHorizonStaking.sol";
 import { HorizonStaking } from "contracts/staking/HorizonStaking.sol";
-import { HorizonStakingExtension } from "contracts/staking/HorizonStakingExtension.sol";
 import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
 import { MockGRTToken } from "../../contracts/mocks/MockGRTToken.sol";
 import { EpochManagerMock } from "contracts/mocks/EpochManagerMock.sol";
@@ -41,7 +40,6 @@ abstract contract GraphBaseTest is IHorizonStakingTypes, Utils, Constants {
     GraphTallyCollector graphTallyCollector;
 
     HorizonStaking private stakingBase;
-    HorizonStakingExtension private stakingExtension;
 
     address subgraphDataServiceLegacyAddress = makeAddr("subgraphDataServiceLegacyAddress");
     address subgraphDataServiceAddress = makeAddr("subgraphDataServiceAddress");
@@ -69,8 +67,7 @@ abstract contract GraphBaseTest is IHorizonStakingTypes, Utils, Constants {
             operator: createUser("operator"),
             gateway: createUser("gateway"),
             verifier: createUser("verifier"),
-            delegator: createUser("delegator"),
-            legacySlasher: createUser("legacySlasher")
+            delegator: createUser("delegator")
         });
 
         // Deploy protocol contracts
@@ -84,7 +81,6 @@ abstract contract GraphBaseTest is IHorizonStakingTypes, Utils, Constants {
         vm.label({ account: address(payments), newLabel: "GraphPayments" });
         vm.label({ account: address(escrow), newLabel: "PaymentsEscrow" });
         vm.label({ account: address(staking), newLabel: "HorizonStaking" });
-        vm.label({ account: address(stakingExtension), newLabel: "HorizonStakingExtension" });
         vm.label({ account: address(graphTallyCollector), newLabel: "GraphTallyCollector" });
 
         // Ensure caller is back to the original msg.sender
@@ -192,12 +188,7 @@ abstract contract GraphBaseTest is IHorizonStakingTypes, Utils, Constants {
             escrow = PaymentsEscrow(escrowProxyAddress);
         }
 
-        stakingExtension = new HorizonStakingExtension(address(controller), subgraphDataServiceLegacyAddress);
-        stakingBase = new HorizonStaking(
-            address(controller),
-            address(stakingExtension),
-            subgraphDataServiceLegacyAddress
-        );
+        stakingBase = new HorizonStaking(address(controller), subgraphDataServiceLegacyAddress);
 
         graphTallyCollector = new GraphTallyCollector(
             "GraphTallyCollector",
diff --git a/packages/horizon/test/unit/data-service/extensions/DataServiceFees.t.sol b/packages/horizon/test/unit/data-service/extensions/DataServiceFees.t.sol
index a2ae10653..5cb3b7d67 100644
--- a/packages/horizon/test/unit/data-service/extensions/DataServiceFees.t.sol
+++ b/packages/horizon/test/unit/data-service/extensions/DataServiceFees.t.sol
@@ -3,7 +3,7 @@ pragma solidity 0.8.27;
 
 import { HorizonStakingSharedTest } from "../../shared/horizon-staking/HorizonStakingShared.t.sol";
 import { DataServiceImpFees } from "../implementations/DataServiceImpFees.sol";
-import { IDataServiceFees } from "@graphprotocol/interfaces/contracts/data-service/IDataServiceFees.sol";
+import { StakeClaims } from "../../../../contracts/data-service/libraries/StakeClaims.sol";
 import { ProvisionTracker } from "../../../../contracts/data-service/libraries/ProvisionTracker.sol";
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 
@@ -13,7 +13,7 @@ contract DataServiceFeesTest is HorizonStakingSharedTest {
         useIndexer
         useProvisionDataService(address(dataService), PROVISION_TOKENS, 0, 0)
     {
-        vm.expectRevert(abi.encodeWithSignature("DataServiceFeesZeroTokens()"));
+        vm.expectRevert(abi.encodeWithSignature("StakeClaimsZeroTokens()"));
         dataService.lockStake(users.indexer, 0);
     }
 
@@ -145,7 +145,7 @@ contract DataServiceFeesTest is HorizonStakingSharedTest {
 
         // it should emit a an event
         vm.expectEmit();
-        emit IDataServiceFees.StakeClaimLocked(
+        emit StakeClaims.StakeClaimLocked(
             serviceProvider,
             calcValues.predictedClaimId,
             calcValues.stakeToLock,
@@ -207,14 +207,14 @@ contract DataServiceFeesTest is HorizonStakingSharedTest {
                 break;
             }
 
-            emit IDataServiceFees.StakeClaimReleased(serviceProvider, calcValues.head, claimTokens, releasableAt);
+            emit StakeClaims.StakeClaimReleased(serviceProvider, calcValues.head, claimTokens, releasableAt);
             calcValues.head = nextClaim;
             calcValues.tokensReleased += claimTokens;
             calcValues.claimsCount++;
         }
 
         // it should emit a an event
-        emit IDataServiceFees.StakeClaimsReleased(serviceProvider, calcValues.claimsCount, calcValues.tokensReleased);
+        emit StakeClaims.StakeClaimsReleased(serviceProvider, calcValues.claimsCount, calcValues.tokensReleased);
         dataService.releaseStake(numClaimsToRelease);
 
         // after state
diff --git a/packages/horizon/test/unit/data-service/extensions/DataServicePausableUpgradeable.t.sol b/packages/horizon/test/unit/data-service/extensions/DataServicePausableUpgradeable.t.sol
index d5413ed5b..fd618a041 100644
--- a/packages/horizon/test/unit/data-service/extensions/DataServicePausableUpgradeable.t.sol
+++ b/packages/horizon/test/unit/data-service/extensions/DataServicePausableUpgradeable.t.sol
@@ -3,17 +3,20 @@ pragma solidity 0.8.27;
 
 import { GraphBaseTest } from "../../GraphBase.t.sol";
 import { DataServiceImpPausableUpgradeable } from "../implementations/DataServiceImpPausableUpgradeable.sol";
+import { IDataServicePausable } from "@graphprotocol/interfaces/contracts/data-service/IDataServicePausable.sol";
 import { UnsafeUpgrades } from "@openzeppelin/foundry-upgrades/src/Upgrades.sol";
 
 import { PPMMath } from "./../../../../contracts/libraries/PPMMath.sol";
 
 contract DataServicePausableUpgradeableTest is GraphBaseTest {
-    function test_WhenTheContractIsDeployed() external {
-        (
-            DataServiceImpPausableUpgradeable dataService,
-            DataServiceImpPausableUpgradeable implementation
-        ) = _deployDataService();
+    DataServiceImpPausableUpgradeable private dataService;
 
+    function setUp() public override {
+        super.setUp();
+        (dataService, ) = _deployDataService();
+    }
+
+    function test_WhenTheContractIsDeployed() external view {
         // via proxy - ensure that the proxy was initialized correctly
         // these calls validate proxy storage was correctly initialized
         uint32 delegationRatio = dataService.getDelegationRatio();
@@ -30,13 +33,113 @@ contract DataServicePausableUpgradeableTest is GraphBaseTest {
         (uint64 minThawingPeriod, uint64 maxThawingPeriod) = dataService.getThawingPeriodRange();
         assertEq(minThawingPeriod, type(uint64).min);
         assertEq(maxThawingPeriod, type(uint64).max);
+    }
+
+    // -- setPauseGuardian --
+
+    function test_SetPauseGuardian() external {
+        address guardian = makeAddr("guardian");
+
+        vm.expectEmit(address(dataService));
+        emit IDataServicePausable.PauseGuardianSet(guardian, true);
+        dataService.setPauseGuardian(guardian, true);
+
+        assertTrue(dataService.pauseGuardians(guardian));
+    }
+
+    function test_SetPauseGuardian_Remove() external {
+        address guardian = makeAddr("guardian");
+        dataService.setPauseGuardian(guardian, true);
+
+        vm.expectEmit(address(dataService));
+        emit IDataServicePausable.PauseGuardianSet(guardian, false);
+        dataService.setPauseGuardian(guardian, false);
+
+        assertFalse(dataService.pauseGuardians(guardian));
+    }
+
+    function test_RevertWhen_SetPauseGuardian_NoChange_AlreadyFalse() external {
+        address guardian = makeAddr("guardian");
+
+        // guardian defaults to false, setting to false should revert
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                IDataServicePausable.DataServicePausablePauseGuardianNoChange.selector,
+                guardian,
+                false
+            )
+        );
+        dataService.setPauseGuardian(guardian, false);
+    }
+
+    function test_RevertWhen_SetPauseGuardian_NoChange_AlreadyTrue() external {
+        address guardian = makeAddr("guardian");
+        dataService.setPauseGuardian(guardian, true);
+
+        // guardian is already true, setting to true should revert
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                IDataServicePausable.DataServicePausablePauseGuardianNoChange.selector,
+                guardian,
+                true
+            )
+        );
+        dataService.setPauseGuardian(guardian, true);
+    }
+
+    // -- pause --
+
+    function test_Pause() external {
+        address guardian = makeAddr("guardian");
+        dataService.setPauseGuardian(guardian, true);
+
+        vm.prank(guardian);
+        dataService.pause();
+
+        assertTrue(dataService.paused());
+    }
+
+    function test_RevertWhen_Pause_NotGuardian() external {
+        address notGuardian = makeAddr("notGuardian");
 
-        // this ensures that implementation immutables were correctly initialized
-        // and they can be read via the proxy
-        assertEq(implementation.controller(), address(controller));
-        assertEq(dataService.controller(), address(controller));
+        vm.expectRevert(
+            abi.encodeWithSelector(IDataServicePausable.DataServicePausableNotPauseGuardian.selector, notGuardian)
+        );
+        vm.prank(notGuardian);
+        dataService.pause();
     }
 
+    // -- unpause --
+
+    function test_Unpause() external {
+        address guardian = makeAddr("guardian");
+        dataService.setPauseGuardian(guardian, true);
+
+        vm.startPrank(guardian);
+        dataService.pause();
+        dataService.unpause();
+        vm.stopPrank();
+
+        assertFalse(dataService.paused());
+    }
+
+    function test_RevertWhen_Unpause_NotGuardian() external {
+        address guardian = makeAddr("guardian");
+        dataService.setPauseGuardian(guardian, true);
+
+        vm.prank(guardian);
+        dataService.pause();
+
+        address notGuardian = makeAddr("notGuardian");
+        vm.expectRevert(
+            abi.encodeWithSelector(IDataServicePausable.DataServicePausableNotPauseGuardian.selector, notGuardian)
+        );
+        vm.prank(notGuardian);
+        dataService.unpause();
+    }
+
+    // -- helpers --
+
     function _deployDataService()
         internal
         returns (DataServiceImpPausableUpgradeable, DataServiceImpPausableUpgradeable)
diff --git a/packages/horizon/test/unit/data-service/implementations/DataServiceImpPausableUpgradeable.sol b/packages/horizon/test/unit/data-service/implementations/DataServiceImpPausableUpgradeable.sol
index 71453fd19..8e62041cc 100644
--- a/packages/horizon/test/unit/data-service/implementations/DataServiceImpPausableUpgradeable.sol
+++ b/packages/horizon/test/unit/data-service/implementations/DataServiceImpPausableUpgradeable.sol
@@ -31,6 +31,10 @@ contract DataServiceImpPausableUpgradeable is DataServicePausableUpgradeable {
 
     function slash(address serviceProvider, bytes calldata data) external {}
 
+    function setPauseGuardian(address _pauseGuardian, bool _allowed) external {
+        _setPauseGuardian(_pauseGuardian, _allowed);
+    }
+
     function controller() external view returns (address) {
         return address(_graphController());
     }
diff --git a/packages/horizon/test/unit/data-service/utilities/ProvisionManager.t.sol b/packages/horizon/test/unit/data-service/utilities/ProvisionManager.t.sol
new file mode 100644
index 000000000..b7f2b4ee2
--- /dev/null
+++ b/packages/horizon/test/unit/data-service/utilities/ProvisionManager.t.sol
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.27;
+
+import { Test } from "forge-std/Test.sol";
+
+import { ProvisionManager } from "../../../../contracts/data-service/utilities/ProvisionManager.sol";
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+import { PartialControllerMock } from "../../mocks/PartialControllerMock.t.sol";
+import { HorizonStakingMock } from "../../mocks/HorizonStakingMock.t.sol";
+import { ProvisionManagerImpl } from "./ProvisionManagerImpl.t.sol";
+
+contract ProvisionManagerTest is Test {
+    ProvisionManagerImpl internal _provisionManager;
+    HorizonStakingMock internal _horizonStakingMock;
+
+    function setUp() public {
+        _horizonStakingMock = new HorizonStakingMock();
+
+        PartialControllerMock.Entry[] memory entries = new PartialControllerMock.Entry[](1);
+        entries[0] = PartialControllerMock.Entry({ name: "Staking", addr: address(_horizonStakingMock) });
+        _provisionManager = new ProvisionManagerImpl(address(new PartialControllerMock(entries)));
+    }
+
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_OnlyValidProvision(address serviceProvider) public {
+        vm.expectRevert(
+            abi.encodeWithSelector(ProvisionManager.ProvisionManagerProvisionNotFound.selector, serviceProvider)
+        );
+        _provisionManager.onlyValidProvision_(serviceProvider);
+
+        IHorizonStakingTypes.Provision memory provision;
+        provision.createdAt = 1;
+
+        _horizonStakingMock.setProvision(serviceProvider, address(_provisionManager), provision);
+
+        _provisionManager.onlyValidProvision_(serviceProvider);
+    }
+
+    function test_OnlyAuthorizedForProvision(address serviceProvider, address sender) public {
+        vm.expectRevert(
+            abi.encodeWithSelector(ProvisionManager.ProvisionManagerNotAuthorized.selector, serviceProvider, sender)
+        );
+        vm.prank(sender);
+        _provisionManager.onlyAuthorizedForProvision_(serviceProvider);
+
+        _horizonStakingMock.setIsAuthorized(serviceProvider, address(_provisionManager), sender, true);
+        vm.prank(sender);
+        _provisionManager.onlyAuthorizedForProvision_(serviceProvider);
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/data-service/utilities/ProvisionManagerImpl.t.sol b/packages/horizon/test/unit/data-service/utilities/ProvisionManagerImpl.t.sol
new file mode 100644
index 000000000..4170d17da
--- /dev/null
+++ b/packages/horizon/test/unit/data-service/utilities/ProvisionManagerImpl.t.sol
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.27;
+
+import { ProvisionManager } from "../../../../contracts/data-service/utilities/ProvisionManager.sol";
+import { GraphDirectory } from "../../../../contracts/utilities/GraphDirectory.sol";
+
+contract ProvisionManagerImpl is GraphDirectory, ProvisionManager {
+    constructor(address controller) GraphDirectory(controller) {}
+
+    function onlyValidProvision_(address serviceProvider) public view onlyValidProvision(serviceProvider) {}
+
+    function onlyAuthorizedForProvision_(
+        address serviceProvider
+    ) public view onlyAuthorizedForProvision(serviceProvider) {}
+}
diff --git a/packages/horizon/test/unit/libraries/LinkedList.t.sol b/packages/horizon/test/unit/libraries/LinkedList.t.sol
index bdf902edf..a5fdf9055 100644
--- a/packages/horizon/test/unit/libraries/LinkedList.t.sol
+++ b/packages/horizon/test/unit/libraries/LinkedList.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.27;
+pragma solidity 0.8.33;
 
 import { Test } from "forge-std/Test.sol";
 import { LinkedList } from "../../../contracts/libraries/LinkedList.sol";
diff --git a/packages/horizon/test/unit/libraries/ListImplementation.sol b/packages/horizon/test/unit/libraries/ListImplementation.sol
index dad859f59..38c8c8fa9 100644
--- a/packages/horizon/test/unit/libraries/ListImplementation.sol
+++ b/packages/horizon/test/unit/libraries/ListImplementation.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.27;
+pragma solidity 0.8.27 || 0.8.33;
 
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 import { LinkedList } from "../../../contracts/libraries/LinkedList.sol";
diff --git a/packages/horizon/test/unit/libraries/PPMMath.t.sol b/packages/horizon/test/unit/libraries/PPMMath.t.sol
index c760cab06..d438cfb8a 100644
--- a/packages/horizon/test/unit/libraries/PPMMath.t.sol
+++ b/packages/horizon/test/unit/libraries/PPMMath.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.27;
+pragma solidity 0.8.33;
 
 import { Test } from "forge-std/Test.sol";
 import { PPMMath } from "../../../contracts/libraries/PPMMath.sol";
diff --git a/packages/horizon/test/unit/libraries/StakeClaims.t.sol b/packages/horizon/test/unit/libraries/StakeClaims.t.sol
new file mode 100644
index 000000000..48eca89a7
--- /dev/null
+++ b/packages/horizon/test/unit/libraries/StakeClaims.t.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.33;
+
+import { Test } from "forge-std/Test.sol";
+
+import { StakeClaims } from "../../../contracts/data-service/libraries/StakeClaims.sol";
+
+contract StakeClaimsTest is Test {
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_BuildStakeClaimId(address dataService, address serviceProvider, uint256 nonce) public pure {
+        bytes32 id = StakeClaims.buildStakeClaimId(dataService, serviceProvider, nonce);
+        bytes32 expectedId = keccak256(abi.encodePacked(dataService, serviceProvider, nonce));
+        assertEq(id, expectedId, "StakeClaim ID does not match expected value");
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/mocks/HorizonStakingMock.t.sol b/packages/horizon/test/unit/mocks/HorizonStakingMock.t.sol
new file mode 100644
index 000000000..4a74c867d
--- /dev/null
+++ b/packages/horizon/test/unit/mocks/HorizonStakingMock.t.sol
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27 || 0.8.33;
+
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+
+contract HorizonStakingMock {
+    mapping(address => mapping(address => IHorizonStakingTypes.Provision)) public provisions;
+    mapping(address => mapping(address => mapping(address => bool))) public authorizations;
+
+    function setProvision(
+        address serviceProvider,
+        address verifier,
+        IHorizonStakingTypes.Provision memory provision
+    ) external {
+        provisions[serviceProvider][verifier] = provision;
+    }
+
+    function getProvision(
+        address serviceProvider,
+        address verifier
+    ) external view returns (IHorizonStakingTypes.Provision memory) {
+        return provisions[serviceProvider][verifier];
+    }
+
+    function isAuthorized(address serviceProvider, address verifier, address operator) external view returns (bool) {
+        return authorizations[serviceProvider][verifier][operator];
+    }
+
+    function setIsAuthorized(address serviceProvider, address verifier, address operator, bool authorized) external {
+        authorizations[serviceProvider][verifier][operator] = authorized;
+    }
+
+    function getProviderTokensAvailable(address serviceProvider, address verifier) external view returns (uint256) {
+        IHorizonStakingTypes.Provision memory provision = provisions[serviceProvider][verifier];
+        return provision.tokens - provision.tokensThawing;
+    }
+}
diff --git a/packages/horizon/test/unit/mocks/InvalidControllerMock.t.sol b/packages/horizon/test/unit/mocks/InvalidControllerMock.t.sol
new file mode 100644
index 000000000..0e0a991a2
--- /dev/null
+++ b/packages/horizon/test/unit/mocks/InvalidControllerMock.t.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27 || 0.8.33;
+
+import { PartialControllerMock } from "./PartialControllerMock.t.sol";
+
+contract InvalidControllerMock is PartialControllerMock {
+    constructor() PartialControllerMock(new PartialControllerMock.Entry[](0)) {}
+}
diff --git a/packages/horizon/test/unit/mocks/PartialControllerMock.t.sol b/packages/horizon/test/unit/mocks/PartialControllerMock.t.sol
new file mode 100644
index 000000000..8fdc8b886
--- /dev/null
+++ b/packages/horizon/test/unit/mocks/PartialControllerMock.t.sol
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27 || 0.8.33;
+
+import { Test } from "forge-std/Test.sol";
+
+import { ControllerMock } from "../../../contracts/mocks/ControllerMock.sol";
+
+contract PartialControllerMock is ControllerMock, Test {
+    struct Entry {
+        string name;
+        address addr;
+    }
+
+    address private _invalidContractAddress;
+
+    Entry[] private _contracts;
+
+    constructor(Entry[] memory contracts) ControllerMock(address(0)) {
+        for (uint256 i = 0; i < contracts.length; i++) {
+            _contracts.push(Entry({ name: contracts[i].name, addr: contracts[i].addr }));
+        }
+        _invalidContractAddress = makeAddr("invalidContractAddress");
+    }
+
+    function getContractProxy(bytes32 data) external view override returns (address) {
+        for (uint256 i = 0; i < _contracts.length; i++) {
+            if (keccak256(abi.encodePacked(_contracts[i].name)) == data) {
+                return _contracts[i].addr;
+            }
+        }
+        return _invalidContractAddress;
+    }
+}
diff --git a/packages/horizon/test/unit/payments/graph-tally-collector/GraphTallyCollector.t.sol b/packages/horizon/test/unit/payments/graph-tally-collector/GraphTallyCollector.t.sol
index b8e569574..ccd242255 100644
--- a/packages/horizon/test/unit/payments/graph-tally-collector/GraphTallyCollector.t.sol
+++ b/packages/horizon/test/unit/payments/graph-tally-collector/GraphTallyCollector.t.sol
@@ -42,7 +42,7 @@ contract GraphTallyTest is HorizonStakingSharedTest, PaymentsEscrowSharedTest {
      * HELPERS
      */
 
-    function _getSignerProof(uint256 _proofDeadline, uint256 _signer) internal view returns (bytes memory) {
+    function _getSignerProof(uint256 _proofDeadline, uint256 _signer) internal returns (bytes memory) {
         (, address msgSender, ) = vm.readCallers();
         bytes32 messageHash = keccak256(
             abi.encodePacked(
diff --git a/packages/horizon/test/unit/payments/recurring-collector/PaymentsEscrowMock.t.sol b/packages/horizon/test/unit/payments/recurring-collector/PaymentsEscrowMock.t.sol
new file mode 100644
index 000000000..4bd0d7346
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/PaymentsEscrowMock.t.sol
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IPaymentsEscrow } from "@graphprotocol/interfaces/contracts/horizon/IPaymentsEscrow.sol";
+
+contract PaymentsEscrowMock is IPaymentsEscrow {
+    function initialize() external {}
+
+    function collect(IGraphPayments.PaymentTypes, address, address, uint256, address, uint256, address) external {}
+
+    function deposit(address, address, uint256) external {}
+
+    function depositTo(address, address, address, uint256) external {}
+
+    function thaw(address, address, uint256) external {}
+
+    function cancelThaw(address, address) external {}
+
+    function withdraw(address, address) external {}
+
+    function getBalance(address, address, address) external pure returns (uint256) {
+        return 0;
+    }
+
+    function MAX_WAIT_PERIOD() external pure returns (uint256) {
+        return 0;
+    }
+
+    function WITHDRAW_ESCROW_THAWING_PERIOD() external pure returns (uint256) {
+        return 0;
+    }
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/RecurringCollectorAuthorizableTest.t.sol b/packages/horizon/test/unit/payments/recurring-collector/RecurringCollectorAuthorizableTest.t.sol
new file mode 100644
index 000000000..98cc251f0
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/RecurringCollectorAuthorizableTest.t.sol
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IAuthorizable } from "@graphprotocol/interfaces/contracts/horizon/IAuthorizable.sol";
+import { RecurringCollector } from "../../../../contracts/payments/collectors/RecurringCollector.sol";
+
+import { AuthorizableTest } from "../../../unit/utilities/Authorizable.t.sol";
+import { InvalidControllerMock } from "../../mocks/InvalidControllerMock.t.sol";
+
+contract RecurringCollectorAuthorizableTest is AuthorizableTest {
+    function newAuthorizable(uint256 thawPeriod) public override returns (IAuthorizable) {
+        return new RecurringCollector("RecurringCollector", "1", address(new InvalidControllerMock()), thawPeriod);
+    }
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/RecurringCollectorHelper.t.sol b/packages/horizon/test/unit/payments/recurring-collector/RecurringCollectorHelper.t.sol
new file mode 100644
index 000000000..5a8bf5aa7
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/RecurringCollectorHelper.t.sol
@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { RecurringCollector } from "../../../../contracts/payments/collectors/RecurringCollector.sol";
+import { AuthorizableHelper } from "../../../unit/utilities/Authorizable.t.sol";
+import { Bounder } from "../../../unit/utils/Bounder.t.sol";
+
+contract RecurringCollectorHelper is AuthorizableHelper, Bounder {
+    RecurringCollector public collector;
+
+    constructor(
+        RecurringCollector collector_
+    ) AuthorizableHelper(collector_, collector_.REVOKE_AUTHORIZATION_THAWING_PERIOD()) {
+        collector = collector_;
+    }
+
+    function generateSignedRCA(
+        IRecurringCollector.RecurringCollectionAgreement memory rca,
+        uint256 signerPrivateKey
+    ) public view returns (IRecurringCollector.SignedRCA memory) {
+        bytes32 messageHash = collector.hashRCA(rca);
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivateKey, messageHash);
+        bytes memory signature = abi.encodePacked(r, s, v);
+        IRecurringCollector.SignedRCA memory signedRCA = IRecurringCollector.SignedRCA({
+            rca: rca,
+            signature: signature
+        });
+
+        return signedRCA;
+    }
+
+    function generateSignedRCAU(
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau,
+        uint256 signerPrivateKey
+    ) public view returns (IRecurringCollector.SignedRCAU memory) {
+        bytes32 messageHash = collector.hashRCAU(rcau);
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivateKey, messageHash);
+        bytes memory signature = abi.encodePacked(r, s, v);
+        IRecurringCollector.SignedRCAU memory signedRCAU = IRecurringCollector.SignedRCAU({
+            rcau: rcau,
+            signature: signature
+        });
+
+        return signedRCAU;
+    }
+
+    function generateSignedRCAUForAgreement(
+        bytes16 agreementId,
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau,
+        uint256 signerPrivateKey
+    ) public view returns (IRecurringCollector.SignedRCAU memory) {
+        // Automatically set the correct nonce based on current agreement state
+        IRecurringCollector.AgreementData memory agreement = collector.getAgreement(agreementId);
+        rcau.nonce = agreement.updateNonce + 1;
+
+        return generateSignedRCAU(rcau, signerPrivateKey);
+    }
+
+    function generateSignedRCAUWithCorrectNonce(
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau,
+        uint256 signerPrivateKey
+    ) public view returns (IRecurringCollector.SignedRCAU memory) {
+        // This is kept for backwards compatibility but should not be used with new interface
+        // since we can't determine agreementId without it being passed separately
+        return generateSignedRCAU(rcau, signerPrivateKey);
+    }
+
+    function generateSignedRCAWithCalculatedId(
+        IRecurringCollector.RecurringCollectionAgreement memory rca,
+        uint256 signerPrivateKey
+    ) public view returns (IRecurringCollector.SignedRCA memory, bytes16) {
+        // Ensure we have sensible values
+        rca = sensibleRCA(rca);
+
+        // Calculate the agreement ID
+        bytes16 agreementId = collector.generateAgreementId(
+            rca.payer,
+            rca.dataService,
+            rca.serviceProvider,
+            rca.deadline,
+            rca.nonce
+        );
+
+        IRecurringCollector.SignedRCA memory signedRCA = generateSignedRCA(rca, signerPrivateKey);
+        return (signedRCA, agreementId);
+    }
+
+    function withElapsedAcceptDeadline(
+        IRecurringCollector.RecurringCollectionAgreement memory rca
+    ) public view returns (IRecurringCollector.RecurringCollectionAgreement memory) {
+        require(block.timestamp > 0, "block.timestamp can't be zero");
+        require(block.timestamp <= type(uint64).max, "block.timestamp can't be huge");
+        rca.deadline = uint64(bound(rca.deadline, 0, block.timestamp - 1));
+        return rca;
+    }
+
+    function withOKAcceptDeadline(
+        IRecurringCollector.RecurringCollectionAgreement memory rca
+    ) public view returns (IRecurringCollector.RecurringCollectionAgreement memory) {
+        require(block.timestamp <= type(uint64).max, "block.timestamp can't be huge");
+        rca.deadline = uint64(boundTimestampMin(rca.deadline, block.timestamp));
+        return rca;
+    }
+
+    function sensibleRCA(
+        IRecurringCollector.RecurringCollectionAgreement memory rca
+    ) public view returns (IRecurringCollector.RecurringCollectionAgreement memory) {
+        vm.assume(rca.dataService != address(0));
+        vm.assume(rca.payer != address(0));
+        vm.assume(rca.serviceProvider != address(0));
+
+        // Ensure we have a nonce if it's zero
+        if (rca.nonce == 0) {
+            rca.nonce = 1;
+        }
+
+        rca.minSecondsPerCollection = _sensibleMinSecondsPerCollection(rca.minSecondsPerCollection);
+        rca.maxSecondsPerCollection = _sensibleMaxSecondsPerCollection(
+            rca.maxSecondsPerCollection,
+            rca.minSecondsPerCollection
+        );
+
+        rca.deadline = _sensibleDeadline(rca.deadline);
+        rca.endsAt = _sensibleEndsAt(rca.endsAt, rca.maxSecondsPerCollection);
+
+        rca.maxInitialTokens = _sensibleMaxInitialTokens(rca.maxInitialTokens);
+        rca.maxOngoingTokensPerSecond = _sensibleMaxOngoingTokensPerSecond(rca.maxOngoingTokensPerSecond);
+
+        return rca;
+    }
+
+    function sensibleRCAU(
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau
+    ) public view returns (IRecurringCollector.RecurringCollectionAgreementUpdate memory) {
+        rcau.minSecondsPerCollection = _sensibleMinSecondsPerCollection(rcau.minSecondsPerCollection);
+        rcau.maxSecondsPerCollection = _sensibleMaxSecondsPerCollection(
+            rcau.maxSecondsPerCollection,
+            rcau.minSecondsPerCollection
+        );
+
+        rcau.deadline = _sensibleDeadline(rcau.deadline);
+        rcau.endsAt = _sensibleEndsAt(rcau.endsAt, rcau.maxSecondsPerCollection);
+        rcau.maxInitialTokens = _sensibleMaxInitialTokens(rcau.maxInitialTokens);
+        rcau.maxOngoingTokensPerSecond = _sensibleMaxOngoingTokensPerSecond(rcau.maxOngoingTokensPerSecond);
+
+        return rcau;
+    }
+
+    function _sensibleDeadline(uint256 _seed) internal view returns (uint64) {
+        return
+            uint64(
+                bound(_seed, block.timestamp + 1, block.timestamp + uint256(collector.MIN_SECONDS_COLLECTION_WINDOW()))
+            ); // between now and +MIN_SECONDS_COLLECTION_WINDOW
+    }
+
+    function _sensibleEndsAt(uint256 _seed, uint32 _maxSecondsPerCollection) internal view returns (uint64) {
+        return
+            uint64(
+                bound(
+                    _seed,
+                    block.timestamp + (10 * uint256(_maxSecondsPerCollection)),
+                    block.timestamp + (1_000_000 * uint256(_maxSecondsPerCollection))
+                )
+            ); // between 10 and 1M max collections
+    }
+
+    function _sensibleMaxSecondsPerCollection(
+        uint32 _seed,
+        uint32 _minSecondsPerCollection
+    ) internal view returns (uint32) {
+        return
+            uint32(
+                bound(
+                    _seed,
+                    _minSecondsPerCollection + uint256(collector.MIN_SECONDS_COLLECTION_WINDOW()),
+                    60 * 60 * 24 * 30
+                ) // between minSecondsPerCollection + 2h and 30 days
+            );
+    }
+
+    function _sensibleMaxInitialTokens(uint256 _seed) internal pure returns (uint256) {
+        return bound(_seed, 0, 1e18 * 100_000_000); // between 0 and 100M tokens
+    }
+
+    function _sensibleMaxOngoingTokensPerSecond(uint256 _seed) internal pure returns (uint256) {
+        return bound(_seed, 1, 1e18); // between 1 and 1e18 tokens per second
+    }
+
+    function _sensibleMinSecondsPerCollection(uint32 _seed) internal pure returns (uint32) {
+        return uint32(bound(_seed, 10 * 60, 24 * 60 * 60)); // between 10 min and 24h
+    }
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/accept.t.sol b/packages/horizon/test/unit/payments/recurring-collector/accept.t.sol
new file mode 100644
index 000000000..3c2e47ba2
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/accept.t.sol
@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+
+import { RecurringCollectorSharedTest } from "./shared.t.sol";
+
+contract RecurringCollectorAcceptTest is RecurringCollectorSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_Accept(FuzzyTestAccept calldata fuzzyTestAccept) public {
+        _sensibleAuthorizeAndAccept(fuzzyTestAccept);
+    }
+
+    function test_Accept_Revert_WhenAcceptanceDeadlineElapsed(
+        IRecurringCollector.SignedRCA memory fuzzySignedRCA,
+        uint256 unboundedSkip
+    ) public {
+        // Generate deterministic agreement ID for validation
+        bytes16 agreementId = _recurringCollector.generateAgreementId(
+            fuzzySignedRCA.rca.payer,
+            fuzzySignedRCA.rca.dataService,
+            fuzzySignedRCA.rca.serviceProvider,
+            fuzzySignedRCA.rca.deadline,
+            fuzzySignedRCA.rca.nonce
+        );
+        vm.assume(agreementId != bytes16(0));
+        skip(boundSkip(unboundedSkip, 1, type(uint64).max - block.timestamp));
+        fuzzySignedRCA.rca = _recurringCollectorHelper.withElapsedAcceptDeadline(fuzzySignedRCA.rca);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementDeadlineElapsed.selector,
+            block.timestamp,
+            fuzzySignedRCA.rca.deadline
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(fuzzySignedRCA.rca.dataService);
+        _recurringCollector.accept(fuzzySignedRCA);
+    }
+
+    function test_Accept_Revert_WhenAlreadyAccepted(FuzzyTestAccept calldata fuzzyTestAccept) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzyTestAccept
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementIncorrectState.selector,
+            agreementId,
+            IRecurringCollector.AgreementState.Accepted
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.accept(accepted);
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/base.t.sol b/packages/horizon/test/unit/payments/recurring-collector/base.t.sol
new file mode 100644
index 000000000..338418835
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/base.t.sol
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+
+import { RecurringCollectorSharedTest } from "./shared.t.sol";
+
+contract RecurringCollectorBaseTest is RecurringCollectorSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_RecoverRCASigner(FuzzyTestAccept memory fuzzyTestAccept) public view {
+        uint256 signerKey = boundKey(fuzzyTestAccept.unboundedSignerKey);
+        IRecurringCollector.SignedRCA memory signedRCA = _recurringCollectorHelper.generateSignedRCA(
+            fuzzyTestAccept.rca,
+            signerKey
+        );
+
+        assertEq(
+            _recurringCollector.recoverRCASigner(signedRCA),
+            vm.addr(signerKey),
+            "Recovered RCA signer does not match"
+        );
+    }
+
+    function test_RecoverRCAUSigner(FuzzyTestUpdate memory fuzzyTestUpdate) public view {
+        uint256 signerKey = boundKey(fuzzyTestUpdate.fuzzyTestAccept.unboundedSignerKey);
+        IRecurringCollector.SignedRCAU memory signedRCAU = _recurringCollectorHelper.generateSignedRCAU(
+            fuzzyTestUpdate.rcau,
+            signerKey
+        );
+
+        assertEq(
+            _recurringCollector.recoverRCAUSigner(signedRCAU),
+            vm.addr(signerKey),
+            "Recovered RCAU signer does not match"
+        );
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/cancel.t.sol b/packages/horizon/test/unit/payments/recurring-collector/cancel.t.sol
new file mode 100644
index 000000000..09dc66c3c
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/cancel.t.sol
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+
+import { RecurringCollectorSharedTest } from "./shared.t.sol";
+
+contract RecurringCollectorCancelTest is RecurringCollectorSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_Cancel(FuzzyTestAccept calldata fuzzyTestAccept, uint8 unboundedCanceler) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzyTestAccept
+        );
+
+        _cancel(accepted.rca, agreementId, _fuzzyCancelAgreementBy(unboundedCanceler));
+    }
+
+    function test_Cancel_Revert_WhenNotAccepted(
+        IRecurringCollector.RecurringCollectionAgreement memory fuzzyRCA,
+        uint8 unboundedCanceler
+    ) public {
+        // Generate deterministic agreement ID
+        bytes16 agreementId = _recurringCollector.generateAgreementId(
+            fuzzyRCA.payer,
+            fuzzyRCA.dataService,
+            fuzzyRCA.serviceProvider,
+            fuzzyRCA.deadline,
+            fuzzyRCA.nonce
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementIncorrectState.selector,
+            agreementId,
+            IRecurringCollector.AgreementState.NotAccepted
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(fuzzyRCA.dataService);
+        _recurringCollector.cancel(agreementId, _fuzzyCancelAgreementBy(unboundedCanceler));
+    }
+
+    function test_Cancel_Revert_WhenNotDataService(
+        FuzzyTestAccept calldata fuzzyTestAccept,
+        uint8 unboundedCanceler,
+        address notDataService
+    ) public {
+        vm.assume(fuzzyTestAccept.rca.dataService != notDataService);
+
+        (, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(fuzzyTestAccept);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorDataServiceNotAuthorized.selector,
+            agreementId,
+            notDataService
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(notDataService);
+        _recurringCollector.cancel(agreementId, _fuzzyCancelAgreementBy(unboundedCanceler));
+    }
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/collect.t.sol b/packages/horizon/test/unit/payments/recurring-collector/collect.t.sol
new file mode 100644
index 000000000..588c7859e
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/collect.t.sol
@@ -0,0 +1,447 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+
+import { RecurringCollectorSharedTest } from "./shared.t.sol";
+
+contract RecurringCollectorCollectTest is RecurringCollectorSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_Collect_Revert_WhenInvalidData(address caller, uint8 unboundedPaymentType, bytes memory data) public {
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorInvalidCollectData.selector,
+            data
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(caller);
+        _recurringCollector.collect(_paymentType(unboundedPaymentType), data);
+    }
+
+    function test_Collect_Revert_WhenCallerNotDataService(
+        FuzzyTestCollect calldata fuzzy,
+        address notDataService
+    ) public {
+        vm.assume(fuzzy.fuzzyTestAccept.rca.dataService != notDataService);
+
+        (, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(fuzzy.fuzzyTestAccept);
+        IRecurringCollector.CollectParams memory collectParams = fuzzy.collectParams;
+
+        skip(1);
+        collectParams.agreementId = agreementId;
+        bytes memory data = _generateCollectData(collectParams);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorDataServiceNotAuthorized.selector,
+            collectParams.agreementId,
+            notDataService
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(notDataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+    }
+
+    function test_Collect_Revert_WhenUnauthorizedDataService(FuzzyTestCollect calldata fuzzy) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzy.fuzzyTestAccept
+        );
+        IRecurringCollector.CollectParams memory collectParams = fuzzy.collectParams;
+        collectParams.agreementId = agreementId;
+        collectParams.tokens = bound(collectParams.tokens, 1, type(uint256).max);
+        bytes memory data = _generateCollectData(collectParams);
+
+        skip(1);
+
+        // Set up the scenario where service provider has no tokens staked with data service
+        // This simulates an unauthorized data service attack
+        _horizonStaking.setProvision(
+            accepted.rca.serviceProvider,
+            accepted.rca.dataService,
+            IHorizonStakingTypes.Provision({
+                tokens: 0, // No tokens staked - this triggers the vulnerability
+                tokensThawing: 0,
+                sharesThawing: 0,
+                maxVerifierCut: 100000,
+                thawingPeriod: 604800,
+                createdAt: uint64(block.timestamp),
+                maxVerifierCutPending: 100000,
+                thawingPeriodPending: 604800,
+                lastParametersStagedAt: 0,
+                thawingNonce: 0
+            })
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorUnauthorizedDataService.selector,
+            accepted.rca.dataService
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+    }
+
+    function test_Collect_Revert_WhenUnknownAgreement(FuzzyTestCollect memory fuzzy, address dataService) public {
+        bytes memory data = _generateCollectData(fuzzy.collectParams);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementNotCollectable.selector,
+            fuzzy.collectParams.agreementId,
+            IRecurringCollector.AgreementNotCollectableReason.InvalidAgreementState
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+    }
+
+    function test_Collect_Revert_WhenCanceledAgreementByServiceProvider(FuzzyTestCollect calldata fuzzy) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzy.fuzzyTestAccept
+        );
+        _cancel(accepted.rca, agreementId, IRecurringCollector.CancelAgreementBy.ServiceProvider);
+        IRecurringCollector.CollectParams memory collectData = fuzzy.collectParams;
+        collectData.tokens = bound(collectData.tokens, 1, type(uint256).max);
+        IRecurringCollector.CollectParams memory collectParams = _generateCollectParams(
+            accepted.rca,
+            agreementId,
+            collectData.collectionId,
+            collectData.tokens,
+            collectData.dataServiceCut
+        );
+        bytes memory data = _generateCollectData(collectParams);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementNotCollectable.selector,
+            collectParams.agreementId,
+            IRecurringCollector.AgreementNotCollectableReason.InvalidAgreementState
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+    }
+
+    function test_Collect_Revert_WhenCollectingTooSoon(
+        FuzzyTestCollect calldata fuzzy,
+        uint256 unboundedCollectionSeconds
+    ) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzy.fuzzyTestAccept
+        );
+
+        skip(accepted.rca.minSecondsPerCollection);
+        bytes memory data = _generateCollectData(
+            _generateCollectParams(
+                accepted.rca,
+                agreementId,
+                fuzzy.collectParams.collectionId,
+                1,
+                fuzzy.collectParams.dataServiceCut
+            )
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+
+        uint256 collectionSeconds = boundSkip(unboundedCollectionSeconds, 1, accepted.rca.minSecondsPerCollection - 1);
+        skip(collectionSeconds);
+
+        IRecurringCollector.CollectParams memory collectParams = _generateCollectParams(
+            accepted.rca,
+            agreementId,
+            fuzzy.collectParams.collectionId,
+            bound(fuzzy.collectParams.tokens, 1, type(uint256).max),
+            fuzzy.collectParams.dataServiceCut
+        );
+        data = _generateCollectData(collectParams);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorCollectionTooSoon.selector,
+            collectParams.agreementId,
+            collectionSeconds,
+            accepted.rca.minSecondsPerCollection
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+    }
+
+    function test_Collect_Revert_WhenCollectingTooLate(
+        FuzzyTestCollect calldata fuzzy,
+        uint256 unboundedFirstCollectionSeconds,
+        uint256 unboundedSecondCollectionSeconds
+    ) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzy.fuzzyTestAccept
+        );
+
+        // skip to collectable time
+
+        skip(
+            boundSkip(
+                unboundedFirstCollectionSeconds,
+                accepted.rca.minSecondsPerCollection,
+                accepted.rca.maxSecondsPerCollection
+            )
+        );
+        bytes memory data = _generateCollectData(
+            _generateCollectParams(
+                accepted.rca,
+                agreementId,
+                fuzzy.collectParams.collectionId,
+                1,
+                fuzzy.collectParams.dataServiceCut
+            )
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+
+        // skip beyond collectable time but still within the agreement endsAt
+        uint256 collectionSeconds = boundSkip(
+            unboundedSecondCollectionSeconds,
+            accepted.rca.maxSecondsPerCollection + 1,
+            accepted.rca.endsAt - block.timestamp
+        );
+        skip(collectionSeconds);
+
+        data = _generateCollectData(
+            _generateCollectParams(
+                accepted.rca,
+                agreementId,
+                fuzzy.collectParams.collectionId,
+                bound(fuzzy.collectParams.tokens, 1, type(uint256).max),
+                fuzzy.collectParams.dataServiceCut
+            )
+        );
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorCollectionTooLate.selector,
+            agreementId,
+            collectionSeconds,
+            accepted.rca.maxSecondsPerCollection
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+    }
+
+    function test_Collect_OK_WhenCollectingTooMuch(
+        FuzzyTestCollect calldata fuzzy,
+        uint256 unboundedInitialCollectionSeconds,
+        uint256 unboundedCollectionSeconds,
+        uint256 unboundedTokens,
+        bool testInitialCollection
+    ) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzy.fuzzyTestAccept
+        );
+
+        if (!testInitialCollection) {
+            // skip to collectable time
+            skip(
+                boundSkip(
+                    unboundedInitialCollectionSeconds,
+                    accepted.rca.minSecondsPerCollection,
+                    accepted.rca.maxSecondsPerCollection
+                )
+            );
+            bytes memory initialData = _generateCollectData(
+                _generateCollectParams(
+                    accepted.rca,
+                    agreementId,
+                    fuzzy.collectParams.collectionId,
+                    1,
+                    fuzzy.collectParams.dataServiceCut
+                )
+            );
+            vm.prank(accepted.rca.dataService);
+            _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), initialData);
+        }
+
+        // skip to collectable time
+        uint256 collectionSeconds = boundSkip(
+            unboundedCollectionSeconds,
+            accepted.rca.minSecondsPerCollection,
+            accepted.rca.maxSecondsPerCollection
+        );
+        skip(collectionSeconds);
+        uint256 maxTokens = accepted.rca.maxOngoingTokensPerSecond * collectionSeconds;
+        maxTokens += testInitialCollection ? accepted.rca.maxInitialTokens : 0;
+        uint256 tokens = bound(unboundedTokens, maxTokens + 1, type(uint256).max);
+        IRecurringCollector.CollectParams memory collectParams = _generateCollectParams(
+            accepted.rca,
+            agreementId,
+            fuzzy.collectParams.collectionId,
+            tokens,
+            fuzzy.collectParams.dataServiceCut
+        );
+        bytes memory data = _generateCollectData(collectParams);
+        vm.prank(accepted.rca.dataService);
+        uint256 collected = _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+        assertEq(collected, maxTokens);
+    }
+
+    function test_Collect_OK(
+        FuzzyTestCollect calldata fuzzy,
+        uint256 unboundedCollectionSeconds,
+        uint256 unboundedTokens
+    ) public {
+        (IRecurringCollector.SignedRCA memory accepted, , bytes16 agreementId) = _sensibleAuthorizeAndAccept(
+            fuzzy.fuzzyTestAccept
+        );
+
+        (bytes memory data, uint256 collectionSeconds, uint256 tokens) = _generateValidCollection(
+            accepted.rca,
+            fuzzy.collectParams,
+            unboundedCollectionSeconds,
+            unboundedTokens
+        );
+
+        skip(collectionSeconds);
+        _expectCollectCallAndEmit(
+            accepted.rca,
+            agreementId,
+            _paymentType(fuzzy.unboundedPaymentType),
+            fuzzy.collectParams,
+            tokens
+        );
+        vm.prank(accepted.rca.dataService);
+        uint256 collected = _recurringCollector.collect(_paymentType(fuzzy.unboundedPaymentType), data);
+        assertEq(collected, tokens);
+    }
+
+    function test_Collect_RevertWhen_ExceedsMaxSlippage() public {
+        // Setup: Create agreement with known parameters
+        IRecurringCollector.RecurringCollectionAgreement memory rca;
+        rca.deadline = uint64(block.timestamp + 1000);
+        rca.endsAt = uint64(block.timestamp + 2000);
+        rca.payer = address(0x123);
+        rca.dataService = address(0x456);
+        rca.serviceProvider = address(0x789);
+        rca.maxInitialTokens = 0; // No initial tokens to keep calculation simple
+        rca.maxOngoingTokensPerSecond = 1 ether; // 1 token per second
+        rca.minSecondsPerCollection = 60; // 1 minute
+        rca.maxSecondsPerCollection = 3600; // 1 hour
+        rca.nonce = 1;
+        rca.metadata = "";
+
+        // Accept the agreement
+        _recurringCollectorHelper.authorizeSignerWithChecks(rca.payer, 1);
+        IRecurringCollector.SignedRCA memory signedRCA = _recurringCollectorHelper.generateSignedRCA(rca, 1);
+        bytes16 agreementId = _accept(signedRCA);
+
+        // Do a first collection to use up initial tokens allowance
+        skip(rca.minSecondsPerCollection);
+        IRecurringCollector.CollectParams memory firstCollection = IRecurringCollector.CollectParams({
+            agreementId: agreementId,
+            collectionId: keccak256("first"),
+            tokens: 1 ether, // Small amount
+            dataServiceCut: 0,
+            receiverDestination: rca.serviceProvider,
+            maxSlippage: type(uint256).max
+        });
+        vm.prank(rca.dataService);
+        _recurringCollector.collect(IGraphPayments.PaymentTypes.IndexingFee, _generateCollectData(firstCollection));
+
+        // Wait minimum collection time again for second collection
+        skip(rca.minSecondsPerCollection);
+
+        // Calculate expected narrowing: max allowed is 60 tokens (60 seconds * 1 token/second)
+        uint256 maxAllowed = rca.maxOngoingTokensPerSecond * rca.minSecondsPerCollection; // 60 tokens
+        uint256 requested = maxAllowed + 50 ether; // Request 110 tokens
+        uint256 expectedSlippage = requested - maxAllowed; // 50 tokens
+        uint256 maxSlippage = expectedSlippage - 1; // Allow up to 49 tokens slippage
+
+        // Create collect params with slippage protection
+        IRecurringCollector.CollectParams memory collectParams = IRecurringCollector.CollectParams({
+            agreementId: agreementId,
+            collectionId: keccak256("test"),
+            tokens: requested,
+            dataServiceCut: 0,
+            receiverDestination: rca.serviceProvider,
+            maxSlippage: maxSlippage
+        });
+
+        bytes memory data = _generateCollectData(collectParams);
+
+        // Expect revert due to excessive slippage (50 > 49)
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                IRecurringCollector.RecurringCollectorExcessiveSlippage.selector,
+                requested,
+                maxAllowed,
+                maxSlippage
+            )
+        );
+        vm.prank(rca.dataService);
+        _recurringCollector.collect(IGraphPayments.PaymentTypes.IndexingFee, data);
+    }
+
+    function test_Collect_OK_WithMaxSlippageDisabled() public {
+        // Setup: Create agreement with known parameters
+        IRecurringCollector.RecurringCollectionAgreement memory rca;
+        rca.deadline = uint64(block.timestamp + 1000);
+        rca.endsAt = uint64(block.timestamp + 2000);
+        rca.payer = address(0x123);
+        rca.dataService = address(0x456);
+        rca.serviceProvider = address(0x789);
+        rca.maxInitialTokens = 0; // No initial tokens to keep calculation simple
+        rca.maxOngoingTokensPerSecond = 1 ether; // 1 token per second
+        rca.minSecondsPerCollection = 60; // 1 minute
+        rca.maxSecondsPerCollection = 3600; // 1 hour
+        rca.nonce = 1;
+        rca.metadata = "";
+
+        // Accept the agreement
+        _recurringCollectorHelper.authorizeSignerWithChecks(rca.payer, 1);
+        IRecurringCollector.SignedRCA memory signedRCA = _recurringCollectorHelper.generateSignedRCA(rca, 1);
+        bytes16 agreementId = _accept(signedRCA);
+
+        // Do a first collection to use up initial tokens allowance
+        skip(rca.minSecondsPerCollection);
+        IRecurringCollector.CollectParams memory firstCollection = IRecurringCollector.CollectParams({
+            agreementId: agreementId,
+            collectionId: keccak256("first"),
+            tokens: 1 ether, // Small amount
+            dataServiceCut: 0,
+            receiverDestination: rca.serviceProvider,
+            maxSlippage: type(uint256).max
+        });
+        vm.prank(rca.dataService);
+        _recurringCollector.collect(IGraphPayments.PaymentTypes.IndexingFee, _generateCollectData(firstCollection));
+
+        // Wait minimum collection time again for second collection
+        skip(rca.minSecondsPerCollection);
+
+        // Calculate expected narrowing: max allowed is 60 tokens (60 seconds * 1 token/second)
+        uint256 maxAllowed = rca.maxOngoingTokensPerSecond * rca.minSecondsPerCollection; // 60 tokens
+        uint256 requested = maxAllowed + 50 ether; // Request 110 tokens (will be narrowed to 60)
+
+        // Create collect params with slippage disabled (type(uint256).max)
+        IRecurringCollector.CollectParams memory collectParams = IRecurringCollector.CollectParams({
+            agreementId: agreementId,
+            collectionId: keccak256("test"),
+            tokens: requested,
+            dataServiceCut: 0,
+            receiverDestination: rca.serviceProvider,
+            maxSlippage: type(uint256).max
+        });
+
+        bytes memory data = _generateCollectData(collectParams);
+
+        // Should succeed despite slippage when maxSlippage is disabled
+        _expectCollectCallAndEmit(
+            rca,
+            agreementId,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            collectParams,
+            maxAllowed // Will collect the narrowed amount
+        );
+
+        vm.prank(rca.dataService);
+        uint256 collected = _recurringCollector.collect(IGraphPayments.PaymentTypes.IndexingFee, data);
+        assertEq(collected, maxAllowed);
+    }
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/shared.t.sol b/packages/horizon/test/unit/payments/recurring-collector/shared.t.sol
new file mode 100644
index 000000000..d59d5f1e2
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/shared.t.sol
@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { Test } from "forge-std/Test.sol";
+
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IPaymentsCollector } from "@graphprotocol/interfaces/contracts/horizon/IPaymentsCollector.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+import { RecurringCollector } from "../../../../contracts/payments/collectors/RecurringCollector.sol";
+
+import { Bounder } from "../../../unit/utils/Bounder.t.sol";
+import { PartialControllerMock } from "../../mocks/PartialControllerMock.t.sol";
+import { HorizonStakingMock } from "../../mocks/HorizonStakingMock.t.sol";
+import { PaymentsEscrowMock } from "./PaymentsEscrowMock.t.sol";
+import { RecurringCollectorHelper } from "./RecurringCollectorHelper.t.sol";
+
+contract RecurringCollectorSharedTest is Test, Bounder {
+    struct FuzzyTestCollect {
+        FuzzyTestAccept fuzzyTestAccept;
+        uint8 unboundedPaymentType;
+        IRecurringCollector.CollectParams collectParams;
+    }
+
+    struct FuzzyTestAccept {
+        IRecurringCollector.RecurringCollectionAgreement rca;
+        uint256 unboundedSignerKey;
+    }
+
+    struct FuzzyTestUpdate {
+        FuzzyTestAccept fuzzyTestAccept;
+        IRecurringCollector.RecurringCollectionAgreementUpdate rcau;
+    }
+
+    RecurringCollector internal _recurringCollector;
+    PaymentsEscrowMock internal _paymentsEscrow;
+    HorizonStakingMock internal _horizonStaking;
+    RecurringCollectorHelper internal _recurringCollectorHelper;
+
+    function setUp() public {
+        _paymentsEscrow = new PaymentsEscrowMock();
+        _horizonStaking = new HorizonStakingMock();
+        PartialControllerMock.Entry[] memory entries = new PartialControllerMock.Entry[](2);
+        entries[0] = PartialControllerMock.Entry({ name: "PaymentsEscrow", addr: address(_paymentsEscrow) });
+        entries[1] = PartialControllerMock.Entry({ name: "Staking", addr: address(_horizonStaking) });
+        _recurringCollector = new RecurringCollector(
+            "RecurringCollector",
+            "1",
+            address(new PartialControllerMock(entries)),
+            1
+        );
+        _recurringCollectorHelper = new RecurringCollectorHelper(_recurringCollector);
+    }
+
+    function _sensibleAuthorizeAndAccept(
+        FuzzyTestAccept calldata _fuzzyTestAccept
+    ) internal returns (IRecurringCollector.SignedRCA memory, uint256 key, bytes16 agreementId) {
+        IRecurringCollector.RecurringCollectionAgreement memory rca = _recurringCollectorHelper.sensibleRCA(
+            _fuzzyTestAccept.rca
+        );
+        key = boundKey(_fuzzyTestAccept.unboundedSignerKey);
+        IRecurringCollector.SignedRCA memory signedRCA;
+        (signedRCA, agreementId) = _authorizeAndAccept(rca, key);
+        return (signedRCA, key, agreementId);
+    }
+
+    // authorizes signer, signs the RCA, and accepts it
+    function _authorizeAndAccept(
+        IRecurringCollector.RecurringCollectionAgreement memory _rca,
+        uint256 _signerKey
+    ) internal returns (IRecurringCollector.SignedRCA memory, bytes16 agreementId) {
+        _recurringCollectorHelper.authorizeSignerWithChecks(_rca.payer, _signerKey);
+        IRecurringCollector.SignedRCA memory signedRCA = _recurringCollectorHelper.generateSignedRCA(_rca, _signerKey);
+
+        agreementId = _accept(signedRCA);
+        return (signedRCA, agreementId);
+    }
+
+    function _accept(IRecurringCollector.SignedRCA memory _signedRCA) internal returns (bytes16) {
+        // Set up valid staking provision by default to allow collections to succeed
+        _setupValidProvision(_signedRCA.rca.serviceProvider, _signedRCA.rca.dataService);
+
+        // Calculate the expected agreement ID for verification
+        bytes16 expectedAgreementId = _recurringCollector.generateAgreementId(
+            _signedRCA.rca.payer,
+            _signedRCA.rca.dataService,
+            _signedRCA.rca.serviceProvider,
+            _signedRCA.rca.deadline,
+            _signedRCA.rca.nonce
+        );
+
+        vm.expectEmit(address(_recurringCollector));
+        emit IRecurringCollector.AgreementAccepted(
+            _signedRCA.rca.dataService,
+            _signedRCA.rca.payer,
+            _signedRCA.rca.serviceProvider,
+            expectedAgreementId,
+            uint64(block.timestamp),
+            _signedRCA.rca.endsAt,
+            _signedRCA.rca.maxInitialTokens,
+            _signedRCA.rca.maxOngoingTokensPerSecond,
+            _signedRCA.rca.minSecondsPerCollection,
+            _signedRCA.rca.maxSecondsPerCollection
+        );
+        vm.prank(_signedRCA.rca.dataService);
+        bytes16 actualAgreementId = _recurringCollector.accept(_signedRCA);
+
+        // Verify the agreement ID matches expectation
+        assertEq(actualAgreementId, expectedAgreementId);
+        return actualAgreementId;
+    }
+
+    function _setupValidProvision(address _serviceProvider, address _dataService) internal {
+        _horizonStaking.setProvision(
+            _serviceProvider,
+            _dataService,
+            IHorizonStakingTypes.Provision({
+                tokens: 1000 ether,
+                tokensThawing: 0,
+                sharesThawing: 0,
+                maxVerifierCut: 100000, // 10%
+                thawingPeriod: 604800, // 7 days
+                createdAt: uint64(block.timestamp),
+                maxVerifierCutPending: 100000,
+                thawingPeriodPending: 604800,
+                lastParametersStagedAt: 0,
+                thawingNonce: 0
+            })
+        );
+    }
+
+    function _cancel(
+        IRecurringCollector.RecurringCollectionAgreement memory _rca,
+        bytes16 _agreementId,
+        IRecurringCollector.CancelAgreementBy _by
+    ) internal {
+        vm.expectEmit(address(_recurringCollector));
+        emit IRecurringCollector.AgreementCanceled(
+            _rca.dataService,
+            _rca.payer,
+            _rca.serviceProvider,
+            _agreementId,
+            uint64(block.timestamp),
+            _by
+        );
+        vm.prank(_rca.dataService);
+        _recurringCollector.cancel(_agreementId, _by);
+    }
+
+    function _expectCollectCallAndEmit(
+        IRecurringCollector.RecurringCollectionAgreement memory _rca,
+        bytes16 _agreementId,
+        IGraphPayments.PaymentTypes __paymentType,
+        IRecurringCollector.CollectParams memory _fuzzyParams,
+        uint256 _tokens
+    ) internal {
+        vm.expectCall(
+            address(_paymentsEscrow),
+            abi.encodeCall(
+                _paymentsEscrow.collect,
+                (
+                    __paymentType,
+                    _rca.payer,
+                    _rca.serviceProvider,
+                    _tokens,
+                    _rca.dataService,
+                    _fuzzyParams.dataServiceCut,
+                    _rca.serviceProvider
+                )
+            )
+        );
+        vm.expectEmit(address(_recurringCollector));
+        emit IPaymentsCollector.PaymentCollected(
+            __paymentType,
+            _fuzzyParams.collectionId,
+            _rca.payer,
+            _rca.serviceProvider,
+            _rca.dataService,
+            _tokens
+        );
+
+        vm.expectEmit(address(_recurringCollector));
+        emit IRecurringCollector.RCACollected(
+            _rca.dataService,
+            _rca.payer,
+            _rca.serviceProvider,
+            _agreementId,
+            _fuzzyParams.collectionId,
+            _tokens,
+            _fuzzyParams.dataServiceCut
+        );
+    }
+
+    function _generateValidCollection(
+        IRecurringCollector.RecurringCollectionAgreement memory _rca,
+        IRecurringCollector.CollectParams memory _fuzzyParams,
+        uint256 _unboundedCollectionSkip,
+        uint256 _unboundedTokens
+    ) internal view returns (bytes memory, uint256, uint256) {
+        uint256 collectionSeconds = boundSkip(
+            _unboundedCollectionSkip,
+            _rca.minSecondsPerCollection,
+            _rca.maxSecondsPerCollection
+        );
+        uint256 tokens = bound(_unboundedTokens, 1, _rca.maxOngoingTokensPerSecond * collectionSeconds);
+
+        // Generate the agreement ID deterministically
+        bytes16 agreementId = _recurringCollector.generateAgreementId(
+            _rca.payer,
+            _rca.dataService,
+            _rca.serviceProvider,
+            _rca.deadline,
+            _rca.nonce
+        );
+
+        bytes memory data = _generateCollectData(
+            _generateCollectParams(_rca, agreementId, _fuzzyParams.collectionId, tokens, _fuzzyParams.dataServiceCut)
+        );
+
+        return (data, collectionSeconds, tokens);
+    }
+
+    function _generateCollectParams(
+        IRecurringCollector.RecurringCollectionAgreement memory _rca,
+        bytes16 _agreementId,
+        bytes32 _collectionId,
+        uint256 _tokens,
+        uint256 _dataServiceCut
+    ) internal pure returns (IRecurringCollector.CollectParams memory) {
+        return
+            IRecurringCollector.CollectParams({
+                agreementId: _agreementId,
+                collectionId: _collectionId,
+                tokens: _tokens,
+                dataServiceCut: _dataServiceCut,
+                receiverDestination: _rca.serviceProvider,
+                maxSlippage: type(uint256).max
+            });
+    }
+
+    function _generateCollectData(
+        IRecurringCollector.CollectParams memory _params
+    ) internal pure returns (bytes memory) {
+        return abi.encode(_params);
+    }
+
+    function _fuzzyCancelAgreementBy(uint8 _seed) internal pure returns (IRecurringCollector.CancelAgreementBy) {
+        return
+            IRecurringCollector.CancelAgreementBy(
+                bound(_seed, 0, uint256(IRecurringCollector.CancelAgreementBy.Payer))
+            );
+    }
+
+    function _paymentType(uint8 _unboundedPaymentType) internal pure returns (IGraphPayments.PaymentTypes) {
+        return
+            IGraphPayments.PaymentTypes(
+                bound(
+                    _unboundedPaymentType,
+                    uint256(type(IGraphPayments.PaymentTypes).min),
+                    uint256(type(IGraphPayments.PaymentTypes).max)
+                )
+            );
+    }
+}
diff --git a/packages/horizon/test/unit/payments/recurring-collector/update.t.sol b/packages/horizon/test/unit/payments/recurring-collector/update.t.sol
new file mode 100644
index 000000000..951d271d9
--- /dev/null
+++ b/packages/horizon/test/unit/payments/recurring-collector/update.t.sol
@@ -0,0 +1,324 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+
+import { RecurringCollectorSharedTest } from "./shared.t.sol";
+
+contract RecurringCollectorUpdateTest is RecurringCollectorSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+
+    function test_Update_Revert_WhenUpdateElapsed(
+        IRecurringCollector.RecurringCollectionAgreement memory rca,
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau,
+        uint256 unboundedUpdateSkip
+    ) public {
+        rca = _recurringCollectorHelper.sensibleRCA(rca);
+        rcau = _recurringCollectorHelper.sensibleRCAU(rcau);
+        // Generate deterministic agreement ID
+        bytes16 agreementId = _recurringCollector.generateAgreementId(
+            rca.payer,
+            rca.dataService,
+            rca.serviceProvider,
+            rca.deadline,
+            rca.nonce
+        );
+        rcau.agreementId = agreementId;
+
+        boundSkipCeil(unboundedUpdateSkip, type(uint64).max);
+        rcau.deadline = uint64(bound(rcau.deadline, 0, block.timestamp - 1));
+        IRecurringCollector.SignedRCAU memory signedRCAU = IRecurringCollector.SignedRCAU({
+            rcau: rcau,
+            signature: ""
+        });
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementDeadlineElapsed.selector,
+            block.timestamp,
+            rcau.deadline
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(rca.dataService);
+        _recurringCollector.update(signedRCAU);
+    }
+
+    function test_Update_Revert_WhenNeverAccepted(
+        IRecurringCollector.RecurringCollectionAgreement memory rca,
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau
+    ) public {
+        rca = _recurringCollectorHelper.sensibleRCA(rca);
+        rcau = _recurringCollectorHelper.sensibleRCAU(rcau);
+        // Generate deterministic agreement ID
+        bytes16 agreementId = _recurringCollector.generateAgreementId(
+            rca.payer,
+            rca.dataService,
+            rca.serviceProvider,
+            rca.deadline,
+            rca.nonce
+        );
+        rcau.agreementId = agreementId;
+
+        rcau.deadline = uint64(block.timestamp);
+        IRecurringCollector.SignedRCAU memory signedRCAU = IRecurringCollector.SignedRCAU({
+            rcau: rcau,
+            signature: ""
+        });
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorAgreementIncorrectState.selector,
+            rcau.agreementId,
+            IRecurringCollector.AgreementState.NotAccepted
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(rca.dataService);
+        _recurringCollector.update(signedRCAU);
+    }
+
+    function test_Update_Revert_WhenDataServiceNotAuthorized(
+        FuzzyTestUpdate calldata fuzzyTestUpdate,
+        address notDataService
+    ) public {
+        vm.assume(fuzzyTestUpdate.fuzzyTestAccept.rca.dataService != notDataService);
+        (, uint256 signerKey, bytes16 agreementId) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau.agreementId = agreementId;
+
+        IRecurringCollector.SignedRCAU memory signedRCAU = _recurringCollectorHelper.generateSignedRCAUWithCorrectNonce(
+            rcau,
+            signerKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorDataServiceNotAuthorized.selector,
+            signedRCAU.rcau.agreementId,
+            notDataService
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(notDataService);
+        _recurringCollector.update(signedRCAU);
+    }
+
+    function test_Update_Revert_WhenInvalidSigner(
+        FuzzyTestUpdate calldata fuzzyTestUpdate,
+        uint256 unboundedInvalidSignerKey
+    ) public {
+        (
+            IRecurringCollector.SignedRCA memory accepted,
+            uint256 signerKey,
+            bytes16 agreementId
+        ) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+        uint256 invalidSignerKey = boundKey(unboundedInvalidSignerKey);
+        vm.assume(signerKey != invalidSignerKey);
+
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau.agreementId = agreementId;
+
+        IRecurringCollector.SignedRCAU memory signedRCAU = _recurringCollectorHelper.generateSignedRCAU(
+            rcau,
+            invalidSignerKey
+        );
+
+        vm.expectRevert(IRecurringCollector.RecurringCollectorInvalidSigner.selector);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU);
+    }
+
+    function test_Update_OK(FuzzyTestUpdate calldata fuzzyTestUpdate) public {
+        (
+            IRecurringCollector.SignedRCA memory accepted,
+            uint256 signerKey,
+            bytes16 agreementId
+        ) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau.agreementId = agreementId;
+        // Don't use fuzzed nonce - use correct nonce for first update
+        rcau.nonce = 1;
+        IRecurringCollector.SignedRCAU memory signedRCAU = _recurringCollectorHelper.generateSignedRCAU(
+            rcau,
+            signerKey
+        );
+
+        vm.expectEmit(address(_recurringCollector));
+        emit IRecurringCollector.AgreementUpdated(
+            accepted.rca.dataService,
+            accepted.rca.payer,
+            accepted.rca.serviceProvider,
+            rcau.agreementId,
+            uint64(block.timestamp),
+            rcau.endsAt,
+            rcau.maxInitialTokens,
+            rcau.maxOngoingTokensPerSecond,
+            rcau.minSecondsPerCollection,
+            rcau.maxSecondsPerCollection
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU);
+
+        IRecurringCollector.AgreementData memory agreement = _recurringCollector.getAgreement(agreementId);
+        assertEq(rcau.endsAt, agreement.endsAt);
+        assertEq(rcau.maxInitialTokens, agreement.maxInitialTokens);
+        assertEq(rcau.maxOngoingTokensPerSecond, agreement.maxOngoingTokensPerSecond);
+        assertEq(rcau.minSecondsPerCollection, agreement.minSecondsPerCollection);
+        assertEq(rcau.maxSecondsPerCollection, agreement.maxSecondsPerCollection);
+        assertEq(rcau.nonce, agreement.updateNonce);
+    }
+
+    function test_Update_Revert_WhenInvalidNonce_TooLow(FuzzyTestUpdate calldata fuzzyTestUpdate) public {
+        (
+            IRecurringCollector.SignedRCA memory accepted,
+            uint256 signerKey,
+            bytes16 agreementId
+        ) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau.agreementId = agreementId;
+        rcau.nonce = 0; // Invalid: should be 1 for first update
+
+        IRecurringCollector.SignedRCAU memory signedRCAU = _recurringCollectorHelper.generateSignedRCAU(
+            rcau,
+            signerKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorInvalidUpdateNonce.selector,
+            rcau.agreementId,
+            1, // expected
+            0 // provided
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU);
+    }
+
+    function test_Update_Revert_WhenInvalidNonce_TooHigh(FuzzyTestUpdate calldata fuzzyTestUpdate) public {
+        (
+            IRecurringCollector.SignedRCA memory accepted,
+            uint256 signerKey,
+            bytes16 agreementId
+        ) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau.agreementId = agreementId;
+        rcau.nonce = 5; // Invalid: should be 1 for first update
+
+        IRecurringCollector.SignedRCAU memory signedRCAU = _recurringCollectorHelper.generateSignedRCAU(
+            rcau,
+            signerKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorInvalidUpdateNonce.selector,
+            rcau.agreementId,
+            1, // expected
+            5 // provided
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU);
+    }
+
+    function test_Update_Revert_WhenReplayAttack(FuzzyTestUpdate calldata fuzzyTestUpdate) public {
+        (
+            IRecurringCollector.SignedRCA memory accepted,
+            uint256 signerKey,
+            bytes16 agreementId
+        ) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau1 = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau1.agreementId = agreementId;
+        rcau1.nonce = 1;
+
+        // First update succeeds
+        IRecurringCollector.SignedRCAU memory signedRCAU1 = _recurringCollectorHelper.generateSignedRCAU(
+            rcau1,
+            signerKey
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU1);
+
+        // Second update with different terms and nonce 2 succeeds
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau2 = rcau1;
+        rcau2.nonce = 2;
+        rcau2.maxOngoingTokensPerSecond = rcau1.maxOngoingTokensPerSecond * 2; // Different terms
+
+        IRecurringCollector.SignedRCAU memory signedRCAU2 = _recurringCollectorHelper.generateSignedRCAU(
+            rcau2,
+            signerKey
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU2);
+
+        // Attempting to replay first update should fail
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IRecurringCollector.RecurringCollectorInvalidUpdateNonce.selector,
+            rcau1.agreementId,
+            3, // expected (current nonce + 1)
+            1 // provided (old nonce)
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU1);
+    }
+
+    function test_Update_OK_NonceIncrementsCorrectly(FuzzyTestUpdate calldata fuzzyTestUpdate) public {
+        (
+            IRecurringCollector.SignedRCA memory accepted,
+            uint256 signerKey,
+            bytes16 agreementId
+        ) = _sensibleAuthorizeAndAccept(fuzzyTestUpdate.fuzzyTestAccept);
+
+        // Initial nonce should be 0
+        IRecurringCollector.AgreementData memory initialAgreement = _recurringCollector.getAgreement(agreementId);
+        assertEq(initialAgreement.updateNonce, 0);
+
+        // First update with nonce 1
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau1 = _recurringCollectorHelper.sensibleRCAU(
+            fuzzyTestUpdate.rcau
+        );
+        rcau1.agreementId = agreementId;
+        rcau1.nonce = 1;
+
+        IRecurringCollector.SignedRCAU memory signedRCAU1 = _recurringCollectorHelper.generateSignedRCAU(
+            rcau1,
+            signerKey
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU1);
+
+        // Verify nonce incremented to 1
+        IRecurringCollector.AgreementData memory updatedAgreement1 = _recurringCollector.getAgreement(agreementId);
+        assertEq(updatedAgreement1.updateNonce, 1);
+
+        // Second update with nonce 2
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau2 = rcau1;
+        rcau2.nonce = 2;
+        rcau2.maxOngoingTokensPerSecond = rcau1.maxOngoingTokensPerSecond * 2; // Different terms
+
+        IRecurringCollector.SignedRCAU memory signedRCAU2 = _recurringCollectorHelper.generateSignedRCAU(
+            rcau2,
+            signerKey
+        );
+        vm.prank(accepted.rca.dataService);
+        _recurringCollector.update(signedRCAU2);
+
+        // Verify nonce incremented to 2
+        IRecurringCollector.AgreementData memory updatedAgreement2 = _recurringCollector.getAgreement(agreementId);
+        assertEq(updatedAgreement2.updateNonce, 2);
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/horizon/test/unit/shared/horizon-staking/HorizonStakingShared.t.sol b/packages/horizon/test/unit/shared/horizon-staking/HorizonStakingShared.t.sol
index 27b4aeca9..4866d02bb 100644
--- a/packages/horizon/test/unit/shared/horizon-staking/HorizonStakingShared.t.sol
+++ b/packages/horizon/test/unit/shared/horizon-staking/HorizonStakingShared.t.sol
@@ -3,16 +3,13 @@ pragma solidity 0.8.27;
 
 import { GraphBaseTest } from "../../GraphBase.t.sol";
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
-import { IHorizonStakingBase } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingBase.sol";
 import { IHorizonStakingMain } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol";
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
 import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 
 import { LinkedList } from "../../../../contracts/libraries/LinkedList.sol";
-import { MathUtils } from "../../../../contracts/libraries/MathUtils.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
 import { PPMMath } from "../../../../contracts/libraries/PPMMath.sol";
-import { ExponentialRebates } from "../../../../contracts/staking/libraries/ExponentialRebates.sol";
 
 abstract contract HorizonStakingSharedTest is GraphBaseTest {
     using LinkedList for ILinkedList.List;
@@ -21,13 +18,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
     event Transfer(address indexed from, address indexed to, uint tokens);
 
     address internal _allocationId = makeAddr("allocationId");
-    bytes32 internal constant _SUBGRAPH_DEPLOYMENT_ID = keccak256("subgraphDeploymentID");
-    uint256 internal constant MAX_ALLOCATION_EPOCHS = 28;
-
-    uint32 internal alphaNumerator = 100;
-    uint32 internal alphaDenominator = 100;
-    uint32 internal lambdaNumerator = 60;
-    uint32 internal lambdaDenominator = 100;
 
     /*
      * MODIFIERS
@@ -78,17 +68,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         _createProvision(users.indexer, dataService, tokens, maxVerifierCut, thawingPeriod);
     }
 
-    modifier useAllocation(uint256 tokens) {
-        vm.assume(tokens <= MAX_STAKING_TOKENS);
-        _createAllocation(users.indexer, _allocationId, _SUBGRAPH_DEPLOYMENT_ID, tokens);
-        _;
-    }
-
-    modifier useRebateParameters() {
-        _setStorageRebateParameters(alphaNumerator, alphaDenominator, lambdaNumerator, lambdaDenominator);
-        _;
-    }
-
     /*
      * HELPERS: these are shortcuts to perform common actions that often involve multiple contract calls
      */
@@ -103,34 +82,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         _provision(serviceProvider, verifier, tokens, maxVerifierCut, thawingPeriod);
     }
 
-    // This allows setting up contract state with legacy allocations
-    function _createAllocation(
-        address serviceProvider,
-        address allocationId,
-        bytes32 subgraphDeploymentId,
-        uint256 tokens
-    ) internal {
-        _setStorageMaxAllocationEpochs(MAX_ALLOCATION_EPOCHS);
-
-        IHorizonStakingExtension.Allocation memory _allocation = IHorizonStakingExtension.Allocation({
-            indexer: serviceProvider,
-            subgraphDeploymentID: subgraphDeploymentId,
-            tokens: tokens,
-            createdAtEpoch: block.timestamp,
-            closedAtEpoch: 0,
-            collectedFees: 0,
-            __DEPRECATED_effectiveAllocation: 0,
-            accRewardsPerAllocatedToken: 0,
-            distributedRebates: 0
-        });
-        _setStorageAllocation(_allocation, allocationId, tokens);
-
-        // delegation pool initialized
-        _setStorageDelegationPool(serviceProvider, 0, uint32(PPMMath.MAX_PPM), uint32(PPMMath.MAX_PPM));
-
-        require(token.transfer(address(staking), tokens), "Transfer failed");
-    }
-
     /*
      * ACTIONS: these are individual contract calls wrapped in assertion blocks to ensure they work as expected
      */
@@ -150,7 +101,7 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         // stakeTo
         token.approve(address(staking), tokens);
         vm.expectEmit();
-        emit IHorizonStakingBase.HorizonStakeDeposited(serviceProvider, tokens);
+        emit IHorizonStakingMain.HorizonStakeDeposited(serviceProvider, tokens);
         staking.stakeTo(serviceProvider, tokens);
 
         // after
@@ -183,7 +134,7 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         // stakeTo
         token.approve(address(staking), tokens);
         vm.expectEmit();
-        emit IHorizonStakingBase.HorizonStakeDeposited(serviceProvider, tokens);
+        emit IHorizonStakingMain.HorizonStakeDeposited(serviceProvider, tokens);
         vm.expectEmit();
         emit IHorizonStakingMain.ProvisionIncreased(serviceProvider, verifier, tokens);
         staking.stakeToProvision(serviceProvider, verifier, tokens);
@@ -230,48 +181,15 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
     function _unstake(uint256 _tokens) internal {
         (, address msgSender, ) = vm.readCallers();
 
-        uint256 deprecatedThawingPeriod = staking.__DEPRECATED_getThawingPeriod();
-
         // before
         uint256 beforeSenderBalance = token.balanceOf(msgSender);
         uint256 beforeStakingBalance = token.balanceOf(address(staking));
         ServiceProviderInternal memory beforeServiceProvider = _getStorageServiceProviderInternal(msgSender);
 
-        bool withdrawCalled = beforeServiceProvider.__DEPRECATED_tokensLocked != 0 &&
-            block.number >= beforeServiceProvider.__DEPRECATED_tokensLockedUntil;
-
-        if (deprecatedThawingPeriod != 0 && beforeServiceProvider.__DEPRECATED_tokensLocked > 0) {
-            deprecatedThawingPeriod = MathUtils.weightedAverageRoundingUp(
-                MathUtils.diffOrZero(
-                    withdrawCalled ? 0 : beforeServiceProvider.__DEPRECATED_tokensLockedUntil,
-                    block.number
-                ),
-                withdrawCalled ? 0 : beforeServiceProvider.__DEPRECATED_tokensLocked,
-                deprecatedThawingPeriod,
-                _tokens
-            );
-        }
-
         // unstake
-        if (deprecatedThawingPeriod == 0) {
-            vm.expectEmit(address(staking));
-            emit IHorizonStakingMain.HorizonStakeWithdrawn(msgSender, _tokens);
-        } else {
-            if (withdrawCalled) {
-                vm.expectEmit(address(staking));
-                emit IHorizonStakingMain.HorizonStakeWithdrawn(
-                    msgSender,
-                    beforeServiceProvider.__DEPRECATED_tokensLocked
-                );
-            }
+        vm.expectEmit(address(staking));
+        emit IHorizonStakingMain.HorizonStakeWithdrawn(msgSender, _tokens);
 
-            vm.expectEmit(address(staking));
-            emit IHorizonStakingMain.HorizonStakeLocked(
-                msgSender,
-                withdrawCalled ? _tokens : beforeServiceProvider.__DEPRECATED_tokensLocked + _tokens,
-                block.number + deprecatedThawingPeriod
-            );
-        }
         staking.unstake(_tokens);
 
         // after
@@ -280,41 +198,16 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         ServiceProviderInternal memory afterServiceProvider = _getStorageServiceProviderInternal(msgSender);
 
         // assert
-        if (deprecatedThawingPeriod == 0) {
-            assertEq(afterSenderBalance, _tokens + beforeSenderBalance);
-            assertEq(afterStakingBalance, beforeStakingBalance - _tokens);
-            assertEq(afterServiceProvider.tokensStaked, beforeServiceProvider.tokensStaked - _tokens);
-            assertEq(afterServiceProvider.tokensProvisioned, beforeServiceProvider.tokensProvisioned);
-            assertEq(
-                afterServiceProvider.__DEPRECATED_tokensAllocated,
-                beforeServiceProvider.__DEPRECATED_tokensAllocated
-            );
-            assertEq(afterServiceProvider.__DEPRECATED_tokensLocked, beforeServiceProvider.__DEPRECATED_tokensLocked);
-            assertEq(
-                afterServiceProvider.__DEPRECATED_tokensLockedUntil,
-                beforeServiceProvider.__DEPRECATED_tokensLockedUntil
-            );
-        } else {
-            assertEq(
-                afterServiceProvider.tokensStaked,
-                withdrawCalled
-                    ? beforeServiceProvider.tokensStaked - beforeServiceProvider.__DEPRECATED_tokensLocked
-                    : beforeServiceProvider.tokensStaked
-            );
-            assertEq(
-                afterServiceProvider.__DEPRECATED_tokensLocked,
-                _tokens + (withdrawCalled ? 0 : beforeServiceProvider.__DEPRECATED_tokensLocked)
-            );
-            assertEq(afterServiceProvider.__DEPRECATED_tokensLockedUntil, block.number + deprecatedThawingPeriod);
-            assertEq(afterServiceProvider.tokensProvisioned, beforeServiceProvider.tokensProvisioned);
-            assertEq(
-                afterServiceProvider.__DEPRECATED_tokensAllocated,
-                beforeServiceProvider.__DEPRECATED_tokensAllocated
-            );
-            uint256 tokensTransferred = (withdrawCalled ? beforeServiceProvider.__DEPRECATED_tokensLocked : 0);
-            assertEq(afterSenderBalance, beforeSenderBalance + tokensTransferred);
-            assertEq(afterStakingBalance, beforeStakingBalance - tokensTransferred);
-        }
+        assertEq(afterSenderBalance, _tokens + beforeSenderBalance);
+        assertEq(afterStakingBalance, beforeStakingBalance - _tokens);
+        assertEq(afterServiceProvider.tokensStaked, beforeServiceProvider.tokensStaked - _tokens);
+        assertEq(afterServiceProvider.tokensProvisioned, beforeServiceProvider.tokensProvisioned);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensAllocated, beforeServiceProvider.__DEPRECATED_tokensAllocated);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensLocked, beforeServiceProvider.__DEPRECATED_tokensLocked);
+        assertEq(
+            afterServiceProvider.__DEPRECATED_tokensLockedUntil,
+            beforeServiceProvider.__DEPRECATED_tokensLockedUntil
+        );
     }
 
     function _withdraw() internal {
@@ -1453,19 +1346,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         assertEq(afterEnabled, true);
     }
 
-    function _clearThawingPeriod() internal {
-        // clearThawingPeriod
-        vm.expectEmit(address(staking));
-        emit IHorizonStakingMain.ThawingPeriodCleared();
-        staking.clearThawingPeriod();
-
-        // after
-        uint64 afterThawingPeriod = staking.__DEPRECATED_getThawingPeriod();
-
-        // assert
-        assertEq(afterThawingPeriod, 0);
-    }
-
     function _setMaxThawingPeriod(uint64 maxThawingPeriod) internal {
         // setMaxThawingPeriod
         vm.expectEmit(address(staking));
@@ -1509,8 +1389,8 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
 
         // Calculate expected tokens after slashing
         CalcValuesSlash memory calcValues;
-        calcValues.tokensToSlash = MathUtils.min(tokens, before.provision.tokens + before.pool.tokens);
-        calcValues.providerTokensSlashed = MathUtils.min(before.provision.tokens, calcValues.tokensToSlash);
+        calcValues.tokensToSlash = Math.min(tokens, before.provision.tokens + before.pool.tokens);
+        calcValues.providerTokensSlashed = Math.min(before.provision.tokens, calcValues.tokensToSlash);
         calcValues.delegationTokensSlashed = calcValues.tokensToSlash - calcValues.providerTokensSlashed;
 
         if (calcValues.tokensToSlash > 0) {
@@ -1612,314 +1492,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         }
     }
 
-    // use struct to avoid 'stack too deep' error
-    struct CalcValuesCloseAllocation {
-        uint256 rewards;
-        uint256 delegatorRewards;
-        uint256 indexerRewards;
-    }
-    struct BeforeValuesCloseAllocation {
-        IHorizonStakingExtension.Allocation allocation;
-        DelegationPoolInternalTest pool;
-        ServiceProviderInternal serviceProvider;
-        uint256 subgraphAllocations;
-        uint256 stakingBalance;
-        uint256 indexerBalance;
-        uint256 beneficiaryBalance;
-    }
-
-    // Current rewards manager is mocked and assumed to mint fixed rewards
-    function _closeAllocation(address allocationId, bytes32 poi) internal {
-        (, address msgSender, ) = vm.readCallers();
-
-        // before
-        BeforeValuesCloseAllocation memory beforeValues;
-        beforeValues.allocation = staking.getAllocation(allocationId);
-        beforeValues.pool = _getStorageDelegationPoolInternal(
-            beforeValues.allocation.indexer,
-            subgraphDataServiceLegacyAddress,
-            true
-        );
-        beforeValues.serviceProvider = _getStorageServiceProviderInternal(beforeValues.allocation.indexer);
-        beforeValues.subgraphAllocations = _getStorageSubgraphAllocations(beforeValues.allocation.subgraphDeploymentID);
-        beforeValues.stakingBalance = token.balanceOf(address(staking));
-        beforeValues.indexerBalance = token.balanceOf(beforeValues.allocation.indexer);
-        beforeValues.beneficiaryBalance = token.balanceOf(
-            _getStorageRewardsDestination(beforeValues.allocation.indexer)
-        );
-
-        bool isAuth = staking.isAuthorized(
-            beforeValues.allocation.indexer,
-            subgraphDataServiceLegacyAddress,
-            msgSender
-        );
-        address rewardsDestination = _getStorageRewardsDestination(beforeValues.allocation.indexer);
-
-        CalcValuesCloseAllocation memory calcValues = CalcValuesCloseAllocation({
-            rewards: ALLOCATIONS_REWARD_CUT,
-            delegatorRewards: ALLOCATIONS_REWARD_CUT -
-                uint256(beforeValues.pool.__DEPRECATED_indexingRewardCut).mulPPM(ALLOCATIONS_REWARD_CUT),
-            indexerRewards: 0
-        });
-        calcValues.indexerRewards =
-            ALLOCATIONS_REWARD_CUT - (beforeValues.pool.tokens > 0 ? calcValues.delegatorRewards : 0);
-
-        // closeAllocation
-        vm.expectEmit(address(staking));
-        emit IHorizonStakingExtension.AllocationClosed(
-            beforeValues.allocation.indexer,
-            beforeValues.allocation.subgraphDeploymentID,
-            epochManager.currentEpoch(),
-            beforeValues.allocation.tokens,
-            allocationId,
-            msgSender,
-            poi,
-            !isAuth
-        );
-        staking.closeAllocation(allocationId, poi);
-
-        // after
-        IHorizonStakingExtension.Allocation memory afterAllocation = staking.getAllocation(allocationId);
-        DelegationPoolInternalTest memory afterPool = _getStorageDelegationPoolInternal(
-            beforeValues.allocation.indexer,
-            subgraphDataServiceLegacyAddress,
-            true
-        );
-        ServiceProviderInternal memory afterServiceProvider = _getStorageServiceProviderInternal(
-            beforeValues.allocation.indexer
-        );
-        uint256 afterSubgraphAllocations = _getStorageSubgraphAllocations(beforeValues.allocation.subgraphDeploymentID);
-        uint256 afterStakingBalance = token.balanceOf(address(staking));
-        uint256 afterIndexerBalance = token.balanceOf(beforeValues.allocation.indexer);
-        uint256 afterBeneficiaryBalance = token.balanceOf(rewardsDestination);
-
-        if (beforeValues.allocation.tokens > 0) {
-            if (isAuth && poi != 0) {
-                if (rewardsDestination != address(0)) {
-                    assertEq(
-                        beforeValues.stakingBalance + calcValues.rewards - calcValues.indexerRewards,
-                        afterStakingBalance
-                    );
-                    assertEq(beforeValues.indexerBalance, afterIndexerBalance);
-                    assertEq(beforeValues.beneficiaryBalance + calcValues.indexerRewards, afterBeneficiaryBalance);
-                } else {
-                    assertEq(beforeValues.stakingBalance + calcValues.rewards, afterStakingBalance);
-                    assertEq(beforeValues.indexerBalance, afterIndexerBalance);
-                    assertEq(beforeValues.beneficiaryBalance, afterBeneficiaryBalance);
-                }
-            } else {
-                assertEq(beforeValues.stakingBalance, afterStakingBalance);
-                assertEq(beforeValues.indexerBalance, afterIndexerBalance);
-                assertEq(beforeValues.beneficiaryBalance, afterBeneficiaryBalance);
-            }
-        } else {
-            assertEq(beforeValues.stakingBalance, afterStakingBalance);
-            assertEq(beforeValues.indexerBalance, afterIndexerBalance);
-            assertEq(beforeValues.beneficiaryBalance, afterBeneficiaryBalance);
-        }
-
-        assertEq(afterAllocation.indexer, beforeValues.allocation.indexer);
-        assertEq(afterAllocation.subgraphDeploymentID, beforeValues.allocation.subgraphDeploymentID);
-        assertEq(afterAllocation.tokens, beforeValues.allocation.tokens);
-        assertEq(afterAllocation.createdAtEpoch, beforeValues.allocation.createdAtEpoch);
-        assertEq(afterAllocation.closedAtEpoch, epochManager.currentEpoch());
-        assertEq(afterAllocation.collectedFees, beforeValues.allocation.collectedFees);
-        assertEq(
-            afterAllocation.__DEPRECATED_effectiveAllocation,
-            beforeValues.allocation.__DEPRECATED_effectiveAllocation
-        );
-        assertEq(afterAllocation.accRewardsPerAllocatedToken, beforeValues.allocation.accRewardsPerAllocatedToken);
-        assertEq(afterAllocation.distributedRebates, beforeValues.allocation.distributedRebates);
-
-        if (beforeValues.allocation.tokens > 0 && isAuth && poi != 0 && rewardsDestination == address(0)) {
-            assertEq(
-                afterServiceProvider.tokensStaked,
-                beforeValues.serviceProvider.tokensStaked + calcValues.indexerRewards
-            );
-        } else {
-            assertEq(afterServiceProvider.tokensStaked, beforeValues.serviceProvider.tokensStaked);
-        }
-        assertEq(afterServiceProvider.tokensProvisioned, beforeValues.serviceProvider.tokensProvisioned);
-        assertEq(
-            afterServiceProvider.__DEPRECATED_tokensAllocated + beforeValues.allocation.tokens,
-            beforeValues.serviceProvider.__DEPRECATED_tokensAllocated
-        );
-        assertEq(
-            afterServiceProvider.__DEPRECATED_tokensLocked,
-            beforeValues.serviceProvider.__DEPRECATED_tokensLocked
-        );
-        assertEq(
-            afterServiceProvider.__DEPRECATED_tokensLockedUntil,
-            beforeValues.serviceProvider.__DEPRECATED_tokensLockedUntil
-        );
-
-        assertEq(afterSubgraphAllocations + beforeValues.allocation.tokens, beforeValues.subgraphAllocations);
-
-        if (beforeValues.allocation.tokens > 0 && isAuth && poi != 0 && beforeValues.pool.tokens > 0) {
-            assertEq(afterPool.tokens, beforeValues.pool.tokens + calcValues.delegatorRewards);
-        } else {
-            assertEq(afterPool.tokens, beforeValues.pool.tokens);
-        }
-    }
-
-    // use struct to avoid 'stack too deep' error
-    struct BeforeValuesCollect {
-        IHorizonStakingExtension.Allocation allocation;
-        DelegationPoolInternalTest pool;
-        ServiceProviderInternal serviceProvider;
-        uint256 stakingBalance;
-        uint256 senderBalance;
-        uint256 curationBalance;
-        uint256 beneficiaryBalance;
-    }
-    struct CalcValuesCollect {
-        uint256 protocolTaxTokens;
-        uint256 queryFees;
-        uint256 curationCutTokens;
-        uint256 newRebates;
-        uint256 payment;
-        uint256 delegationFeeCut;
-    }
-    struct AfterValuesCollect {
-        IHorizonStakingExtension.Allocation allocation;
-        DelegationPoolInternalTest pool;
-        ServiceProviderInternal serviceProvider;
-        uint256 stakingBalance;
-        uint256 senderBalance;
-        uint256 curationBalance;
-        uint256 beneficiaryBalance;
-    }
-
-    function _collect(uint256 tokens, address allocationId) internal {
-        (, address msgSender, ) = vm.readCallers();
-
-        // before
-        BeforeValuesCollect memory beforeValues;
-        beforeValues.allocation = staking.getAllocation(allocationId);
-        beforeValues.pool = _getStorageDelegationPoolInternal(
-            beforeValues.allocation.indexer,
-            subgraphDataServiceLegacyAddress,
-            true
-        );
-        beforeValues.serviceProvider = _getStorageServiceProviderInternal(beforeValues.allocation.indexer);
-
-        (uint32 curationPercentage, uint32 protocolPercentage) = _getStorageProtocolTaxAndCuration();
-        address rewardsDestination = _getStorageRewardsDestination(beforeValues.allocation.indexer);
-
-        beforeValues.stakingBalance = token.balanceOf(address(staking));
-        beforeValues.senderBalance = token.balanceOf(msgSender);
-        beforeValues.curationBalance = token.balanceOf(address(curation));
-        beforeValues.beneficiaryBalance = token.balanceOf(rewardsDestination);
-
-        // calc some stuff
-        CalcValuesCollect memory calcValues;
-        calcValues.protocolTaxTokens = tokens.mulPPMRoundUp(protocolPercentage);
-        calcValues.queryFees = tokens - calcValues.protocolTaxTokens;
-        calcValues.curationCutTokens = 0;
-        if (curation.isCurated(beforeValues.allocation.subgraphDeploymentID)) {
-            calcValues.curationCutTokens = calcValues.queryFees.mulPPMRoundUp(curationPercentage);
-            calcValues.queryFees -= calcValues.curationCutTokens;
-        }
-        calcValues.newRebates = ExponentialRebates.exponentialRebates(
-            calcValues.queryFees + beforeValues.allocation.collectedFees,
-            beforeValues.allocation.tokens,
-            alphaNumerator,
-            alphaDenominator,
-            lambdaNumerator,
-            lambdaDenominator
-        );
-        calcValues.payment = calcValues.newRebates > calcValues.queryFees
-            ? calcValues.queryFees
-            : calcValues.newRebates;
-        calcValues.delegationFeeCut = 0;
-        if (beforeValues.pool.tokens > 0) {
-            calcValues.delegationFeeCut =
-                calcValues.payment - calcValues.payment.mulPPM(beforeValues.pool.__DEPRECATED_queryFeeCut);
-            calcValues.payment -= calcValues.delegationFeeCut;
-        }
-
-        // staking.collect()
-        if (tokens > 0) {
-            vm.expectEmit(address(staking));
-            emit IHorizonStakingExtension.RebateCollected(
-                msgSender,
-                beforeValues.allocation.indexer,
-                beforeValues.allocation.subgraphDeploymentID,
-                allocationId,
-                epochManager.currentEpoch(),
-                tokens,
-                calcValues.protocolTaxTokens,
-                calcValues.curationCutTokens,
-                calcValues.queryFees,
-                calcValues.payment,
-                calcValues.delegationFeeCut
-            );
-        }
-        staking.collect(tokens, allocationId);
-
-        // after
-        AfterValuesCollect memory afterValues;
-        afterValues.allocation = staking.getAllocation(allocationId);
-        afterValues.pool = _getStorageDelegationPoolInternal(
-            beforeValues.allocation.indexer,
-            subgraphDataServiceLegacyAddress,
-            true
-        );
-        afterValues.serviceProvider = _getStorageServiceProviderInternal(beforeValues.allocation.indexer);
-        afterValues.stakingBalance = token.balanceOf(address(staking));
-        afterValues.senderBalance = token.balanceOf(msgSender);
-        afterValues.curationBalance = token.balanceOf(address(curation));
-        afterValues.beneficiaryBalance = token.balanceOf(rewardsDestination);
-
-        // assert
-        assertEq(afterValues.senderBalance + tokens, beforeValues.senderBalance);
-        assertEq(afterValues.curationBalance, beforeValues.curationBalance + calcValues.curationCutTokens);
-        if (rewardsDestination != address(0)) {
-            assertEq(afterValues.beneficiaryBalance, beforeValues.beneficiaryBalance + calcValues.payment);
-            assertEq(afterValues.stakingBalance, beforeValues.stakingBalance + calcValues.delegationFeeCut);
-        } else {
-            assertEq(afterValues.beneficiaryBalance, beforeValues.beneficiaryBalance);
-            assertEq(
-                afterValues.stakingBalance,
-                beforeValues.stakingBalance + calcValues.delegationFeeCut + calcValues.payment
-            );
-        }
-
-        assertEq(
-            afterValues.allocation.collectedFees,
-            beforeValues.allocation.collectedFees + tokens - calcValues.protocolTaxTokens - calcValues.curationCutTokens
-        );
-        assertEq(afterValues.allocation.indexer, beforeValues.allocation.indexer);
-        assertEq(afterValues.allocation.subgraphDeploymentID, beforeValues.allocation.subgraphDeploymentID);
-        assertEq(afterValues.allocation.tokens, beforeValues.allocation.tokens);
-        assertEq(afterValues.allocation.createdAtEpoch, beforeValues.allocation.createdAtEpoch);
-        assertEq(afterValues.allocation.closedAtEpoch, beforeValues.allocation.closedAtEpoch);
-        assertEq(
-            afterValues.allocation.accRewardsPerAllocatedToken,
-            beforeValues.allocation.accRewardsPerAllocatedToken
-        );
-        assertEq(
-            afterValues.allocation.distributedRebates,
-            beforeValues.allocation.distributedRebates + calcValues.newRebates
-        );
-
-        assertEq(afterValues.pool.tokens, beforeValues.pool.tokens + calcValues.delegationFeeCut);
-        assertEq(afterValues.pool.shares, beforeValues.pool.shares);
-        assertEq(afterValues.pool.tokensThawing, beforeValues.pool.tokensThawing);
-        assertEq(afterValues.pool.sharesThawing, beforeValues.pool.sharesThawing);
-        assertEq(afterValues.pool.thawingNonce, beforeValues.pool.thawingNonce);
-
-        assertEq(afterValues.serviceProvider.tokensProvisioned, beforeValues.serviceProvider.tokensProvisioned);
-        if (rewardsDestination != address(0)) {
-            assertEq(afterValues.serviceProvider.tokensStaked, beforeValues.serviceProvider.tokensStaked);
-        } else {
-            assertEq(
-                afterValues.serviceProvider.tokensStaked,
-                beforeValues.serviceProvider.tokensStaked + calcValues.payment
-            );
-        }
-    }
-
     /*
      * STORAGE HELPERS
      */
@@ -1964,22 +1536,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         return vm.load(address(staking), bytes32(slot)) == bytes32(uint256(1));
     }
 
-    function _setStorageDeprecatedThawingPeriod(uint32 _thawingPeriod) internal {
-        uint256 slot = 13;
-
-        // Read the current value of the slot
-        uint256 currentSlotValue = uint256(vm.load(address(staking), bytes32(slot)));
-
-        // Create a mask to clear the bits for __DEPRECATED_thawingPeriod (bits 0-31)
-        uint256 mask = ~(uint256(0xFFFFFFFF)); // Mask to clear the first 32 bits
-
-        // Clear the bits for __DEPRECATED_thawingPeriod and set the new value
-        uint256 newSlotValue = (currentSlotValue & mask) | uint256(_thawingPeriod);
-
-        // Store the updated value back into the slot
-        vm.store(address(staking), bytes32(slot), bytes32(newSlotValue));
-    }
-
     function _setStorageServiceProvider(
         address _indexer,
         uint256 _tokensStaked,
@@ -2091,62 +1647,9 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         return delegation;
     }
 
-    function _setStorageAllocation(
-        IHorizonStakingExtension.Allocation memory allocation,
-        address allocationId,
-        uint256 tokens
-    ) internal {
-        // __DEPRECATED_allocations
-        uint256 allocationsSlot = 15;
-        bytes32 allocationBaseSlot = keccak256(abi.encode(allocationId, allocationsSlot));
-        vm.store(address(staking), allocationBaseSlot, bytes32(uint256(uint160(allocation.indexer))));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 1), allocation.subgraphDeploymentID);
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 2), bytes32(tokens));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 3), bytes32(allocation.createdAtEpoch));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 4), bytes32(allocation.closedAtEpoch));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 5), bytes32(allocation.collectedFees));
-        vm.store(
-            address(staking),
-            bytes32(uint256(allocationBaseSlot) + 6),
-            bytes32(allocation.__DEPRECATED_effectiveAllocation)
-        );
-        vm.store(
-            address(staking),
-            bytes32(uint256(allocationBaseSlot) + 7),
-            bytes32(allocation.accRewardsPerAllocatedToken)
-        );
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 8), bytes32(allocation.distributedRebates));
-
-        // _serviceProviders
-        uint256 serviceProviderSlot = 14;
-        bytes32 serviceProviderBaseSlot = keccak256(abi.encode(allocation.indexer, serviceProviderSlot));
-        uint256 currentTokensStaked = uint256(vm.load(address(staking), serviceProviderBaseSlot));
-        uint256 currentTokensProvisioned = uint256(
-            vm.load(address(staking), bytes32(uint256(serviceProviderBaseSlot) + 1))
-        );
-        vm.store(
-            address(staking),
-            bytes32(uint256(serviceProviderBaseSlot) + 0),
-            bytes32(currentTokensStaked + tokens)
-        );
-        vm.store(
-            address(staking),
-            bytes32(uint256(serviceProviderBaseSlot) + 1),
-            bytes32(currentTokensProvisioned + tokens)
-        );
-
-        // __DEPRECATED_subgraphAllocations
-        uint256 subgraphsAllocationsSlot = 16;
-        bytes32 subgraphAllocationsBaseSlot = keccak256(
-            abi.encode(allocation.subgraphDeploymentID, subgraphsAllocationsSlot)
-        );
-        uint256 currentAllocatedTokens = uint256(vm.load(address(staking), subgraphAllocationsBaseSlot));
-        vm.store(address(staking), subgraphAllocationsBaseSlot, bytes32(currentAllocatedTokens + tokens));
-    }
-
-    function _getStorageSubgraphAllocations(bytes32 subgraphDeploymentId) internal view returns (uint256) {
+    function _getStorageSubgraphAllocations(bytes32 subgraphDeploymentID) internal view returns (uint256) {
         uint256 subgraphsAllocationsSlot = 16;
-        bytes32 subgraphAllocationsBaseSlot = keccak256(abi.encode(subgraphDeploymentId, subgraphsAllocationsSlot));
+        bytes32 subgraphAllocationsBaseSlot = keccak256(abi.encode(subgraphDeploymentID, subgraphsAllocationsSlot));
         return uint256(vm.load(address(staking), subgraphAllocationsBaseSlot));
     }
 
@@ -2162,40 +1665,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         return address(uint160(uint256(vm.load(address(staking), rewardsDestinationSlotBaseSlot))));
     }
 
-    function _setStorageMaxAllocationEpochs(uint256 maxAllocationEpochs) internal {
-        uint256 slot = 13;
-
-        // Read the current value of the storage slot
-        uint256 currentSlotValue = uint256(vm.load(address(staking), bytes32(slot)));
-
-        // Mask to clear the specific bits for __DEPRECATED_maxAllocationEpochs (bits 128-159)
-        uint256 mask = ~(uint256(0xFFFFFFFF) << 128);
-
-        // Clear the bits and set the new maxAllocationEpochs value
-        uint256 newSlotValue = (currentSlotValue & mask) | (uint256(maxAllocationEpochs) << 128);
-
-        // Store the updated value back into the slot
-        vm.store(address(staking), bytes32(slot), bytes32(newSlotValue));
-
-        uint256 readMaxAllocationEpochs = _getStorageMaxAllocationEpochs();
-        assertEq(readMaxAllocationEpochs, maxAllocationEpochs);
-    }
-
-    function _getStorageMaxAllocationEpochs() internal view returns (uint256) {
-        uint256 slot = 13;
-
-        // Read the current value of the storage slot
-        uint256 currentSlotValue = uint256(vm.load(address(staking), bytes32(slot)));
-
-        // Mask to isolate bits 128-159
-        uint256 mask = uint256(0xFFFFFFFF) << 128;
-
-        // Extract the maxAllocationEpochs by masking and shifting
-        uint256 maxAllocationEpochs = (currentSlotValue & mask) >> 128;
-
-        return maxAllocationEpochs;
-    }
-
     function _setStorageDelegationPool(
         address serviceProvider,
         uint256 tokens,
@@ -2211,148 +1680,6 @@ abstract contract HorizonStakingSharedTest is GraphBaseTest {
         vm.store(address(staking), tokensSlot, bytes32(tokens));
     }
 
-    function _setStorageRebateParameters(
-        uint32 alphaNumerator_,
-        uint32 alphaDenominator_,
-        uint32 lambdaNumerator_,
-        uint32 lambdaDenominator_
-    ) internal {
-        // Store alpha numerator and denominator in slot 13
-        uint256 alphaSlot = 13;
-
-        uint256 newAlphaSlotValue;
-        {
-            uint256 alphaNumeratorOffset = 160; // Offset for __DEPRECATED_alphaNumerator (20th byte)
-            uint256 alphaDenominatorOffset = 192; // Offset for __DEPRECATED_alphaDenominator (24th byte)
-
-            // Read current value of the slot
-            uint256 currentAlphaSlotValue = uint256(vm.load(address(staking), bytes32(alphaSlot)));
-
-            // Create a mask to clear the bits for alphaNumerator and alphaDenominator
-            uint256 alphaMask = ~(uint256(0xFFFFFFFF) << alphaNumeratorOffset) &
-                ~(uint256(0xFFFFFFFF) << alphaDenominatorOffset);
-
-            // Clear and set new values
-            newAlphaSlotValue =
-                (currentAlphaSlotValue & alphaMask) |
-                (uint256(alphaNumerator_) << alphaNumeratorOffset) |
-                (uint256(alphaDenominator_) << alphaDenominatorOffset);
-        }
-
-        // Store the updated value back into the slot
-        vm.store(address(staking), bytes32(alphaSlot), bytes32(newAlphaSlotValue));
-
-        // Store lambda numerator and denominator in slot 25
-        uint256 lambdaSlot = 25;
-
-        uint256 newLambdaSlotValue;
-        {
-            uint256 lambdaNumeratorOffset = 160; // Offset for lambdaNumerator (20th byte)
-            uint256 lambdaDenominatorOffset = 192; // Offset for lambdaDenominator (24th byte)
-
-            // Read current value of the slot
-            uint256 currentLambdaSlotValue = uint256(vm.load(address(staking), bytes32(lambdaSlot)));
-
-            // Create a mask to clear the bits for lambdaNumerator and lambdaDenominator
-            uint256 lambdaMask = ~(uint256(0xFFFFFFFF) << lambdaNumeratorOffset) &
-                ~(uint256(0xFFFFFFFF) << lambdaDenominatorOffset);
-
-            // Clear and set new values
-            newLambdaSlotValue =
-                (currentLambdaSlotValue & lambdaMask) |
-                (uint256(lambdaNumerator_) << lambdaNumeratorOffset) |
-                (uint256(lambdaDenominator_) << lambdaDenominatorOffset);
-        }
-
-        // Store the updated value back into the slot
-        vm.store(address(staking), bytes32(lambdaSlot), bytes32(newLambdaSlotValue));
-
-        // Verify the storage
-        (
-            uint32 readAlphaNumerator,
-            uint32 readAlphaDenominator,
-            uint32 readLambdaNumerator,
-            uint32 readLambdaDenominator
-        ) = _getStorageRebateParameters();
-        assertEq(readAlphaNumerator, alphaNumerator_);
-        assertEq(readAlphaDenominator, alphaDenominator_);
-        assertEq(readLambdaNumerator, lambdaNumerator_);
-        assertEq(readLambdaDenominator, lambdaDenominator_);
-    }
-
-    function _getStorageRebateParameters() internal view returns (uint32, uint32, uint32, uint32) {
-        // Read alpha numerator and denominator
-        uint256 alphaSlot = 13;
-        uint256 alphaValues = uint256(vm.load(address(staking), bytes32(alphaSlot)));
-        // forge-lint: disable-next-line(unsafe-typecast)
-        uint32 alphaNumerator_ = uint32(alphaValues >> 160);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        uint32 alphaDenominator_ = uint32(alphaValues >> 192);
-
-        // Read lambda numerator and denominator
-        uint256 lambdaSlot = 25;
-        uint256 lambdaValues = uint256(vm.load(address(staking), bytes32(lambdaSlot)));
-        // forge-lint: disable-next-line(unsafe-typecast)
-        uint32 lambdaNumerator_ = uint32(lambdaValues >> 160);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        uint32 lambdaDenominator_ = uint32(lambdaValues >> 192);
-
-        return (alphaNumerator_, alphaDenominator_, lambdaNumerator_, lambdaDenominator_);
-    }
-
-    // function _setStorageProtocolTaxAndCuration(uint32 curationPercentage, uint32 taxPercentage) private {
-    //     bytes32 slot = bytes32(uint256(13));
-    //     uint256 curationOffset = 4;
-    //     uint256 protocolTaxOffset = 8;
-    //     bytes32 originalValue = vm.load(address(staking), slot);
-
-    //     bytes32 newProtocolTaxValue = bytes32(
-    //         ((uint256(originalValue) &
-    //             ~((0xFFFFFFFF << (8 * curationOffset)) | (0xFFFFFFFF << (8 * protocolTaxOffset)))) |
-    //             (uint256(curationPercentage) << (8 * curationOffset))) |
-    //             (uint256(taxPercentage) << (8 * protocolTaxOffset))
-    //     );
-    //     vm.store(address(staking), slot, newProtocolTaxValue);
-
-    //     (uint32 readCurationPercentage, uint32 readTaxPercentage) = _getStorageProtocolTaxAndCuration();
-    //     assertEq(readCurationPercentage, curationPercentage);
-    // }
-
-    function _setStorageProtocolTaxAndCuration(uint32 curationPercentage, uint32 taxPercentage) internal {
-        bytes32 slot = bytes32(uint256(13));
-
-        // Offsets for the percentages
-        uint256 curationOffset = 32; // __DEPRECATED_curationPercentage (2nd uint32, bits 32-63)
-        uint256 protocolTaxOffset = 64; // __DEPRECATED_protocolPercentage (3rd uint32, bits 64-95)
-
-        // Read the current slot value
-        uint256 originalValue = uint256(vm.load(address(staking), slot));
-
-        // Create masks to clear the specific bits for the two percentages
-        uint256 mask = ~(uint256(0xFFFFFFFF) << curationOffset) & ~(uint256(0xFFFFFFFF) << protocolTaxOffset); // Mask for curationPercentage // Mask for protocolTax
-
-        // Clear the existing bits and set the new values
-        uint256 newSlotValue = (originalValue & mask) |
-            (uint256(curationPercentage) << curationOffset) |
-            (uint256(taxPercentage) << protocolTaxOffset);
-
-        // Store the updated slot value
-        vm.store(address(staking), slot, bytes32(newSlotValue));
-
-        // Verify the values were set correctly
-        (uint32 readCurationPercentage, uint32 readTaxPercentage) = _getStorageProtocolTaxAndCuration();
-        assertEq(readCurationPercentage, curationPercentage);
-        assertEq(readTaxPercentage, taxPercentage);
-    }
-
-    function _getStorageProtocolTaxAndCuration() internal view returns (uint32, uint32) {
-        bytes32 slot = bytes32(uint256(13));
-        bytes32 value = vm.load(address(staking), slot);
-        uint32 curationPercentage = uint32(uint256(value) >> 32);
-        uint32 taxPercentage = uint32(uint256(value) >> 64);
-        return (curationPercentage, taxPercentage);
-    }
-
     /*
      * MISC: private functions to help with testing
      */
diff --git a/packages/horizon/test/unit/staking/allocation/allocation.t.sol b/packages/horizon/test/unit/staking/allocation/allocation.t.sol
deleted file mode 100644
index 2b7349817..000000000
--- a/packages/horizon/test/unit/staking/allocation/allocation.t.sol
+++ /dev/null
@@ -1,31 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.27;
-
-import { HorizonStakingTest } from "../HorizonStaking.t.sol";
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
-
-contract HorizonStakingAllocationTest is HorizonStakingTest {
-    /*
-     * TESTS
-     */
-
-    function testAllocation_GetAllocationState_Active(uint256 tokens) public useIndexer useAllocation(tokens) {
-        IHorizonStakingExtension.AllocationState state = staking.getAllocationState(_allocationId);
-        assertEq(uint16(state), uint16(IHorizonStakingExtension.AllocationState.Active));
-    }
-
-    function testAllocation_GetAllocationState_Null() public view {
-        IHorizonStakingExtension.AllocationState state = staking.getAllocationState(_allocationId);
-        assertEq(uint16(state), uint16(IHorizonStakingExtension.AllocationState.Null));
-    }
-
-    function testAllocation_IsAllocation(uint256 tokens) public useIndexer useAllocation(tokens) {
-        bool isAllocation = staking.isAllocation(_allocationId);
-        assertTrue(isAllocation);
-    }
-
-    function testAllocation_IsNotAllocation() public view {
-        bool isAllocation = staking.isAllocation(_allocationId);
-        assertFalse(isAllocation);
-    }
-}
diff --git a/packages/horizon/test/unit/staking/allocation/close.t.sol b/packages/horizon/test/unit/staking/allocation/close.t.sol
deleted file mode 100644
index 41eddfe0f..000000000
--- a/packages/horizon/test/unit/staking/allocation/close.t.sol
+++ /dev/null
@@ -1,113 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.27;
-
-import { HorizonStakingTest } from "../HorizonStaking.t.sol";
-import { PPMMath } from "../../../../contracts/libraries/PPMMath.sol";
-
-contract HorizonStakingCloseAllocationTest is HorizonStakingTest {
-    using PPMMath for uint256;
-
-    bytes32 internal constant _POI = keccak256("poi");
-
-    /*
-     * MODIFIERS
-     */
-
-    modifier useLegacyOperator() {
-        resetPrank(users.indexer);
-        _setOperator(subgraphDataServiceLegacyAddress, users.operator, true);
-        vm.startPrank(users.operator);
-        _;
-        vm.stopPrank();
-    }
-
-    /*
-     * TESTS
-     */
-
-    function testCloseAllocation(uint256 tokens) public useIndexer useAllocation(1 ether) {
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        // Skip 15 epochs
-        vm.roll(15);
-
-        _closeAllocation(_allocationId, _POI);
-    }
-
-    function testCloseAllocation_Operator(uint256 tokens) public useLegacyOperator useAllocation(1 ether) {
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        // Skip 15 epochs
-        vm.roll(15);
-
-        _closeAllocation(_allocationId, _POI);
-    }
-
-    function testCloseAllocation_WithBeneficiaryAddress(uint256 tokens) public useIndexer useAllocation(1 ether) {
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        address beneficiary = makeAddr("beneficiary");
-        _setStorageRewardsDestination(users.indexer, beneficiary);
-
-        // Skip 15 epochs
-        vm.roll(15);
-
-        _closeAllocation(_allocationId, _POI);
-    }
-
-    function testCloseAllocation_RevertWhen_NotActive() public {
-        vm.expectRevert("!active");
-        staking.closeAllocation(_allocationId, _POI);
-    }
-
-    function testCloseAllocation_RevertWhen_NotIndexer() public useIndexer useAllocation(1 ether) {
-        resetPrank(users.delegator);
-        vm.expectRevert("!auth");
-        staking.closeAllocation(_allocationId, _POI);
-    }
-
-    function testCloseAllocation_AfterMaxEpochs_AnyoneCanClose(
-        uint256 tokens
-    ) public useIndexer useAllocation(1 ether) {
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        // Skip to over the max allocation epochs
-        vm.roll((MAX_ALLOCATION_EPOCHS + 1) * EPOCH_LENGTH + 1);
-
-        resetPrank(users.delegator);
-        _closeAllocation(_allocationId, 0x0);
-    }
-
-    function testCloseAllocation_RevertWhen_ZeroTokensNotAuthorized() public useIndexer useAllocation(1 ether) {
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, 100 ether, 0, 0);
-
-        resetPrank(users.delegator);
-        vm.expectRevert("!auth");
-        staking.closeAllocation(_allocationId, 0x0);
-    }
-
-    function testCloseAllocation_WithDelegation(
-        uint256 tokens,
-        uint256 delegationTokens,
-        uint32 indexingRewardCut
-    ) public useIndexer useAllocation(1 ether) {
-        tokens = bound(tokens, 2, MAX_STAKING_TOKENS);
-        delegationTokens = bound(delegationTokens, 0, MAX_STAKING_TOKENS);
-        vm.assume(indexingRewardCut <= MAX_PPM);
-
-        uint256 legacyAllocationTokens = tokens / 2;
-        uint256 provisionTokens = tokens - legacyAllocationTokens;
-
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, provisionTokens, 0, 0);
-        _setStorageDelegationPool(users.indexer, delegationTokens, indexingRewardCut, 0);
-
-        // Skip 15 epochs
-        vm.roll(15);
-
-        _closeAllocation(_allocationId, _POI);
-    }
-}
diff --git a/packages/horizon/test/unit/staking/allocation/collect.t.sol b/packages/horizon/test/unit/staking/allocation/collect.t.sol
deleted file mode 100644
index a05c55220..000000000
--- a/packages/horizon/test/unit/staking/allocation/collect.t.sol
+++ /dev/null
@@ -1,81 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.27;
-
-import { console } from "forge-std/console.sol";
-
-import { HorizonStakingTest } from "../HorizonStaking.t.sol";
-import { ExponentialRebates } from "../../../../contracts/staking/libraries/ExponentialRebates.sol";
-import { PPMMath } from "../../../../contracts/libraries/PPMMath.sol";
-
-contract HorizonStakingCollectAllocationTest is HorizonStakingTest {
-    using PPMMath for uint256;
-
-    /*
-     * TESTS
-     */
-
-    function testCollectAllocation_RevertWhen_InvalidAllocationId(
-        uint256 tokens
-    ) public useIndexer useAllocation(1 ether) {
-        vm.expectRevert("!alloc");
-        staking.collect(tokens, address(0));
-    }
-
-    function testCollectAllocation_RevertWhen_Null(uint256 tokens) public {
-        vm.expectRevert("!collect");
-        staking.collect(tokens, _allocationId);
-    }
-
-    function testCollect_Tokens(
-        uint256 allocationTokens,
-        uint256 collectTokens,
-        uint256 curationTokens,
-        uint32 curationPercentage,
-        uint32 protocolTaxPercentage,
-        uint256 delegationTokens,
-        uint32 queryFeeCut
-    ) public useIndexer useRebateParameters useAllocation(allocationTokens) {
-        collectTokens = bound(collectTokens, 0, MAX_STAKING_TOKENS);
-        curationTokens = bound(curationTokens, 0, MAX_STAKING_TOKENS);
-        delegationTokens = bound(delegationTokens, 0, MAX_STAKING_TOKENS);
-        vm.assume(curationPercentage <= MAX_PPM);
-        vm.assume(protocolTaxPercentage <= MAX_PPM);
-        vm.assume(queryFeeCut <= MAX_PPM);
-
-        resetPrank(users.indexer);
-        _setStorageProtocolTaxAndCuration(curationPercentage, protocolTaxPercentage);
-        console.log("queryFeeCut", queryFeeCut);
-        _setStorageDelegationPool(users.indexer, delegationTokens, 0, queryFeeCut);
-        curation.signal(_SUBGRAPH_DEPLOYMENT_ID, curationTokens);
-
-        resetPrank(users.gateway);
-        approve(address(staking), collectTokens);
-        _collect(collectTokens, _allocationId);
-    }
-
-    function testCollect_WithBeneficiaryAddress(
-        uint256 allocationTokens,
-        uint256 collectTokens
-    ) public useIndexer useRebateParameters useAllocation(allocationTokens) {
-        collectTokens = bound(collectTokens, 0, MAX_STAKING_TOKENS);
-
-        address beneficiary = makeAddr("beneficiary");
-        _setStorageRewardsDestination(users.indexer, beneficiary);
-
-        resetPrank(users.gateway);
-        approve(address(staking), collectTokens);
-        _collect(collectTokens, _allocationId);
-
-        uint256 newRebates = ExponentialRebates.exponentialRebates(
-            collectTokens,
-            allocationTokens,
-            alphaNumerator,
-            alphaDenominator,
-            lambdaNumerator,
-            lambdaDenominator
-        );
-        uint256 payment = newRebates > collectTokens ? collectTokens : newRebates;
-
-        assertEq(token.balanceOf(beneficiary), payment);
-    }
-}
diff --git a/packages/horizon/test/unit/staking/delegation/forceWithdrawDelegated.t.sol b/packages/horizon/test/unit/staking/delegation/forceWithdrawDelegated.t.sol
new file mode 100644
index 000000000..5f12d5ee7
--- /dev/null
+++ b/packages/horizon/test/unit/staking/delegation/forceWithdrawDelegated.t.sol
@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import { IHorizonStakingMain } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol";
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+
+import { HorizonStakingTest } from "../HorizonStaking.t.sol";
+
+contract HorizonStakingForceWithdrawDelegatedTest is HorizonStakingTest {
+    /*
+     * MODIFIERS
+     */
+
+    modifier useDelegator() {
+        resetPrank(users.delegator);
+        _;
+    }
+
+    /*
+     * HELPERS
+     */
+
+    function _setLegacyDelegation(
+        address _indexer,
+        address _delegator,
+        uint256 _shares,
+        uint256 __DEPRECATED_tokensLocked,
+        uint256 __DEPRECATED_tokensLockedUntil
+    ) public {
+        // Calculate the base storage slot for the serviceProvider in the mapping
+        bytes32 baseSlot = keccak256(abi.encode(_indexer, uint256(20)));
+
+        // Calculate the slot for the delegator's DelegationInternal struct
+        bytes32 delegatorSlot = keccak256(abi.encode(_delegator, bytes32(uint256(baseSlot) + 4)));
+
+        // Use vm.store to set each field of the struct
+        vm.store(address(staking), bytes32(uint256(delegatorSlot)), bytes32(_shares));
+        vm.store(address(staking), bytes32(uint256(delegatorSlot) + 1), bytes32(__DEPRECATED_tokensLocked));
+        vm.store(address(staking), bytes32(uint256(delegatorSlot) + 2), bytes32(__DEPRECATED_tokensLockedUntil));
+    }
+
+    /*
+     * ACTIONS
+     */
+
+    function _forceWithdrawDelegated(address _indexer, address _delegator) internal {
+        IHorizonStakingTypes.DelegationPool memory pool = staking.getDelegationPool(
+            _indexer,
+            subgraphDataServiceLegacyAddress
+        );
+        uint256 beforeStakingBalance = token.balanceOf(address(staking));
+        uint256 beforeDelegatorBalance = token.balanceOf(_delegator);
+
+        vm.expectEmit(address(staking));
+        emit IHorizonStakingMain.StakeDelegatedWithdrawn(_indexer, _delegator, pool.tokens);
+        staking.forceWithdrawDelegated(_indexer, _delegator);
+
+        uint256 afterStakingBalance = token.balanceOf(address(staking));
+        uint256 afterDelegatorBalance = token.balanceOf(_delegator);
+
+        assertEq(afterStakingBalance, beforeStakingBalance - pool.tokens);
+        assertEq(afterDelegatorBalance - pool.tokens, beforeDelegatorBalance);
+
+        DelegationInternal memory delegation = _getStorageDelegation(
+            _indexer,
+            subgraphDataServiceLegacyAddress,
+            _delegator,
+            true
+        );
+        assertEq(delegation.shares, 0);
+        assertEq(delegation.__DEPRECATED_tokensLocked, 0);
+        assertEq(delegation.__DEPRECATED_tokensLockedUntil, 0);
+    }
+
+    /*
+     * TESTS
+     */
+
+    function testForceWithdrawDelegated_Tokens(uint256 tokensLocked) public useDelegator {
+        vm.assume(tokensLocked > 0);
+
+        _setStorageDelegationPool(users.indexer, tokensLocked, 0, 0);
+        _setLegacyDelegation(users.indexer, users.delegator, 0, tokensLocked, 1);
+        require(token.transfer(address(staking), tokensLocked), "transfer failed");
+
+        // switch to a third party (not the delegator)
+        resetPrank(users.operator);
+
+        _forceWithdrawDelegated(users.indexer, users.delegator);
+    }
+
+    function testForceWithdrawDelegated_CalledByDelegator(uint256 tokensLocked) public useDelegator {
+        vm.assume(tokensLocked > 0);
+
+        _setStorageDelegationPool(users.indexer, tokensLocked, 0, 0);
+        _setLegacyDelegation(users.indexer, users.delegator, 0, tokensLocked, 1);
+        require(token.transfer(address(staking), tokensLocked), "transfer failed");
+
+        // delegator can also call forceWithdrawDelegated on themselves
+        _forceWithdrawDelegated(users.indexer, users.delegator);
+    }
+
+    function testForceWithdrawDelegated_RevertWhen_NoTokens() public useDelegator {
+        _setStorageDelegationPool(users.indexer, 0, 0, 0);
+        _setLegacyDelegation(users.indexer, users.delegator, 0, 0, 0);
+
+        // switch to a third party
+        resetPrank(users.operator);
+
+        bytes memory expectedError = abi.encodeWithSignature("HorizonStakingNothingToWithdraw()");
+        vm.expectRevert(expectedError);
+        staking.forceWithdrawDelegated(users.indexer, users.delegator);
+    }
+}
diff --git a/packages/horizon/test/unit/staking/delegation/withdraw.t.sol b/packages/horizon/test/unit/staking/delegation/withdraw.t.sol
index 31155cec2..c9cc29694 100644
--- a/packages/horizon/test/unit/staking/delegation/withdraw.t.sol
+++ b/packages/horizon/test/unit/staking/delegation/withdraw.t.sol
@@ -160,4 +160,56 @@ contract HorizonStakingWithdrawDelegationTest is HorizonStakingTest {
         resetPrank(users.delegator);
         _withdrawDelegated(users.indexer, subgraphDataServiceAddress, 0);
     }
+
+    function testWithdrawDelegation_GetThawedTokens(
+        uint256 delegationAmount,
+        uint256 withdrawShares
+    )
+        public
+        useIndexer
+        useProvision(10_000_000 ether, 0, MAX_THAWING_PERIOD)
+        useDelegation(delegationAmount)
+        useUndelegate(withdrawShares)
+    {
+        ILinkedList.List memory thawingRequests = staking.getThawRequestList(
+            IHorizonStakingTypes.ThawRequestType.Delegation,
+            users.indexer,
+            subgraphDataServiceAddress,
+            users.delegator
+        );
+        ThawRequest memory thawRequest = staking.getThawRequest(
+            IHorizonStakingTypes.ThawRequestType.Delegation,
+            thawingRequests.tail
+        );
+
+        // Before thawing period passes, thawed tokens should be 0
+        uint256 thawedTokensBefore = staking.getThawedTokens(
+            IHorizonStakingTypes.ThawRequestType.Delegation,
+            users.indexer,
+            subgraphDataServiceAddress,
+            users.delegator
+        );
+        assertEq(thawedTokensBefore, 0);
+
+        // Skip past thawing period
+        skip(thawRequest.thawingUntil + 1);
+
+        // After thawing period, thawed tokens should match expected amount
+        uint256 thawedTokensAfter = staking.getThawedTokens(
+            IHorizonStakingTypes.ThawRequestType.Delegation,
+            users.indexer,
+            subgraphDataServiceAddress,
+            users.delegator
+        );
+
+        // Thawed tokens should be greater than 0 and should match what we can withdraw
+        assertGt(thawedTokensAfter, 0);
+
+        // Withdraw and verify the amount matches
+        uint256 balanceBefore = token.balanceOf(users.delegator);
+        _withdrawDelegated(users.indexer, subgraphDataServiceAddress, 0);
+        uint256 balanceAfter = token.balanceOf(users.delegator);
+
+        assertEq(balanceAfter - balanceBefore, thawedTokensAfter);
+    }
 }
diff --git a/packages/horizon/test/unit/staking/governance/governance.t.sol b/packages/horizon/test/unit/staking/governance/governance.t.sol
index cc2a54465..cecbaf207 100644
--- a/packages/horizon/test/unit/staking/governance/governance.t.sol
+++ b/packages/horizon/test/unit/staking/governance/governance.t.sol
@@ -37,19 +37,6 @@ contract HorizonStakingGovernanceTest is HorizonStakingTest {
         staking.setDelegationSlashingEnabled();
     }
 
-    function testGovernance_ClearThawingPeriod(uint32 thawingPeriod) public useGovernor {
-        // simulate previous thawing period
-        _setStorageDeprecatedThawingPeriod(thawingPeriod);
-
-        _clearThawingPeriod();
-    }
-
-    function testGovernance_ClearThawingPeriod_NotGovernor() public useIndexer {
-        bytes memory expectedError = abi.encodeWithSignature("ManagedOnlyGovernor()");
-        vm.expectRevert(expectedError);
-        staking.clearThawingPeriod();
-    }
-
     function testGovernance__SetMaxThawingPeriod(uint64 maxThawingPeriod) public useGovernor {
         _setMaxThawingPeriod(maxThawingPeriod);
     }
diff --git a/packages/horizon/test/unit/staking/legacy/isAllocation.t.sol b/packages/horizon/test/unit/staking/legacy/isAllocation.t.sol
new file mode 100644
index 000000000..1f19ccc00
--- /dev/null
+++ b/packages/horizon/test/unit/staking/legacy/isAllocation.t.sol
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+import { HorizonStakingSharedTest } from "../../shared/horizon-staking/HorizonStakingShared.t.sol";
+
+contract HorizonStakingIsAllocationTest is HorizonStakingSharedTest {
+    /*
+     * TESTS
+     */
+
+    function test_IsAllocation_ReturnsFalse_WhenAllocationDoesNotExist() public {
+        address nonExistentAllocationId = makeAddr("nonExistentAllocation");
+        assertFalse(staking.isAllocation(nonExistentAllocationId));
+    }
+
+    function test_IsAllocation_ReturnsTrue_WhenActiveAllocationExists() public {
+        address allocationId = makeAddr("activeAllocation");
+
+        // Set up an active legacy allocation in storage
+        _setLegacyAllocationInStaking(
+            allocationId,
+            users.indexer,
+            bytes32("subgraphDeploymentId"),
+            1000 ether, // tokens
+            1, // createdAtEpoch
+            0 // closedAtEpoch (0 = still active)
+        );
+
+        assertTrue(staking.isAllocation(allocationId));
+    }
+
+    function test_IsAllocation_ReturnsTrue_WhenClosedAllocationExists() public {
+        address allocationId = makeAddr("closedAllocation");
+
+        // Set up a closed legacy allocation in storage
+        _setLegacyAllocationInStaking(
+            allocationId,
+            users.indexer,
+            bytes32("subgraphDeploymentId"),
+            1000 ether, // tokens
+            1, // createdAtEpoch
+            10 // closedAtEpoch (non-zero = closed)
+        );
+
+        assertTrue(staking.isAllocation(allocationId));
+    }
+
+    function test_IsAllocation_ReturnsFalse_WhenIndexerIsZeroAddress() public {
+        address allocationId = makeAddr("zeroIndexerAllocation");
+
+        // Set up an allocation with zero indexer (should be considered Null)
+        _setLegacyAllocationInStaking(
+            allocationId,
+            address(0), // indexer is zero
+            bytes32("subgraphDeploymentId"),
+            1000 ether,
+            1,
+            0
+        );
+
+        assertFalse(staking.isAllocation(allocationId));
+    }
+
+    /*
+     * HELPERS
+     */
+
+    /**
+     * @notice Sets a legacy allocation directly in HorizonStaking storage
+     * @dev The __DEPRECATED_allocations mapping is at storage slot 10 in HorizonStakingStorage
+     * The LegacyAllocation struct has the following layout:
+     * - slot 0: indexer (address)
+     * - slot 1: subgraphDeploymentID (bytes32)
+     * - slot 2: tokens (uint256)
+     * - slot 3: createdAtEpoch (uint256)
+     * - slot 4: closedAtEpoch (uint256)
+     * - slot 5: collectedFees (uint256)
+     * - slot 6: __DEPRECATED_effectiveAllocation (uint256)
+     * - slot 7: accRewardsPerAllocatedToken (uint256)
+     * - slot 8: distributedRebates (uint256)
+     */
+    function _setLegacyAllocationInStaking(
+        address _allocationId,
+        address _indexer,
+        bytes32 _subgraphDeploymentId,
+        uint256 _tokens,
+        uint256 _createdAtEpoch,
+        uint256 _closedAtEpoch
+    ) internal {
+        // Storage slot for __DEPRECATED_allocations mapping in HorizonStaking
+        // Use `forge inspect HorizonStaking storage-layout` to verify
+        uint256 allocationsSlot = 15;
+        bytes32 allocationBaseSlot = keccak256(abi.encode(_allocationId, allocationsSlot));
+
+        // Set indexer (slot 0)
+        vm.store(address(staking), allocationBaseSlot, bytes32(uint256(uint160(_indexer))));
+        // Set subgraphDeploymentID (slot 1)
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 1), _subgraphDeploymentId);
+        // Set tokens (slot 2)
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 2), bytes32(_tokens));
+        // Set createdAtEpoch (slot 3)
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 3), bytes32(_createdAtEpoch));
+        // Set closedAtEpoch (slot 4)
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 4), bytes32(_closedAtEpoch));
+    }
+}
diff --git a/packages/horizon/test/unit/staking/provision/parameters.t.sol b/packages/horizon/test/unit/staking/provision/parameters.t.sol
index 3c3c745de..652bc6737 100644
--- a/packages/horizon/test/unit/staking/provision/parameters.t.sol
+++ b/packages/horizon/test/unit/staking/provision/parameters.t.sol
@@ -175,4 +175,36 @@ contract HorizonStakingProvisionParametersTest is HorizonStakingTest {
         );
         staking.acceptProvisionParameters(users.indexer);
     }
+
+    function test_ProvisionParametersAccept_RevertWhen_MaxThawingPeriodReduced(
+        uint256 amount,
+        uint32 maxVerifierCut,
+        uint64 thawingPeriod
+    ) public useIndexer useValidParameters(maxVerifierCut, thawingPeriod) {
+        vm.assume(amount > 0);
+        vm.assume(amount <= MAX_STAKING_TOKENS);
+        vm.assume(thawingPeriod > 0);
+
+        // Create provision with initial parameters (thawingPeriod = 0)
+        _createProvision(users.indexer, subgraphDataServiceAddress, amount, 0, 0);
+
+        // Stage new parameters with valid thawing period
+        _setProvisionParameters(users.indexer, subgraphDataServiceAddress, maxVerifierCut, thawingPeriod);
+
+        // Governor reduces max thawing period to below the staged value
+        uint64 newMaxThawingPeriod = thawingPeriod - 1;
+        resetPrank(users.governor);
+        _setMaxThawingPeriod(newMaxThawingPeriod);
+
+        // Verifier tries to accept the parameters - should revert
+        resetPrank(subgraphDataServiceAddress);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                IHorizonStakingMain.HorizonStakingInvalidThawingPeriod.selector,
+                thawingPeriod,
+                newMaxThawingPeriod
+            )
+        );
+        staking.acceptProvisionParameters(users.indexer);
+    }
 }
diff --git a/packages/horizon/test/unit/staking/provision/provision.t.sol b/packages/horizon/test/unit/staking/provision/provision.t.sol
index 5149e8cf6..474d9b96a 100644
--- a/packages/horizon/test/unit/staking/provision/provision.t.sol
+++ b/packages/horizon/test/unit/staking/provision/provision.t.sol
@@ -94,22 +94,6 @@ contract HorizonStakingProvisionTest is HorizonStakingTest {
         staking.provision(users.indexer, subgraphDataServiceAddress, amount, maxVerifierCut, thawingPeriod);
     }
 
-    function testProvision_RevertWhen_VerifierIsNotSubgraphDataServiceDuringTransitionPeriod(
-        uint256 amount
-    ) public useIndexer useStake(amount) {
-        // simulate the transition period
-        _setStorageDeprecatedThawingPeriod(THAWING_PERIOD_IN_BLOCKS);
-
-        // oddly we use subgraphDataServiceLegacyAddress as the subgraph service address
-        // so subgraphDataServiceAddress is not the subgraph service ¯\_(ツ)_/¯
-        bytes memory expectedError = abi.encodeWithSignature(
-            "HorizonStakingInvalidVerifier(address)",
-            subgraphDataServiceAddress
-        );
-        vm.expectRevert(expectedError);
-        staking.provision(users.indexer, subgraphDataServiceAddress, amount, 0, 0);
-    }
-
     function testProvision_AddTokensToProvision(
         uint256 amount,
         uint32 maxVerifierCut,
diff --git a/packages/horizon/test/unit/staking/serviceProvider/serviceProvider.t.sol b/packages/horizon/test/unit/staking/serviceProvider/serviceProvider.t.sol
index 651fd662f..03db6893f 100644
--- a/packages/horizon/test/unit/staking/serviceProvider/serviceProvider.t.sol
+++ b/packages/horizon/test/unit/staking/serviceProvider/serviceProvider.t.sol
@@ -99,37 +99,6 @@ contract HorizonStakingServiceProviderTest is HorizonStakingTest {
         assertEq(providerTokensAvailable, amount);
     }
 
-    function testServiceProvider_HasStake(
-        uint256 amount
-    ) public useIndexer useProvision(amount, MAX_PPM, MAX_THAWING_PERIOD) {
-        assertTrue(staking.hasStake(users.indexer));
-
-        _thaw(users.indexer, subgraphDataServiceAddress, amount);
-        skip(MAX_THAWING_PERIOD + 1);
-        _deprovision(users.indexer, subgraphDataServiceAddress, 0);
-        staking.unstake(amount);
-
-        assertFalse(staking.hasStake(users.indexer));
-    }
-
-    function testServiceProvider_GetIndexerStakedTokens(
-        uint256 amount
-    ) public useIndexer useProvision(amount, MAX_PPM, MAX_THAWING_PERIOD) {
-        assertEq(staking.getIndexerStakedTokens(users.indexer), amount);
-
-        _thaw(users.indexer, subgraphDataServiceAddress, amount);
-        // Does not discount thawing tokens
-        assertEq(staking.getIndexerStakedTokens(users.indexer), amount);
-
-        skip(MAX_THAWING_PERIOD + 1);
-        _deprovision(users.indexer, subgraphDataServiceAddress, 0);
-        // Does not discount thawing tokens
-        assertEq(staking.getIndexerStakedTokens(users.indexer), amount);
-
-        staking.unstake(amount);
-        assertEq(staking.getIndexerStakedTokens(users.indexer), 0);
-    }
-
     function testServiceProvider_RevertIf_InvalidDelegationFeeCut(
         uint256 cut,
         uint8 paymentTypeInput
diff --git a/packages/horizon/test/unit/staking/slash/legacySlash.t.sol b/packages/horizon/test/unit/staking/slash/legacySlash.t.sol
deleted file mode 100644
index 4e4a9bdd3..000000000
--- a/packages/horizon/test/unit/staking/slash/legacySlash.t.sol
+++ /dev/null
@@ -1,251 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.27;
-
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
-
-import { HorizonStakingTest } from "../HorizonStaking.t.sol";
-
-contract HorizonStakingLegacySlashTest is HorizonStakingTest {
-    /*
-     * MODIFIERS
-     */
-
-    modifier useLegacySlasher(address slasher) {
-        bytes32 storageKey = keccak256(abi.encode(slasher, 18));
-        vm.store(address(staking), storageKey, bytes32(uint256(1)));
-        _;
-    }
-
-    /*
-     * HELPERS
-     */
-
-    function _setIndexer(
-        address _indexer,
-        uint256 _tokensStaked,
-        uint256 _tokensAllocated,
-        uint256 _tokensLocked,
-        uint256 _tokensLockedUntil
-    ) public {
-        bytes32 baseSlot = keccak256(abi.encode(_indexer, 14));
-
-        vm.store(address(staking), bytes32(uint256(baseSlot)), bytes32(_tokensStaked));
-        vm.store(address(staking), bytes32(uint256(baseSlot) + 1), bytes32(_tokensAllocated));
-        vm.store(address(staking), bytes32(uint256(baseSlot) + 2), bytes32(_tokensLocked));
-        vm.store(address(staking), bytes32(uint256(baseSlot) + 3), bytes32(_tokensLockedUntil));
-    }
-
-    /*
-     * ACTIONS
-     */
-
-    function _legacySlash(address _indexer, uint256 _tokens, uint256 _rewards, address _beneficiary) internal {
-        // before
-        uint256 beforeStakingBalance = token.balanceOf(address(staking));
-        uint256 beforeRewardsDestinationBalance = token.balanceOf(_beneficiary);
-        ServiceProviderInternal memory beforeIndexer = _getStorageServiceProviderInternal(_indexer);
-
-        // calculate slashable stake
-        uint256 slashableStake = beforeIndexer.tokensStaked - beforeIndexer.tokensProvisioned;
-        uint256 actualTokens = _tokens;
-        uint256 actualRewards = _rewards;
-        if (slashableStake == 0) {
-            actualTokens = 0;
-            actualRewards = 0;
-        } else if (_tokens > slashableStake) {
-            actualRewards = (_rewards * slashableStake) / _tokens;
-            actualTokens = slashableStake;
-        }
-
-        // slash
-        vm.expectEmit(address(staking));
-        emit IHorizonStakingExtension.StakeSlashed(_indexer, actualTokens, actualRewards, _beneficiary);
-        staking.slash(_indexer, _tokens, _rewards, _beneficiary);
-
-        // after
-        uint256 afterStakingBalance = token.balanceOf(address(staking));
-        uint256 afterRewardsDestinationBalance = token.balanceOf(_beneficiary);
-        ServiceProviderInternal memory afterIndexer = _getStorageServiceProviderInternal(_indexer);
-
-        assertEq(beforeStakingBalance - actualTokens, afterStakingBalance);
-        assertEq(beforeRewardsDestinationBalance, afterRewardsDestinationBalance - actualRewards);
-        assertEq(afterIndexer.tokensStaked, beforeIndexer.tokensStaked - actualTokens);
-    }
-
-    /*
-     * TESTS
-     */
-    function testSlash_Legacy(
-        uint256 tokensStaked,
-        uint256 tokensProvisioned,
-        uint256 slashTokens,
-        uint256 reward
-    ) public useIndexer useLegacySlasher(users.legacySlasher) {
-        vm.assume(tokensStaked > 0);
-        vm.assume(tokensStaked <= MAX_STAKING_TOKENS);
-        vm.assume(tokensProvisioned > 0);
-        vm.assume(tokensProvisioned <= tokensStaked);
-        slashTokens = bound(slashTokens, 1, tokensStaked);
-        reward = bound(reward, 0, slashTokens);
-
-        _stake(tokensStaked);
-        _provision(users.indexer, subgraphDataServiceLegacyAddress, tokensProvisioned, 0, 0);
-
-        resetPrank(users.legacySlasher);
-        _legacySlash(users.indexer, slashTokens, reward, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_UsingLockedTokens(
-        uint256 tokens,
-        uint256 slashTokens,
-        uint256 reward
-    ) public useIndexer useLegacySlasher(users.legacySlasher) {
-        vm.assume(tokens > 1);
-        slashTokens = bound(slashTokens, 1, tokens);
-        reward = bound(reward, 0, slashTokens);
-
-        _setIndexer(users.indexer, tokens, 0, tokens, block.timestamp + 1);
-        // Send tokens manually to staking
-        require(token.transfer(address(staking), tokens), "Transfer failed");
-
-        resetPrank(users.legacySlasher);
-        _legacySlash(users.indexer, slashTokens, reward, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_UsingAllocatedTokens(
-        uint256 tokens,
-        uint256 slashTokens,
-        uint256 reward
-    ) public useIndexer useLegacySlasher(users.legacySlasher) {
-        vm.assume(tokens > 1);
-        slashTokens = bound(slashTokens, 1, tokens);
-        reward = bound(reward, 0, slashTokens);
-
-        _setIndexer(users.indexer, tokens, 0, tokens, 0);
-        // Send tokens manually to staking
-        require(token.transfer(address(staking), tokens), "Transfer failed");
-
-        resetPrank(users.legacySlasher);
-        staking.legacySlash(users.indexer, slashTokens, reward, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_RevertWhen_CallerNotSlasher(
-        uint256 tokens,
-        uint256 slashTokens,
-        uint256 reward
-    ) public useIndexer {
-        vm.assume(tokens > 0);
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        vm.expectRevert("!slasher");
-        staking.legacySlash(users.indexer, slashTokens, reward, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_RevertWhen_RewardsOverSlashTokens(
-        uint256 tokens,
-        uint256 slashTokens,
-        uint256 reward
-    ) public useIndexer useLegacySlasher(users.legacySlasher) {
-        vm.assume(tokens > 0);
-        vm.assume(slashTokens > 0);
-        vm.assume(reward > slashTokens);
-
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        resetPrank(users.legacySlasher);
-        vm.expectRevert("rewards>slash");
-        staking.legacySlash(users.indexer, slashTokens, reward, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_RevertWhen_NoStake(
-        uint256 slashTokens,
-        uint256 reward
-    ) public useLegacySlasher(users.legacySlasher) {
-        vm.assume(slashTokens > 0);
-        reward = bound(reward, 0, slashTokens);
-
-        resetPrank(users.legacySlasher);
-        vm.expectRevert("!stake");
-        staking.legacySlash(users.indexer, slashTokens, reward, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_RevertWhen_ZeroTokens(
-        uint256 tokens
-    ) public useIndexer useLegacySlasher(users.legacySlasher) {
-        vm.assume(tokens > 0);
-
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        resetPrank(users.legacySlasher);
-        vm.expectRevert("!tokens");
-        staking.legacySlash(users.indexer, 0, 0, makeAddr("fisherman"));
-    }
-
-    function testSlash_Legacy_RevertWhen_NoBeneficiary(
-        uint256 tokens,
-        uint256 slashTokens,
-        uint256 reward
-    ) public useIndexer useLegacySlasher(users.legacySlasher) {
-        vm.assume(tokens > 0);
-        slashTokens = bound(slashTokens, 1, tokens);
-        reward = bound(reward, 0, slashTokens);
-
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, 0);
-
-        resetPrank(users.legacySlasher);
-        vm.expectRevert("!beneficiary");
-        staking.legacySlash(users.indexer, slashTokens, reward, address(0));
-    }
-
-    function test_LegacySlash_WhenTokensAllocatedGreaterThanStake()
-        public
-        useIndexer
-        useLegacySlasher(users.legacySlasher)
-    {
-        // Setup indexer with:
-        // - tokensStaked = 1000 GRT
-        // - tokensAllocated = 800 GRT
-        // - tokensLocked = 300 GRT
-        // This means tokensUsed (1100 GRT) > tokensStaked (1000 GRT)
-        _setIndexer(
-            users.indexer,
-            1000 ether, // tokensStaked
-            800 ether, // tokensAllocated
-            300 ether, // tokensLocked
-            0 // tokensLockedUntil
-        );
-
-        // Send tokens manually to staking
-        require(token.transfer(address(staking), 1100 ether), "Transfer failed");
-
-        resetPrank(users.legacySlasher);
-        _legacySlash(users.indexer, 1000 ether, 500 ether, makeAddr("fisherman"));
-    }
-
-    function test_LegacySlash_WhenDelegateCallFails() public useIndexer useLegacySlasher(users.legacySlasher) {
-        // Setup indexer with:
-        // - tokensStaked = 1000 GRT
-        // - tokensAllocated = 800 GRT
-        // - tokensLocked = 300 GRT
-
-        _setIndexer(
-            users.indexer,
-            1000 ether, // tokensStaked
-            800 ether, // tokensAllocated
-            300 ether, // tokensLocked
-            0 // tokensLockedUntil
-        );
-
-        // Send tokens manually to staking
-        require(token.transfer(address(staking), 1100 ether), "Transfer failed");
-
-        // Change staking extension code to an invalid opcode so the delegatecall reverts
-        address stakingExtension = staking.getStakingExtension();
-        vm.etch(stakingExtension, hex"fe");
-
-        resetPrank(users.legacySlasher);
-        bytes memory expectedError = abi.encodeWithSignature("HorizonStakingLegacySlashFailed()");
-        vm.expectRevert(expectedError);
-        staking.slash(users.indexer, 1000 ether, 500 ether, makeAddr("fisherman"));
-    }
-}
diff --git a/packages/horizon/test/unit/staking/stake/forceWithdraw.t.sol b/packages/horizon/test/unit/staking/stake/forceWithdraw.t.sol
new file mode 100644
index 000000000..0b41f8976
--- /dev/null
+++ b/packages/horizon/test/unit/staking/stake/forceWithdraw.t.sol
@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import { IHorizonStakingMain } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol";
+
+import { HorizonStakingTest } from "../HorizonStaking.t.sol";
+
+contract HorizonStakingForceWithdrawTest is HorizonStakingTest {
+    /*
+     * HELPERS
+     */
+
+    function _forceWithdraw(address _serviceProvider) internal {
+        (, address msgSender, ) = vm.readCallers();
+
+        // before
+        ServiceProviderInternal memory beforeServiceProvider = _getStorageServiceProviderInternal(_serviceProvider);
+        uint256 beforeServiceProviderBalance = token.balanceOf(_serviceProvider);
+        uint256 beforeCallerBalance = token.balanceOf(msgSender);
+        uint256 beforeStakingBalance = token.balanceOf(address(staking));
+
+        // forceWithdraw
+        vm.expectEmit(address(staking));
+        emit IHorizonStakingMain.HorizonStakeWithdrawn(
+            _serviceProvider,
+            beforeServiceProvider.__DEPRECATED_tokensLocked
+        );
+        staking.forceWithdraw(_serviceProvider);
+
+        // after
+        ServiceProviderInternal memory afterServiceProvider = _getStorageServiceProviderInternal(_serviceProvider);
+        uint256 afterServiceProviderBalance = token.balanceOf(_serviceProvider);
+        uint256 afterCallerBalance = token.balanceOf(msgSender);
+        uint256 afterStakingBalance = token.balanceOf(address(staking));
+
+        // assert - tokens go to service provider, not caller
+        assertEq(
+            afterServiceProviderBalance - beforeServiceProviderBalance,
+            beforeServiceProvider.__DEPRECATED_tokensLocked
+        );
+        assertEq(afterCallerBalance, beforeCallerBalance); // caller balance unchanged
+        assertEq(beforeStakingBalance - afterStakingBalance, beforeServiceProvider.__DEPRECATED_tokensLocked);
+
+        // assert - service provider state updated
+        assertEq(
+            afterServiceProvider.tokensStaked,
+            beforeServiceProvider.tokensStaked - beforeServiceProvider.__DEPRECATED_tokensLocked
+        );
+        assertEq(afterServiceProvider.tokensProvisioned, beforeServiceProvider.tokensProvisioned);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensAllocated, beforeServiceProvider.__DEPRECATED_tokensAllocated);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensLocked, 0);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensLockedUntil, 0);
+    }
+
+    /*
+     * TESTS
+     */
+
+    function testForceWithdraw_Tokens(uint256 tokens, uint256 tokensLocked) public useIndexer {
+        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
+        tokensLocked = bound(tokensLocked, 1, tokens);
+
+        // simulate locked tokens ready to withdraw
+        require(token.transfer(address(staking), tokens), "transfer failed");
+        _setStorageServiceProvider(users.indexer, tokens, 0, tokensLocked, block.number, 0);
+
+        _createProvision(users.indexer, subgraphDataServiceAddress, tokens, 0, MAX_THAWING_PERIOD);
+
+        // switch to a different user (not the service provider)
+        resetPrank(users.delegator);
+
+        _forceWithdraw(users.indexer);
+    }
+
+    function testForceWithdraw_CalledByServiceProvider(uint256 tokens, uint256 tokensLocked) public useIndexer {
+        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
+        tokensLocked = bound(tokensLocked, 1, tokens);
+
+        // simulate locked tokens ready to withdraw
+        require(token.transfer(address(staking), tokens), "transfer failed");
+        _setStorageServiceProvider(users.indexer, tokens, 0, tokensLocked, block.number, 0);
+
+        _createProvision(users.indexer, subgraphDataServiceAddress, tokens, 0, MAX_THAWING_PERIOD);
+
+        // before
+        ServiceProviderInternal memory beforeServiceProvider = _getStorageServiceProviderInternal(users.indexer);
+        uint256 beforeServiceProviderBalance = token.balanceOf(users.indexer);
+        uint256 beforeStakingBalance = token.balanceOf(address(staking));
+
+        // service provider can also call forceWithdraw on themselves
+        vm.expectEmit(address(staking));
+        emit IHorizonStakingMain.HorizonStakeWithdrawn(users.indexer, beforeServiceProvider.__DEPRECATED_tokensLocked);
+        staking.forceWithdraw(users.indexer);
+
+        // after
+        ServiceProviderInternal memory afterServiceProvider = _getStorageServiceProviderInternal(users.indexer);
+        uint256 afterServiceProviderBalance = token.balanceOf(users.indexer);
+        uint256 afterStakingBalance = token.balanceOf(address(staking));
+
+        // assert
+        assertEq(
+            afterServiceProviderBalance - beforeServiceProviderBalance,
+            beforeServiceProvider.__DEPRECATED_tokensLocked
+        );
+        assertEq(beforeStakingBalance - afterStakingBalance, beforeServiceProvider.__DEPRECATED_tokensLocked);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensLocked, 0);
+        assertEq(afterServiceProvider.__DEPRECATED_tokensLockedUntil, 0);
+    }
+
+    function testForceWithdraw_RevertWhen_ZeroTokens(uint256 tokens) public useIndexer {
+        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
+
+        // simulate zero locked tokens
+        require(token.transfer(address(staking), tokens), "transfer failed");
+        _setStorageServiceProvider(users.indexer, tokens, 0, 0, 0, 0);
+
+        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, MAX_THAWING_PERIOD);
+
+        // switch to a different user
+        resetPrank(users.delegator);
+
+        vm.expectRevert(abi.encodeWithSelector(IHorizonStakingMain.HorizonStakingInvalidZeroTokens.selector));
+        staking.forceWithdraw(users.indexer);
+    }
+}
diff --git a/packages/horizon/test/unit/staking/stake/unstake.t.sol b/packages/horizon/test/unit/staking/stake/unstake.t.sol
index 54803cc60..0b9a0fcca 100644
--- a/packages/horizon/test/unit/staking/stake/unstake.t.sol
+++ b/packages/horizon/test/unit/staking/stake/unstake.t.sol
@@ -24,79 +24,6 @@ contract HorizonStakingUnstakeTest is HorizonStakingTest {
         _unstake(tokensToUnstake);
     }
 
-    function testUnstake_LockingPeriodGreaterThanZero_NoThawing(
-        uint256 tokens,
-        uint256 tokensToUnstake,
-        uint32 maxVerifierCut,
-        uint64 thawingPeriod
-    ) public useIndexer useProvision(tokens, maxVerifierCut, thawingPeriod) {
-        tokensToUnstake = bound(tokensToUnstake, 1, tokens);
-
-        // simulate transition period
-        _setStorageDeprecatedThawingPeriod(THAWING_PERIOD_IN_BLOCKS);
-
-        // thaw, wait and deprovision
-        _thaw(users.indexer, subgraphDataServiceAddress, tokens);
-        skip(thawingPeriod + 1);
-        _deprovision(users.indexer, subgraphDataServiceAddress, 0);
-
-        // unstake
-        _unstake(tokensToUnstake);
-    }
-
-    function testUnstake_LockingPeriodGreaterThanZero_TokensDoneThawing(
-        uint256 tokens,
-        uint256 tokensToUnstake,
-        uint256 tokensLocked
-    ) public useIndexer {
-        // bounds
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        tokensToUnstake = bound(tokensToUnstake, 1, tokens);
-        tokensLocked = bound(tokensLocked, 1, MAX_STAKING_TOKENS);
-
-        // simulate locked tokens with past locking period
-        _setStorageDeprecatedThawingPeriod(THAWING_PERIOD_IN_BLOCKS);
-        require(token.transfer(address(staking), tokensLocked), "Transfer failed");
-        _setStorageServiceProvider(users.indexer, tokensLocked, 0, tokensLocked, block.number, 0);
-
-        // create provision, thaw and deprovision
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, MAX_THAWING_PERIOD);
-        _thaw(users.indexer, subgraphDataServiceLegacyAddress, tokens);
-        skip(MAX_THAWING_PERIOD + 1);
-        _deprovision(users.indexer, subgraphDataServiceLegacyAddress, 0);
-
-        // unstake
-        _unstake(tokensToUnstake);
-    }
-
-    function testUnstake_LockingPeriodGreaterThanZero_TokensStillThawing(
-        uint256 tokens,
-        uint256 tokensToUnstake,
-        uint256 tokensThawing,
-        uint32 tokensThawingUntilBlock
-    ) public useIndexer {
-        // bounds
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        tokensToUnstake = bound(tokensToUnstake, 1, tokens);
-        tokensThawing = bound(tokensThawing, 1, MAX_STAKING_TOKENS);
-        vm.assume(tokensThawingUntilBlock > block.number);
-        vm.assume(tokensThawingUntilBlock < block.number + THAWING_PERIOD_IN_BLOCKS);
-
-        // simulate locked tokens still thawing
-        _setStorageDeprecatedThawingPeriod(THAWING_PERIOD_IN_BLOCKS);
-        require(token.transfer(address(staking), tokensThawing), "Transfer failed");
-        _setStorageServiceProvider(users.indexer, tokensThawing, 0, tokensThawing, tokensThawingUntilBlock, 0);
-
-        // create provision, thaw and deprovision
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, MAX_THAWING_PERIOD);
-        _thaw(users.indexer, subgraphDataServiceLegacyAddress, tokens);
-        skip(MAX_THAWING_PERIOD + 1);
-        _deprovision(users.indexer, subgraphDataServiceLegacyAddress, 0);
-
-        // unstake
-        _unstake(tokensToUnstake);
-    }
-
     function testUnstake_RevertWhen_ZeroTokens(
         uint256 amount,
         uint32 maxVerifierCut,
diff --git a/packages/horizon/test/unit/staking/stake/withdraw.t.sol b/packages/horizon/test/unit/staking/stake/withdraw.t.sol
index 2d7b89382..282135edc 100644
--- a/packages/horizon/test/unit/staking/stake/withdraw.t.sol
+++ b/packages/horizon/test/unit/staking/stake/withdraw.t.sol
@@ -35,19 +35,4 @@ contract HorizonStakingWithdrawTest is HorizonStakingTest {
         vm.expectRevert(abi.encodeWithSelector(IHorizonStakingMain.HorizonStakingInvalidZeroTokens.selector));
         staking.withdraw();
     }
-
-    function testWithdraw_RevertWhen_StillThawing(uint256 tokens, uint256 tokensLocked) public useIndexer {
-        tokens = bound(tokens, 1, MAX_STAKING_TOKENS);
-        tokensLocked = bound(tokensLocked, 1, tokens);
-
-        // simulate locked tokens still thawing
-        uint256 thawUntil = block.timestamp + 1;
-        require(token.transfer(address(staking), tokens), "Transfer failed");
-        _setStorageServiceProvider(users.indexer, tokens, 0, tokensLocked, thawUntil, 0);
-
-        _createProvision(users.indexer, subgraphDataServiceLegacyAddress, tokens, 0, MAX_THAWING_PERIOD);
-
-        vm.expectRevert(abi.encodeWithSelector(IHorizonStakingMain.HorizonStakingStillThawing.selector, thawUntil));
-        staking.withdraw();
-    }
 }
diff --git a/packages/horizon/test/unit/utilities/Authorizable.t.sol b/packages/horizon/test/unit/utilities/Authorizable.t.sol
index 33713c436..27e9c8515 100644
--- a/packages/horizon/test/unit/utilities/Authorizable.t.sol
+++ b/packages/horizon/test/unit/utilities/Authorizable.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.27;
+pragma solidity 0.8.27 || 0.8.33;
 
 import { Test } from "forge-std/Test.sol";
 
@@ -14,23 +14,27 @@ contract AuthorizableImp is Authorizable {
 }
 
 contract AuthorizableTest is Test, Bounder {
-    AuthorizableImp public authorizable;
+    IAuthorizable public authorizable;
     AuthorizableHelper authHelper;
 
     modifier withFuzzyThaw(uint256 _thawPeriod) {
         // Max thaw period is 1 year to allow for thawing tests
         _thawPeriod = bound(_thawPeriod, 1, 60 * 60 * 24 * 365);
-        setupAuthorizable(new AuthorizableImp(_thawPeriod));
+        setupAuthorizable(_thawPeriod);
         _;
     }
 
-    function setUp() public virtual {
-        setupAuthorizable(new AuthorizableImp(0));
+    function setUp() public {
+        setupAuthorizable(0);
     }
 
-    function setupAuthorizable(AuthorizableImp _authorizable) internal {
-        authorizable = _authorizable;
-        authHelper = new AuthorizableHelper(authorizable);
+    function setupAuthorizable(uint256 _thawPeriod) internal {
+        authorizable = newAuthorizable(_thawPeriod);
+        authHelper = new AuthorizableHelper(authorizable, _thawPeriod);
+    }
+
+    function newAuthorizable(uint256 _thawPeriod) public virtual returns (IAuthorizable) {
+        return new AuthorizableImp(_thawPeriod);
     }
 
     function test_AuthorizeSigner(uint256 _unboundedKey, address _authorizer) public {
@@ -304,12 +308,12 @@ contract AuthorizableTest is Test, Bounder {
 
         authHelper.authorizeAndThawSignerWithChecks(_authorizer, signerKey);
 
-        _skip = bound(_skip, 0, authorizable.REVOKE_AUTHORIZATION_THAWING_PERIOD() - 1);
+        _skip = bound(_skip, 0, authHelper.revokeAuthorizationThawingPeriod() - 1);
         skip(_skip);
         bytes memory expectedErr = abi.encodeWithSelector(
             IAuthorizable.AuthorizableSignerStillThawing.selector,
             block.timestamp,
-            block.timestamp - _skip + authorizable.REVOKE_AUTHORIZATION_THAWING_PERIOD()
+            block.timestamp - _skip + authHelper.revokeAuthorizationThawingPeriod()
         );
         vm.expectRevert(expectedErr);
         vm.prank(_authorizer);
@@ -322,17 +326,19 @@ contract AuthorizableTest is Test, Bounder {
 }
 
 contract AuthorizableHelper is Test {
-    AuthorizableImp internal authorizable;
+    IAuthorizable internal authorizable;
+    uint256 public revokeAuthorizationThawingPeriod;
 
-    constructor(AuthorizableImp _authorizable) {
+    constructor(IAuthorizable _authorizable, uint256 _thawPeriod) {
         authorizable = _authorizable;
+        revokeAuthorizationThawingPeriod = _thawPeriod;
     }
 
     function authorizeAndThawSignerWithChecks(address _authorizer, uint256 _signerKey) public {
         address signer = vm.addr(_signerKey);
         authorizeSignerWithChecks(_authorizer, _signerKey);
 
-        uint256 thawEndTimestamp = block.timestamp + authorizable.REVOKE_AUTHORIZATION_THAWING_PERIOD();
+        uint256 thawEndTimestamp = block.timestamp + revokeAuthorizationThawingPeriod;
         vm.expectEmit(address(authorizable));
         emit IAuthorizable.SignerThawing(_authorizer, signer, thawEndTimestamp);
         vm.prank(_authorizer);
@@ -344,7 +350,7 @@ contract AuthorizableHelper is Test {
     function authorizeAndRevokeSignerWithChecks(address _authorizer, uint256 _signerKey) public {
         address signer = vm.addr(_signerKey);
         authorizeAndThawSignerWithChecks(_authorizer, _signerKey);
-        skip(authorizable.REVOKE_AUTHORIZATION_THAWING_PERIOD() + 1);
+        skip(revokeAuthorizationThawingPeriod + 1);
         vm.expectEmit(address(authorizable));
         emit IAuthorizable.SignerRevoked(_authorizer, signer);
         vm.prank(_authorizer);
@@ -357,6 +363,7 @@ contract AuthorizableHelper is Test {
         address signer = vm.addr(_signerKey);
         assertNotAuthorized(_authorizer, signer);
 
+        require(block.timestamp < type(uint256).max, "Test cannot be run at the end of time");
         uint256 proofDeadline = block.timestamp + 1;
         bytes memory proof = generateAuthorizationProof(
             block.chainid,
diff --git a/packages/horizon/test/unit/utilities/GraphDirectory.t.sol b/packages/horizon/test/unit/utilities/GraphDirectory.t.sol
index 2eea04b73..b552ebf09 100644
--- a/packages/horizon/test/unit/utilities/GraphDirectory.t.sol
+++ b/packages/horizon/test/unit/utilities/GraphDirectory.t.sol
@@ -17,8 +17,7 @@ contract GraphDirectoryTest is GraphBaseTest {
             _getContractFromController("EpochManager"),
             _getContractFromController("RewardsManager"),
             _getContractFromController("GraphTokenGateway"),
-            _getContractFromController("GraphProxyAdmin"),
-            _getContractFromController("Curation")
+            _getContractFromController("GraphProxyAdmin")
         );
         _deployImplementation(address(controller));
     }
@@ -47,7 +46,6 @@ contract GraphDirectoryTest is GraphBaseTest {
         assertEq(_getContractFromController("RewardsManager"), address(directory.graphRewardsManager()));
         assertEq(_getContractFromController("GraphTokenGateway"), address(directory.graphTokenGateway()));
         assertEq(_getContractFromController("GraphProxyAdmin"), address(directory.graphProxyAdmin()));
-        assertEq(_getContractFromController("Curation"), address(directory.graphCuration()));
     }
 
     function test_RevertWhen_AnInvalidContractGetterIsCalled() external {
diff --git a/packages/horizon/test/unit/utilities/GraphDirectoryImplementation.sol b/packages/horizon/test/unit/utilities/GraphDirectoryImplementation.sol
index 4a88bf0cd..bf1ed561d 100644
--- a/packages/horizon/test/unit/utilities/GraphDirectoryImplementation.sol
+++ b/packages/horizon/test/unit/utilities/GraphDirectoryImplementation.sol
@@ -12,7 +12,6 @@ import { IEpochManager } from "@graphprotocol/interfaces/contracts/contracts/epo
 import { IRewardsManager } from "@graphprotocol/interfaces/contracts/contracts/rewards/IRewardsManager.sol";
 import { ITokenGateway } from "@graphprotocol/interfaces/contracts/contracts/arbitrum/ITokenGateway.sol";
 import { IGraphProxyAdmin } from "@graphprotocol/interfaces/contracts/contracts/upgrades/IGraphProxyAdmin.sol";
-import { ICuration } from "@graphprotocol/interfaces/contracts/contracts/curation/ICuration.sol";
 
 import { GraphDirectory } from "./../../../contracts/utilities/GraphDirectory.sol";
 
@@ -22,6 +21,7 @@ contract GraphDirectoryImplementation is GraphDirectory {
     function getContractFromController(bytes memory contractName) external view returns (address) {
         return _graphController().getContractProxy(keccak256(contractName));
     }
+
     function graphToken() external view returns (IGraphToken) {
         return _graphToken();
     }
@@ -57,8 +57,4 @@ contract GraphDirectoryImplementation is GraphDirectory {
     function graphProxyAdmin() external view returns (IGraphProxyAdmin) {
         return _graphProxyAdmin();
     }
-
-    function graphCuration() external view returns (ICuration) {
-        return _graphCuration();
-    }
 }
diff --git a/packages/horizon/test/unit/utils/Bounder.t.sol b/packages/horizon/test/unit/utils/Bounder.t.sol
index 44e977f57..d532cd9df 100644
--- a/packages/horizon/test/unit/utils/Bounder.t.sol
+++ b/packages/horizon/test/unit/utils/Bounder.t.sol
@@ -1,23 +1,27 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.27;
+pragma solidity 0.8.27 || 0.8.33;
 
 import { Test } from "forge-std/Test.sol";
 
 contract Bounder is Test {
     uint256 constant SECP256K1_CURVE_ORDER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141;
 
+    function boundKeyAndAddr(uint256 _value) internal pure returns (uint256, address) {
+        uint256 key = bound(_value, 1, SECP256K1_CURVE_ORDER - 1);
+        return (key, vm.addr(key));
+    }
+
     function boundAddrAndKey(uint256 _value) internal pure returns (uint256, address) {
-        uint256 signerKey = bound(_value, 1, SECP256K1_CURVE_ORDER - 1);
-        return (signerKey, vm.addr(signerKey));
+        return boundKeyAndAddr(_value);
     }
 
     function boundAddr(uint256 _value) internal pure returns (address) {
-        (, address addr) = boundAddrAndKey(_value);
+        (, address addr) = boundKeyAndAddr(_value);
         return addr;
     }
 
     function boundKey(uint256 _value) internal pure returns (uint256) {
-        (uint256 key, ) = boundAddrAndKey(_value);
+        (uint256 key, ) = boundKeyAndAddr(_value);
         return key;
     }
 
@@ -28,4 +32,21 @@ contract Bounder is Test {
     function boundTimestampMin(uint256 _value, uint256 _min) internal pure returns (uint256) {
         return bound(_value, _min, type(uint256).max);
     }
+
+    function boundSkipFloor(uint256 _value, uint256 _min) internal view returns (uint256) {
+        return boundSkip(_value, _min, type(uint256).max);
+    }
+
+    function boundSkipCeil(uint256 _value, uint256 _max) internal view returns (uint256) {
+        return boundSkip(_value, 0, _max);
+    }
+
+    function boundSkip(uint256 _value, uint256 _min, uint256 _max) internal view returns (uint256) {
+        return bound(_value, orTillEndOfTime(_min), orTillEndOfTime(_max));
+    }
+
+    function orTillEndOfTime(uint256 _value) internal view returns (uint256) {
+        uint256 tillEndOfTime = type(uint256).max - block.timestamp;
+        return _value < tillEndOfTime ? _value : tillEndOfTime;
+    }
 }
diff --git a/packages/horizon/test/unit/utils/Users.sol b/packages/horizon/test/unit/utils/Users.sol
index 6213e4e82..c47395a14 100644
--- a/packages/horizon/test/unit/utils/Users.sol
+++ b/packages/horizon/test/unit/utils/Users.sol
@@ -9,5 +9,4 @@ struct Users {
     address gateway;
     address verifier;
     address delegator;
-    address legacySlasher;
 }
diff --git a/packages/interfaces/contracts/contracts/rewards/IRewardsManager.sol b/packages/interfaces/contracts/contracts/rewards/IRewardsManager.sol
index aa7d32eba..05d609101 100644
--- a/packages/interfaces/contracts/contracts/rewards/IRewardsManager.sol
+++ b/packages/interfaces/contracts/contracts/rewards/IRewardsManager.sol
@@ -278,7 +278,7 @@ interface IRewardsManager {
 
     /**
      * @notice Pull rewards from the contract for a particular allocation
-     * @dev This function can only be called by the Staking contract.
+     * @dev This function can only be called by the Subgraph Service contract.
      * This function will mint the necessary tokens to reward based on the inflation calculation.
      * @param allocationID Allocation
      * @return Assigned rewards amount
diff --git a/packages/interfaces/contracts/data-service/IDataServiceFees.sol b/packages/interfaces/contracts/data-service/IDataServiceFees.sol
index 9cba91d7a..e9bf60bf0 100644
--- a/packages/interfaces/contracts/data-service/IDataServiceFees.sol
+++ b/packages/interfaces/contracts/data-service/IDataServiceFees.sol
@@ -26,70 +26,6 @@ import { IDataService } from "./IDataService.sol";
  * bugs. We may have an active bug bounty program.
  */
 interface IDataServiceFees is IDataService {
-    /**
-     * @notice A stake claim, representing provisioned stake that gets locked
-     * to be released to a service provider.
-     * @dev StakeClaims are stored in linked lists by service provider, ordered by
-     * creation timestamp.
-     * @param tokens The amount of tokens to be locked in the claim
-     * @param createdAt The timestamp when the claim was created
-     * @param releasableAt The timestamp when the tokens can be released
-     * @param nextClaim The next claim in the linked list
-     */
-    struct StakeClaim {
-        uint256 tokens;
-        uint256 createdAt;
-        uint256 releasableAt;
-        bytes32 nextClaim;
-    }
-
-    /**
-     * @notice Emitted when a stake claim is created and stake is locked.
-     * @param serviceProvider The address of the service provider
-     * @param claimId The id of the stake claim
-     * @param tokens The amount of tokens to lock in the claim
-     * @param unlockTimestamp The timestamp when the tokens can be released
-     */
-    event StakeClaimLocked(
-        address indexed serviceProvider,
-        bytes32 indexed claimId,
-        uint256 tokens,
-        uint256 unlockTimestamp
-    );
-
-    /**
-     * @notice Emitted when a stake claim is released and stake is unlocked.
-     * @param serviceProvider The address of the service provider
-     * @param claimId The id of the stake claim
-     * @param tokens The amount of tokens released
-     * @param releasableAt The timestamp when the tokens were released
-     */
-    event StakeClaimReleased(
-        address indexed serviceProvider,
-        bytes32 indexed claimId,
-        uint256 tokens,
-        uint256 releasableAt
-    );
-
-    /**
-     * @notice Emitted when a series of stake claims are released.
-     * @param serviceProvider The address of the service provider
-     * @param claimsCount The number of stake claims being released
-     * @param tokensReleased The total amount of tokens being released
-     */
-    event StakeClaimsReleased(address indexed serviceProvider, uint256 claimsCount, uint256 tokensReleased);
-
-    /**
-     * @notice Thrown when attempting to get a stake claim that does not exist.
-     * @param claimId The id of the stake claim
-     */
-    error DataServiceFeesClaimNotFound(bytes32 claimId);
-
-    /**
-     * @notice Emitted when trying to lock zero tokens in a stake claim
-     */
-    error DataServiceFeesZeroTokens();
-
     /**
      * @notice Releases expired stake claims for the caller.
      * @dev This function is only meant to be called if the service provider has enough
diff --git a/packages/interfaces/contracts/data-service/IDataServiceRescuable.sol b/packages/interfaces/contracts/data-service/IDataServiceRescuable.sol
deleted file mode 100644
index 4607e664c..000000000
--- a/packages/interfaces/contracts/data-service/IDataServiceRescuable.sol
+++ /dev/null
@@ -1,72 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.22;
-
-// TODO: Re-enable and fix issues when publishing a new version
-// solhint-disable gas-indexed-events
-
-import { IDataService } from "./IDataService.sol";
-
-/**
- * @title Interface for the {IDataServicePausable} contract.
- * @author Edge & Node
- * @notice Extension for the {IDataService} contract, adds the ability to rescue
- * any ERC20 token or ETH from the contract, controlled by a rescuer privileged role.
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-interface IDataServiceRescuable is IDataService {
-    /**
-     * @notice Emitted when tokens are rescued from the contract.
-     * @param from The address initiating the rescue
-     * @param to The address receiving the rescued tokens
-     * @param token The address of the token being rescued
-     * @param tokens The amount of tokens rescued
-     */
-    event TokensRescued(address indexed from, address indexed to, address indexed token, uint256 tokens);
-
-    /**
-     * @notice Emitted when a rescuer is set.
-     * @param account The address of the rescuer
-     * @param allowed Whether the rescuer is allowed to rescue tokens
-     */
-    event RescuerSet(address indexed account, bool allowed);
-
-    /**
-     * @notice Thrown when trying to rescue zero tokens.
-     */
-    error DataServiceRescuableCannotRescueZero();
-
-    /**
-     * @notice Thrown when the caller is not a rescuer.
-     * @param account The address of the account that attempted the rescue
-     */
-    error DataServiceRescuableNotRescuer(address account);
-
-    /**
-     * @notice Rescues GRT tokens from the contract.
-     * @dev Declared as virtual to allow disabling the function via override.
-     *
-     * Requirements:
-     * - Cannot rescue zero tokens.
-     *
-     * Emits a {TokensRescued} event.
-     *
-     * @param to Address of the tokens recipient.
-     * @param tokens Amount of tokens to rescue.
-     */
-    function rescueGRT(address to, uint256 tokens) external;
-
-    /**
-     * @notice Rescues ether from the contract.
-     * @dev Declared as virtual to allow disabling the function via override.
-     *
-     * Requirements:
-     * - Cannot rescue zeroether.
-     *
-     * Emits a {TokensRescued} event.
-     *
-     * @param to Address of the tokens recipient.
-     * @param tokens Amount of tokens to rescue.
-     */
-    function rescueETH(address payable to, uint256 tokens) external;
-}
diff --git a/packages/interfaces/contracts/horizon/IHorizonStaking.sol b/packages/interfaces/contracts/horizon/IHorizonStaking.sol
index 4e680a1e5..9b16ad368 100644
--- a/packages/interfaces/contracts/horizon/IHorizonStaking.sol
+++ b/packages/interfaces/contracts/horizon/IHorizonStaking.sol
@@ -5,15 +5,14 @@ pragma solidity ^0.8.22;
 import { IHorizonStakingTypes } from "./internal/IHorizonStakingTypes.sol";
 import { IHorizonStakingMain } from "./internal/IHorizonStakingMain.sol";
 import { IHorizonStakingBase } from "./internal/IHorizonStakingBase.sol";
-import { IHorizonStakingExtension } from "./internal/IHorizonStakingExtension.sol";
 
 /**
  * @title Complete interface for the Horizon Staking contract
  * @author Edge & Node
- * @notice This interface exposes all functions implemented by the {HorizonStaking} contract and its extension
- * {HorizonStakingExtension} as well as the custom data types used by the contract.
+ * @notice This interface exposes all functions implemented by the {HorizonStaking} contract
+ * as well as the custom data types used by the contract.
  * @dev Use this interface to interact with the Horizon Staking contract.
  * @custom:security-contact Please email security+contracts@thegraph.com if you find any
  * bugs. We may have an active bug bounty program.
  */
-interface IHorizonStaking is IHorizonStakingTypes, IHorizonStakingBase, IHorizonStakingMain, IHorizonStakingExtension {}
+interface IHorizonStaking is IHorizonStakingTypes, IHorizonStakingBase, IHorizonStakingMain {}
diff --git a/packages/interfaces/contracts/horizon/IRecurringCollector.sol b/packages/interfaces/contracts/horizon/IRecurringCollector.sol
new file mode 100644
index 000000000..445c4cb0b
--- /dev/null
+++ b/packages/interfaces/contracts/horizon/IRecurringCollector.sol
@@ -0,0 +1,483 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.33;
+
+import { IPaymentsCollector } from "./IPaymentsCollector.sol";
+import { IGraphPayments } from "./IGraphPayments.sol";
+import { IAuthorizable } from "./IAuthorizable.sol";
+
+/**
+ * @title Interface for the {RecurringCollector} contract
+ * @author Edge & Node
+ * @dev Implements the {IPaymentCollector} interface as defined by the Graph
+ * Horizon payments protocol.
+ * @notice Implements a payments collector contract that can be used to collect
+ * recurrent payments.
+ */
+interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
+    /// @notice The state of an agreement
+    enum AgreementState {
+        NotAccepted,
+        Accepted,
+        CanceledByServiceProvider,
+        CanceledByPayer
+    }
+
+    /// @notice The party that can cancel an agreement
+    enum CancelAgreementBy {
+        ServiceProvider,
+        Payer,
+        ThirdParty
+    }
+
+    /// @notice Reasons why an agreement is not collectable
+    enum AgreementNotCollectableReason {
+        None,
+        InvalidAgreementState,
+        ZeroCollectionSeconds,
+        InvalidTemporalWindow
+    }
+
+    /**
+     * @notice A representation of a signed Recurring Collection Agreement (RCA)
+     * @param rca The Recurring Collection Agreement to be signed
+     * @param signature The signature of the RCA - 65 bytes: r (32 Bytes) || s (32 Bytes) || v (1 Byte)
+     */
+    struct SignedRCA {
+        RecurringCollectionAgreement rca;
+        bytes signature;
+    }
+
+    /**
+     * @notice The Recurring Collection Agreement (RCA)
+     * @param deadline The deadline for accepting the RCA
+     * @param endsAt The timestamp when the agreement ends
+     * @param payer The address of the payer the RCA was issued by
+     * @param dataService The address of the data service the RCA was issued to
+     * @param serviceProvider The address of the service provider the RCA was issued to
+     * @param maxInitialTokens The maximum amount of tokens that can be collected in the first collection
+     * on top of the amount allowed for subsequent collections
+     * @param maxOngoingTokensPerSecond The maximum amount of tokens that can be collected per second
+     * except for the first collection
+     * @param minSecondsPerCollection The minimum amount of seconds that must pass between collections
+     * @param maxSecondsPerCollection The maximum amount of seconds that can pass between collections
+     * @param nonce A unique nonce for preventing collisions (user-chosen)
+     * @param metadata Arbitrary metadata to extend functionality if a data service requires it
+     *
+     */
+    // solhint-disable-next-line gas-struct-packing
+    struct RecurringCollectionAgreement {
+        uint64 deadline;
+        uint64 endsAt;
+        address payer;
+        address dataService;
+        address serviceProvider;
+        uint256 maxInitialTokens;
+        uint256 maxOngoingTokensPerSecond;
+        uint32 minSecondsPerCollection;
+        uint32 maxSecondsPerCollection;
+        uint256 nonce;
+        bytes metadata;
+    }
+
+    /**
+     * @notice A representation of a signed Recurring Collection Agreement Update (RCAU)
+     * @param rcau The Recurring Collection Agreement Update to be signed
+     * @param signature The signature of the RCAU - 65 bytes: r (32 Bytes) || s (32 Bytes) || v (1 Byte)
+     */
+    struct SignedRCAU {
+        RecurringCollectionAgreementUpdate rcau;
+        bytes signature;
+    }
+
+    /**
+     * @notice The Recurring Collection Agreement Update (RCAU)
+     * @param agreementId The agreement ID of the RCAU
+     * @param deadline The deadline for upgrading the RCA
+     * @param endsAt The timestamp when the agreement ends
+     * @param maxInitialTokens The maximum amount of tokens that can be collected in the first collection
+     * on top of the amount allowed for subsequent collections
+     * @param maxOngoingTokensPerSecond The maximum amount of tokens that can be collected per second
+     * except for the first collection
+     * @param minSecondsPerCollection The minimum amount of seconds that must pass between collections
+     * @param maxSecondsPerCollection The maximum amount of seconds that can pass between collections
+     * @param nonce The nonce for preventing replay attacks (must be current nonce + 1)
+     * @param metadata Arbitrary metadata to extend functionality if a data service requires it
+     */
+    // solhint-disable-next-line gas-struct-packing
+    struct RecurringCollectionAgreementUpdate {
+        bytes16 agreementId;
+        uint64 deadline;
+        uint64 endsAt;
+        uint256 maxInitialTokens;
+        uint256 maxOngoingTokensPerSecond;
+        uint32 minSecondsPerCollection;
+        uint32 maxSecondsPerCollection;
+        uint32 nonce;
+        bytes metadata;
+    }
+
+    /**
+     * @notice The data for an agreement
+     * @dev This struct is used to store the data of an agreement in the contract
+     * @param dataService The address of the data service
+     * @param payer The address of the payer
+     * @param serviceProvider The address of the service provider
+     * @param acceptedAt The timestamp when the agreement was accepted
+     * @param lastCollectionAt The timestamp when the agreement was last collected at
+     * @param endsAt The timestamp when the agreement ends
+     * @param maxInitialTokens The maximum amount of tokens that can be collected in the first collection
+     * on top of the amount allowed for subsequent collections
+     * @param maxOngoingTokensPerSecond The maximum amount of tokens that can be collected per second
+     * except for the first collection
+     * @param minSecondsPerCollection The minimum amount of seconds that must pass between collections
+     * @param maxSecondsPerCollection The maximum amount of seconds that can pass between collections
+     * @param updateNonce The current nonce for updates (prevents replay attacks)
+     * @param canceledAt The timestamp when the agreement was canceled
+     * @param state The state of the agreement
+     */
+    struct AgreementData {
+        address dataService;
+        address payer;
+        address serviceProvider;
+        uint64 acceptedAt;
+        uint64 lastCollectionAt;
+        uint64 endsAt;
+        uint256 maxInitialTokens;
+        uint256 maxOngoingTokensPerSecond;
+        uint32 minSecondsPerCollection;
+        uint32 maxSecondsPerCollection;
+        uint32 updateNonce;
+        uint64 canceledAt;
+        AgreementState state;
+    }
+
+    /**
+     * @notice The params for collecting an agreement
+     * @param agreementId The agreement ID of the RCA
+     * @param collectionId The collection ID of the RCA
+     * @param tokens The amount of tokens to collect
+     * @param dataServiceCut The data service cut in parts per million
+     * @param receiverDestination The address where the collected fees should be sent
+     * @param maxSlippage Max acceptable tokens to lose due to rate limiting, or type(uint256).max to ignore
+     */
+    struct CollectParams {
+        bytes16 agreementId;
+        bytes32 collectionId;
+        uint256 tokens;
+        uint256 dataServiceCut;
+        address receiverDestination;
+        uint256 maxSlippage;
+    }
+
+    /**
+     * @notice Emitted when an agreement is accepted
+     * @param dataService The address of the data service
+     * @param payer The address of the payer
+     * @param serviceProvider The address of the service provider
+     * @param agreementId The agreement ID
+     * @param acceptedAt The timestamp when the agreement was accepted
+     * @param endsAt The timestamp when the agreement ends
+     * @param maxInitialTokens The maximum amount of tokens that can be collected in the first collection
+     * @param maxOngoingTokensPerSecond The maximum amount of tokens that can be collected per second
+     * @param minSecondsPerCollection The minimum amount of seconds that must pass between collections
+     * @param maxSecondsPerCollection The maximum amount of seconds that can pass between collections
+     */
+    event AgreementAccepted(
+        address indexed dataService,
+        address indexed payer,
+        address indexed serviceProvider,
+        bytes16 agreementId,
+        uint64 acceptedAt,
+        uint64 endsAt,
+        uint256 maxInitialTokens,
+        uint256 maxOngoingTokensPerSecond,
+        uint32 minSecondsPerCollection,
+        uint32 maxSecondsPerCollection
+    );
+
+    /**
+     * @notice Emitted when an agreement is canceled
+     * @param dataService The address of the data service
+     * @param payer The address of the payer
+     * @param serviceProvider The address of the service provider
+     * @param agreementId The agreement ID
+     * @param canceledAt The timestamp when the agreement was canceled
+     * @param canceledBy The party that canceled the agreement
+     */
+    event AgreementCanceled(
+        address indexed dataService,
+        address indexed payer,
+        address indexed serviceProvider,
+        bytes16 agreementId,
+        uint64 canceledAt,
+        CancelAgreementBy canceledBy
+    );
+
+    /**
+     * @notice Emitted when an agreement is updated
+     * @param dataService The address of the data service
+     * @param payer The address of the payer
+     * @param serviceProvider The address of the service provider
+     * @param agreementId The agreement ID
+     * @param updatedAt The timestamp when the agreement was updated
+     * @param endsAt The timestamp when the agreement ends
+     * @param maxInitialTokens The maximum amount of tokens that can be collected in the first collection
+     * @param maxOngoingTokensPerSecond The maximum amount of tokens that can be collected per second
+     * @param minSecondsPerCollection The minimum amount of seconds that must pass between collections
+     * @param maxSecondsPerCollection The maximum amount of seconds that can pass between collections
+     */
+    event AgreementUpdated(
+        address indexed dataService,
+        address indexed payer,
+        address indexed serviceProvider,
+        bytes16 agreementId,
+        uint64 updatedAt,
+        uint64 endsAt,
+        uint256 maxInitialTokens,
+        uint256 maxOngoingTokensPerSecond,
+        uint32 minSecondsPerCollection,
+        uint32 maxSecondsPerCollection
+    );
+
+    /**
+     * @notice Emitted when an RCA is collected
+     * @param dataService The address of the data service
+     * @param payer The address of the payer
+     * @param serviceProvider The address of the service provider
+     * @param agreementId The agreement ID
+     * @param collectionId The collection ID
+     * @param tokens The amount of tokens collected
+     * @param dataServiceCut The tokens cut for the data service
+     */
+    event RCACollected(
+        address indexed dataService,
+        address indexed payer,
+        address indexed serviceProvider,
+        bytes16 agreementId,
+        bytes32 collectionId,
+        uint256 tokens,
+        uint256 dataServiceCut
+    );
+
+    /**
+     * @notice Thrown when accepting an agreement with a zero ID
+     */
+    error RecurringCollectorAgreementIdZero();
+
+    /**
+     * @notice Thrown when interacting with an agreement not owned by the message sender
+     * @param agreementId The agreement ID
+     * @param unauthorizedDataService The address of the unauthorized data service
+     */
+    error RecurringCollectorDataServiceNotAuthorized(bytes16 agreementId, address unauthorizedDataService);
+    /**
+     * @notice Thrown when the data service is not authorized for the service provider
+     * @param dataService The address of the unauthorized data service
+     */
+    error RecurringCollectorUnauthorizedDataService(address dataService);
+
+    /**
+     * @notice Thrown when interacting with an agreement with an elapsed deadline
+     * @param currentTimestamp The current timestamp
+     * @param deadline The elapsed deadline timestamp
+     */
+    error RecurringCollectorAgreementDeadlineElapsed(uint256 currentTimestamp, uint64 deadline);
+
+    /**
+     * @notice Thrown when the signer is invalid
+     */
+    error RecurringCollectorInvalidSigner();
+
+    /**
+     * @notice Thrown when the payment type is not IndexingFee
+     * @param invalidPaymentType The invalid payment type
+     */
+    error RecurringCollectorInvalidPaymentType(IGraphPayments.PaymentTypes invalidPaymentType);
+
+    /**
+     * @notice Thrown when the caller is not the data service the RCA was issued to
+     * @param unauthorizedCaller The address of the caller
+     * @param dataService The address of the data service
+     */
+    error RecurringCollectorUnauthorizedCaller(address unauthorizedCaller, address dataService);
+
+    /**
+     * @notice Thrown when calling collect() with invalid data
+     * @param invalidData The invalid data
+     */
+    error RecurringCollectorInvalidCollectData(bytes invalidData);
+
+    /**
+     * @notice Thrown when interacting with an agreement that has an incorrect state
+     * @param agreementId The agreement ID
+     * @param incorrectState The incorrect state
+     */
+    error RecurringCollectorAgreementIncorrectState(bytes16 agreementId, AgreementState incorrectState);
+
+    /**
+     * @notice Thrown when an agreement is not collectable
+     * @param agreementId The agreement ID
+     * @param reason The reason why the agreement is not collectable
+     */
+    error RecurringCollectorAgreementNotCollectable(bytes16 agreementId, AgreementNotCollectableReason reason);
+
+    /**
+     * @notice Thrown when accepting an agreement with an address that is not set
+     */
+    error RecurringCollectorAgreementAddressNotSet();
+
+    /**
+     * @notice Thrown when accepting or upgrading an agreement with an elapsed endsAt
+     * @param currentTimestamp The current timestamp
+     * @param endsAt The agreement end timestamp
+     */
+    error RecurringCollectorAgreementElapsedEndsAt(uint256 currentTimestamp, uint64 endsAt);
+
+    /**
+     * @notice Thrown when accepting or upgrading an agreement with an elapsed endsAt
+     * @param allowedMinCollectionWindow The allowed minimum collection window
+     * @param minSecondsPerCollection The minimum seconds per collection
+     * @param maxSecondsPerCollection The maximum seconds per collection
+     */
+    error RecurringCollectorAgreementInvalidCollectionWindow(
+        uint32 allowedMinCollectionWindow,
+        uint32 minSecondsPerCollection,
+        uint32 maxSecondsPerCollection
+    );
+
+    /**
+     * @notice Thrown when accepting or upgrading an agreement with an invalid duration
+     * @param requiredMinDuration The required minimum duration
+     * @param invalidDuration The invalid duration
+     */
+    error RecurringCollectorAgreementInvalidDuration(uint32 requiredMinDuration, uint256 invalidDuration);
+
+    /**
+     * @notice Thrown when calling collect() with a zero collection seconds
+     * @param agreementId The agreement ID
+     * @param currentTimestamp The current timestamp
+     * @param lastCollectionAt The timestamp when the last collection was done
+     *
+     */
+    error RecurringCollectorZeroCollectionSeconds(
+        bytes16 agreementId,
+        uint256 currentTimestamp,
+        uint64 lastCollectionAt
+    );
+
+    /**
+     * @notice Thrown when calling collect() too soon
+     * @param agreementId The agreement ID
+     * @param secondsSinceLast Seconds since last collection
+     * @param minSeconds Minimum seconds between collections
+     */
+    error RecurringCollectorCollectionTooSoon(bytes16 agreementId, uint32 secondsSinceLast, uint32 minSeconds);
+
+    /**
+     * @notice Thrown when calling collect() too late
+     * @param agreementId The agreement ID
+     * @param secondsSinceLast Seconds since last collection
+     * @param maxSeconds Maximum seconds between collections
+     */
+    error RecurringCollectorCollectionTooLate(bytes16 agreementId, uint64 secondsSinceLast, uint32 maxSeconds);
+
+    /**
+     * @notice Thrown when calling update() with an invalid nonce
+     * @param agreementId The agreement ID
+     * @param expected The expected nonce
+     * @param provided The provided nonce
+     */
+    error RecurringCollectorInvalidUpdateNonce(bytes16 agreementId, uint32 expected, uint32 provided);
+
+    /**
+     * @notice Thrown when collected tokens are less than requested beyond the allowed slippage
+     * @param requested The amount of tokens requested to collect
+     * @param actual The actual amount that would be collected
+     * @param maxSlippage The maximum allowed slippage
+     */
+    error RecurringCollectorExcessiveSlippage(uint256 requested, uint256 actual, uint256 maxSlippage);
+
+    /**
+     * @notice Accept an indexing agreement.
+     * @param signedRCA The signed Recurring Collection Agreement which is to be accepted.
+     * @return agreementId The deterministically generated agreement ID
+     */
+    function accept(SignedRCA calldata signedRCA) external returns (bytes16 agreementId);
+
+    /**
+     * @notice Cancel an indexing agreement.
+     * @param agreementId The agreement's ID.
+     * @param by The party that is canceling the agreement.
+     */
+    function cancel(bytes16 agreementId, CancelAgreementBy by) external;
+
+    /**
+     * @notice Update an indexing agreement.
+     * @param signedRCAU The signed Recurring Collection Agreement Update which is to be applied.
+     */
+    function update(SignedRCAU calldata signedRCAU) external;
+
+    /**
+     * @notice Computes the hash of a RecurringCollectionAgreement (RCA).
+     * @param rca The RCA for which to compute the hash.
+     * @return The hash of the RCA.
+     */
+    function hashRCA(RecurringCollectionAgreement calldata rca) external view returns (bytes32);
+
+    /**
+     * @notice Computes the hash of a RecurringCollectionAgreementUpdate (RCAU).
+     * @param rcau The RCAU for which to compute the hash.
+     * @return The hash of the RCAU.
+     */
+    function hashRCAU(RecurringCollectionAgreementUpdate calldata rcau) external view returns (bytes32);
+
+    /**
+     * @notice Recovers the signer address of a signed RecurringCollectionAgreement (RCA).
+     * @param signedRCA The SignedRCA containing the RCA and its signature.
+     * @return The address of the signer.
+     */
+    function recoverRCASigner(SignedRCA calldata signedRCA) external view returns (address);
+
+    /**
+     * @notice Recovers the signer address of a signed RecurringCollectionAgreementUpdate (RCAU).
+     * @param signedRCAU The SignedRCAU containing the RCAU and its signature.
+     * @return The address of the signer.
+     */
+    function recoverRCAUSigner(SignedRCAU calldata signedRCAU) external view returns (address);
+
+    /**
+     * @notice Gets an agreement.
+     * @param agreementId The ID of the agreement to retrieve.
+     * @return The AgreementData struct containing the agreement's data.
+     */
+    function getAgreement(bytes16 agreementId) external view returns (AgreementData memory);
+
+    /**
+     * @notice Get collection info for an agreement
+     * @param agreement The agreement data
+     * @return isCollectable Whether the agreement is in a valid state that allows collection attempts,
+     * not that there are necessarily funds available to collect.
+     * @return collectionSeconds The valid collection duration in seconds (0 if not collectable)
+     * @return reason The reason why the agreement is not collectable (None if collectable)
+     */
+    function getCollectionInfo(
+        AgreementData calldata agreement
+    ) external view returns (bool isCollectable, uint256 collectionSeconds, AgreementNotCollectableReason reason);
+
+    /**
+     * @notice Generate a deterministic agreement ID from agreement parameters
+     * @param payer The address of the payer
+     * @param dataService The address of the data service
+     * @param serviceProvider The address of the service provider
+     * @param deadline The deadline for accepting the agreement
+     * @param nonce A unique nonce for preventing collisions
+     * @return agreementId The deterministically generated agreement ID
+     */
+    function generateAgreementId(
+        address payer,
+        address dataService,
+        address serviceProvider,
+        uint64 deadline,
+        uint256 nonce
+    ) external pure returns (bytes16 agreementId);
+}
diff --git a/packages/interfaces/contracts/horizon/internal/IHorizonStakingBase.sol b/packages/interfaces/contracts/horizon/internal/IHorizonStakingBase.sol
index c48f20099..4bc81d44f 100644
--- a/packages/interfaces/contracts/horizon/internal/IHorizonStakingBase.sol
+++ b/packages/interfaces/contracts/horizon/internal/IHorizonStakingBase.sol
@@ -13,7 +13,7 @@ import { ILinkedList } from "./ILinkedList.sol";
 /**
  * @title Interface for the {HorizonStakingBase} contract.
  * @author Edge & Node
- * @notice Provides getters for {HorizonStaking} and {HorizonStakingExtension} storage variables.
+ * @notice Provides getters for {HorizonStaking} storage variables.
  * @dev Most functions operate over {HorizonStaking} provisions. To uniquely identify a provision
  * functions take `serviceProvider` and `verifier` addresses.
  * @custom:security-contact Please email security+contracts@thegraph.com if you find any
@@ -21,19 +21,15 @@ import { ILinkedList } from "./ILinkedList.sol";
  */
 interface IHorizonStakingBase {
     /**
-     * @notice Emitted when a service provider stakes tokens.
-     * @dev TRANSITION PERIOD: After transition period move to IHorizonStakingMain. Temporarily it
-     * needs to be here since it's emitted by {_stake} which is used by both {HorizonStaking}
-     * and {HorizonStakingExtension}.
-     * @param serviceProvider The address of the service provider.
-     * @param tokens The amount of tokens staked.
+     * @notice Thrown when using an invalid thaw request type.
      */
-    event HorizonStakeDeposited(address indexed serviceProvider, uint256 tokens);
+    error HorizonStakingInvalidThawRequestType();
 
     /**
-     * @notice Thrown when using an invalid thaw request type.
+     * @notice Gets the address of the subgraph data service.
+     * @return The address of the subgraph data service.
      */
-    error HorizonStakingInvalidThawRequestType();
+    function getSubgraphService() external view returns (address);
 
     /**
      * @notice Gets the details of a service provider.
diff --git a/packages/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol b/packages/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol
deleted file mode 100644
index d487b2eca..000000000
--- a/packages/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol
+++ /dev/null
@@ -1,215 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-pragma solidity ^0.8.22;
-
-// TODO: Re-enable and fix issues when publishing a new version
-// solhint-disable gas-indexed-events
-
-import { IRewardsIssuer } from "../../contracts/rewards/IRewardsIssuer.sol";
-
-/**
- * @title Interface for {HorizonStakingExtension} contract.
- * @author Edge & Node
- * @notice Provides functions for managing legacy allocations.
- * @custom:security-contact Please email security+contracts@thegraph.com if you find any
- * bugs. We may have an active bug bounty program.
- */
-interface IHorizonStakingExtension is IRewardsIssuer {
-    /**
-     * @dev Allocate GRT tokens for the purpose of serving queries of a subgraph deployment
-     * An allocation is created in the allocate() function and closed in closeAllocation()
-     * @param indexer The indexer address
-     * @param subgraphDeploymentID The subgraph deployment ID
-     * @param tokens The amount of tokens allocated to the subgraph deployment
-     * @param createdAtEpoch The epoch when the allocation was created
-     * @param closedAtEpoch The epoch when the allocation was closed
-     * @param collectedFees The amount of collected fees for the allocation
-     * @param __DEPRECATED_effectiveAllocation Deprecated field.
-     * @param accRewardsPerAllocatedToken Snapshot used for reward calculation
-     * @param distributedRebates The amount of collected rebates that have been rebated
-     */
-    struct Allocation {
-        address indexer;
-        bytes32 subgraphDeploymentID;
-        uint256 tokens;
-        uint256 createdAtEpoch;
-        uint256 closedAtEpoch;
-        uint256 collectedFees;
-        uint256 __DEPRECATED_effectiveAllocation;
-        uint256 accRewardsPerAllocatedToken;
-        uint256 distributedRebates;
-    }
-
-    /**
-     * @dev Possible states an allocation can be.
-     * States:
-     * - Null = indexer == address(0)
-     * - Active = not Null && tokens > 0
-     * - Closed = Active && closedAtEpoch != 0
-     */
-    enum AllocationState {
-        Null,
-        Active,
-        Closed
-    }
-
-    /**
-     * @notice Emitted when `indexer` close an allocation in `epoch` for `allocationID`.
-     * An amount of `tokens` get unallocated from `subgraphDeploymentID`.
-     * This event also emits the POI (proof of indexing) submitted by the indexer.
-     * `isPublic` is true if the sender was someone other than the indexer.
-     * @param indexer The indexer address
-     * @param subgraphDeploymentID The subgraph deployment ID
-     * @param epoch The protocol epoch the allocation was closed on
-     * @param tokens The amount of tokens unallocated from the allocation
-     * @param allocationID The allocation identifier
-     * @param sender The address closing the allocation
-     * @param poi The proof of indexing submitted by the sender
-     * @param isPublic True if the allocation was force closed by someone other than the indexer/operator
-     */
-    event AllocationClosed(
-        address indexed indexer,
-        bytes32 indexed subgraphDeploymentID,
-        uint256 epoch,
-        uint256 tokens,
-        address indexed allocationID,
-        address sender,
-        bytes32 poi,
-        bool isPublic
-    );
-
-    /**
-     * @notice Emitted when `indexer` collects a rebate on `subgraphDeploymentID` for `allocationID`.
-     * `epoch` is the protocol epoch the rebate was collected on
-     * The rebate is for `tokens` amount which are being provided by `assetHolder`; `queryFees`
-     * is the amount up for rebate after `curationFees` are distributed and `protocolTax` is burnt.
-     * `queryRebates` is the amount distributed to the `indexer` with `delegationFees` collected
-     * and sent to the delegation pool.
-     * @param assetHolder The address of the asset holder, the entity paying the query fees
-     * @param indexer The indexer address
-     * @param subgraphDeploymentID The subgraph deployment ID
-     * @param allocationID The allocation identifier
-     * @param epoch The protocol epoch the rebate was collected on
-     * @param tokens The amount of tokens collected
-     * @param protocolTax The amount of tokens burnt as protocol tax
-     * @param curationFees The amount of tokens distributed to the curation pool
-     * @param queryFees The amount of tokens collected as query fees
-     * @param queryRebates The amount of tokens distributed to the indexer
-     * @param delegationRewards The amount of tokens collected from the delegation pool
-     */
-    event RebateCollected(
-        address assetHolder,
-        address indexed indexer,
-        bytes32 indexed subgraphDeploymentID,
-        address indexed allocationID,
-        uint256 epoch,
-        uint256 tokens,
-        uint256 protocolTax,
-        uint256 curationFees,
-        uint256 queryFees,
-        uint256 queryRebates,
-        uint256 delegationRewards
-    );
-
-    /**
-     * @notice Emitted when `indexer` was slashed for a total of `tokens` amount.
-     * Tracks `reward` amount of tokens given to `beneficiary`.
-     * @param indexer The indexer address
-     * @param tokens The amount of tokens slashed
-     * @param reward The amount of reward tokens to send to a beneficiary
-     * @param beneficiary The address of a beneficiary to receive a reward for the slashing
-     */
-    event StakeSlashed(address indexed indexer, uint256 tokens, uint256 reward, address beneficiary);
-
-    /**
-     * @notice Close an allocation and free the staked tokens.
-     * To be eligible for rewards a proof of indexing must be presented.
-     * Presenting a bad proof is subject to slashable condition.
-     * To opt out of rewards set _poi to 0x0
-     * @param allocationID The allocation identifier
-     * @param poi Proof of indexing submitted for the allocated period
-     */
-    function closeAllocation(address allocationID, bytes32 poi) external;
-
-    /**
-     * @notice Collect and rebate query fees to the indexer
-     * This function will accept calls with zero tokens.
-     * We use an exponential rebate formula to calculate the amount of tokens to rebate to the indexer.
-     * This implementation allows collecting multiple times on the same allocation, keeping track of the
-     * total amount rebated, the total amount collected and compensating the indexer for the difference.
-     * @param tokens Amount of tokens to collect
-     * @param allocationID Allocation where the tokens will be assigned
-     */
-    function collect(uint256 tokens, address allocationID) external;
-
-    /**
-     * @notice Slash the indexer stake. Delegated tokens are not subject to slashing.
-     * Note that depending on the state of the indexer's stake, the slashed amount might be smaller than the
-     * requested slash amount. This can happen if the indexer has moved a significant part of their stake to
-     * a provision. Any outstanding slashing amount should be settled using Horizon's slash function
-     * {IHorizonStaking.slash}.
-     * @dev Can only be called by the slasher role.
-     * @param indexer Address of indexer to slash
-     * @param tokens Amount of tokens to slash from the indexer stake
-     * @param reward Amount of reward tokens to send to a beneficiary
-     * @param beneficiary Address of a beneficiary to receive a reward for the slashing
-     */
-    function legacySlash(address indexer, uint256 tokens, uint256 reward, address beneficiary) external;
-
-    /**
-     * @notice (Legacy) Return true if operator is allowed for the service provider on the subgraph data service.
-     * @param operator Address of the operator
-     * @param indexer Address of the service provider
-     * @return True if operator is allowed for indexer, false otherwise
-     */
-    function isOperator(address operator, address indexer) external view returns (bool);
-
-    /**
-     * @notice Getter that returns if an indexer has any stake.
-     * @param indexer Address of the indexer
-     * @return True if indexer has staked tokens
-     */
-    function hasStake(address indexer) external view returns (bool);
-
-    /**
-     * @notice Get the total amount of tokens staked by the indexer.
-     * @param indexer Address of the indexer
-     * @return Amount of tokens staked by the indexer
-     */
-    function getIndexerStakedTokens(address indexer) external view returns (uint256);
-
-    /**
-     * @notice Return the allocation by ID.
-     * @param allocationID Address used as allocation identifier
-     * @return Allocation data
-     */
-    function getAllocation(address allocationID) external view returns (Allocation memory);
-
-    /**
-     * @notice Return the current state of an allocation
-     * @param allocationID Allocation identifier
-     * @return AllocationState enum with the state of the allocation
-     */
-    function getAllocationState(address allocationID) external view returns (AllocationState);
-
-    /**
-     * @notice Return if allocationID is used.
-     * @param allocationID Address used as signer by the indexer for an allocation
-     * @return True if allocationID already used
-     */
-    function isAllocation(address allocationID) external view returns (bool);
-
-    /**
-     * @notice Return the time in blocks to unstake
-     * Deprecated, now enforced by each data service (verifier)
-     * @return Thawing period in blocks
-     */
-    function __DEPRECATED_getThawingPeriod() external view returns (uint64);
-
-    /**
-     * @notice Return the address of the subgraph data service.
-     * @dev TRANSITION PERIOD: After transition period move to main HorizonStaking contract
-     * @return Address of the subgraph data service
-     */
-    function getSubgraphService() external view returns (address);
-}
diff --git a/packages/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol b/packages/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol
index 19c1e1cf8..1c87fee1e 100644
--- a/packages/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol
+++ b/packages/interfaces/contracts/horizon/internal/IHorizonStakingMain.sol
@@ -12,13 +12,8 @@ import { IHorizonStakingTypes } from "./IHorizonStakingTypes.sol";
  * @title Inferface for the {HorizonStaking} contract.
  * @author Edge & Node
  * @notice Provides functions for managing stake, provisions, delegations, and slashing.
- * @dev Note that this interface only includes the functions implemented by {HorizonStaking} contract,
- * and not those implemented by {HorizonStakingExtension}.
- * Do not use this interface to interface with the {HorizonStaking} contract, use {IHorizonStaking} for
- * the complete interface.
  * @dev Most functions operate over {HorizonStaking} provisions. To uniquely identify a provision
  * functions take `serviceProvider` and `verifier` addresses.
- * @dev TRANSITION PERIOD: After transition period rename to IHorizonStaking.
  * @custom:security-contact Please email security+contracts@thegraph.com if you find any
  * bugs. We may have an active bug bounty program.
  */
@@ -26,15 +21,14 @@ interface IHorizonStakingMain {
     // -- Events: stake --
 
     /**
-     * @notice Emitted when a service provider unstakes tokens during the transition period.
-     * @param serviceProvider The address of the service provider
-     * @param tokens The amount of tokens now locked (including previously locked tokens)
-     * @param until The block number until the stake is locked
+     * @notice Emitted when a service provider stakes tokens.
+     * @param serviceProvider The address of the service provider.
+     * @param tokens The amount of tokens staked.
      */
-    event HorizonStakeLocked(address indexed serviceProvider, uint256 tokens, uint256 until);
+    event HorizonStakeDeposited(address indexed serviceProvider, uint256 tokens);
 
     /**
-     * @notice Emitted when a service provider withdraws tokens during the transition period.
+     * @notice Emitted when a service provider unstakes tokens.
      * @param serviceProvider The address of the service provider
      * @param tokens The amount of tokens withdrawn
      */
@@ -219,7 +213,7 @@ interface IHorizonStakingMain {
 
     /**
      * @notice Emitted when `delegator` withdrew delegated `tokens` from `indexer` using `withdrawDelegated`.
-     * @dev This event is for the legacy `withdrawDelegated` function.
+     * @dev This event is for the legacy `withdrawDelegated` function, only emitted for pre-horizon undelegations.
      * @param indexer The address of the indexer
      * @param delegator The address of the delegator
      * @param tokens The amount of tokens withdrawn
@@ -324,12 +318,6 @@ interface IHorizonStakingMain {
      */
     event AllowedLockedVerifierSet(address indexed verifier, bool allowed);
 
-    /**
-     * @notice Emitted when the legacy global thawing period is set to zero.
-     * @dev This marks the end of the transition period.
-     */
-    event ThawingPeriodCleared();
-
     /**
      * @notice Emitted when the delegation slashing global flag is set.
      */
@@ -373,13 +361,6 @@ interface IHorizonStakingMain {
      */
     error HorizonStakingNotAuthorized(address serviceProvider, address verifier, address caller);
 
-    /**
-     * @notice Thrown when attempting to create a provision with a verifier other than the
-     * subgraph data service. This restriction only applies during the transition period.
-     * @param verifier The verifier address
-     */
-    error HorizonStakingInvalidVerifier(address verifier);
-
     /**
      * @notice Thrown when attempting to create a provision with an invalid maximum verifier cut.
      * @param maxVerifierCut The maximum verifier cut
@@ -407,14 +388,6 @@ interface IHorizonStakingMain {
      */
     error HorizonStakingInsufficientIdleStake(uint256 tokens, uint256 minTokens);
 
-    /**
-     * @notice Thrown during the transition period when the service provider has insufficient stake to
-     * cover their existing legacy allocations.
-     * @param tokens The actual token amount
-     * @param minTokens The minimum required token amount
-     */
-    error HorizonStakingInsufficientStakeForLegacyAllocations(uint256 tokens, uint256 minTokens);
-
     // -- Errors: delegation --
 
     /**
@@ -480,18 +453,12 @@ interface IHorizonStakingMain {
     error HorizonStakingTooManyThawRequests();
 
     /**
-     * @notice Thrown when attempting to withdraw tokens that have not thawed (legacy undelegate).
+     * @notice Thrown when attempting to withdraw tokens that have not thawed.
+     * @dev This error is only thrown for pre-horizon undelegations.
      */
     error HorizonStakingNothingToWithdraw();
 
     // -- Errors: misc --
-    /**
-     * @notice Thrown during the transition period when attempting to withdraw tokens that are still thawing.
-     * @dev Note this thawing refers to the global thawing period applied to legacy allocated tokens,
-     * it does not refer to thaw requests.
-     * @param until The block number until the stake is locked
-     */
-    error HorizonStakingStillThawing(uint256 until);
 
     /**
      * @notice Thrown when a service provider attempts to operate on verifiers that are not allowed.
@@ -511,11 +478,6 @@ interface IHorizonStakingMain {
      */
     error HorizonStakingInvalidDelegationFeeCut(uint256 feeCut);
 
-    /**
-     * @notice Thrown when a legacy slash fails.
-     */
-    error HorizonStakingLegacySlashFailed();
-
     /**
      * @notice Thrown when there attempting to slash a provision with no tokens to slash.
      */
@@ -571,19 +533,12 @@ interface IHorizonStakingMain {
 
     /**
      * @notice Move idle stake back to the owner's account.
-     * Stake is removed from the protocol:
-     * - During the transition period it's locked for a period of time before it can be withdrawn
-     *   by calling {withdraw}.
-     * - After the transition period it's immediately withdrawn.
-     * Note that after the transition period if there are tokens still locked they will have to be
-     * withdrawn by calling {withdraw}.
+     * Stake is immediately removed from the protocol.
      * @dev Requirements:
      * - `_tokens` cannot be zero.
-     * - `_serviceProvider` must have enough idle stake to cover the staking amount and any
-     *   legacy allocation.
+     * - `_serviceProvider` must have enough idle stake to cover the staking amount.
      *
-     * Emits a {HorizonStakeLocked} event during the transition period.
-     * Emits a {HorizonStakeWithdrawn} event after the transition period.
+     * Emits a {HorizonStakeWithdrawn} event.
      *
      * @param tokens Amount of tokens to unstake
      */
@@ -592,8 +547,12 @@ interface IHorizonStakingMain {
     /**
      * @notice Withdraw service provider tokens once the thawing period (initiated by {unstake}) has passed.
      * All thawed tokens are withdrawn.
-     * @dev This is only needed during the transition period while we still have
-     * a global lock. After that, unstake() will automatically withdraw.
+     * This function is for backwards compatibility with the legacy staking contract.
+     * It only allows withdrawing tokens unstaked before horizon upgrade.
+     * @dev This function can't be removed in case there are still pre-horizon unstakes.
+     *
+     * Emits a {HorizonStakeWithdrawn} event.
+     *
      */
     function withdraw() external;
 
@@ -603,8 +562,6 @@ interface IHorizonStakingMain {
      * service, where the data service is the verifier.
      * This function can be called by the service provider or by an operator authorized by the provider
      * for this specific verifier.
-     * @dev During the transition period, only the subgraph data service can be used as a verifier. This
-     * prevents an escape hatch for legacy allocation stake.
      * @dev Requirements:
      * - `tokens` cannot be zero.
      * - The `serviceProvider` must have enough idle stake to cover the tokens to provision.
@@ -826,7 +783,7 @@ interface IHorizonStakingMain {
      * - `newServiceProvider` and `newVerifier` must not be the zero address.
      * - `newServiceProvider` must have previously provisioned stake to `newVerifier`.
      *
-     * Emits {ThawRequestFulfilled}, {ThawRequestsFulfilled} and {DelegatedTokensWithdrawn} events.
+     * Emits {ThawRequestFulfilled} and {ThawRequestsFulfilled} events.
      *
      * @param oldServiceProvider The old service provider address
      * @param oldVerifier The old verifier address
@@ -883,6 +840,7 @@ interface IHorizonStakingMain {
      * @notice Withdraw undelegated tokens from the subgraph data service provision after thawing.
      * This function is for backwards compatibility with the legacy staking contract.
      * It only allows withdrawing tokens undelegated before horizon upgrade.
+     * @dev This function can't be removed in case there are still pre-horizon undelegations.
      * @dev See {delegate}.
      * @param serviceProvider The service provider address
      * @param deprecated Deprecated parameter kept for backwards compatibility
@@ -971,14 +929,6 @@ interface IHorizonStakingMain {
      */
     function setDelegationSlashingEnabled() external;
 
-    /**
-     * @notice Clear the legacy global thawing period.
-     * This signifies the end of the transition period, after which no legacy allocations should be left.
-     * @dev This function can only be called by the contract governor.
-     * @dev Emits a {ThawingPeriodCleared} event.
-     */
-    function clearThawingPeriod() external;
-
     /**
      * @notice Sets the global maximum thawing period allowed for provisions.
      * @param maxThawingPeriod The new maximum thawing period, in seconds
@@ -1004,8 +954,37 @@ interface IHorizonStakingMain {
     function isAuthorized(address serviceProvider, address verifier, address operator) external view returns (bool);
 
     /**
-     * @notice Get the address of the staking extension.
-     * @return The address of the staking extension
+     * @notice Withdraw service provider legacy locked tokens.
+     * This is a permissionless function that allows anyone to withdraw on behalf of a service provider.
+     * It only allows withdrawing tokens that were unstaked before the Horizon upgrade.
+     * @dev Tokens are always sent to the service provider, not the caller.
+     *
+     * Emits a {HorizonStakeWithdrawn} event.
+     *
+     * @param serviceProvider Address of service provider to withdraw funds from
+     */
+    function forceWithdraw(address serviceProvider) external;
+
+    /**
+     * @notice Withdraw delegator legacy undelegated tokens.
+     * This is a permissionless function that allows anyone to withdraw on behalf of a delegator.
+     * It only allows withdrawing tokens that were undelegated before the Horizon upgrade.
+     * @dev Tokens are always sent to the delegator, not the caller.
+     *
+     * Emits a {StakeDelegatedWithdrawn} event.
+     *
+     * @param serviceProvider The service provider address
+     * @param delegator The delegator address to withdraw funds for
+     * @return The amount of tokens withdrawn
+     */
+    function forceWithdrawDelegated(address serviceProvider, address delegator) external returns (uint256);
+
+    /**
+     * @notice Return if allocationID is used.
+     * @dev This function is used to check for allocation id collisions with legacy allocations
+     * that were created before the Horizon upgrade.
+     * @param allocationID Address used as signer by the indexer for an allocation
+     * @return True if allocationID already used
      */
-    function getStakingExtension() external view returns (address);
+    function isAllocation(address allocationID) external view returns (bool);
 }
diff --git a/packages/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol b/packages/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol
index e8fff211b..22cdb5b4b 100644
--- a/packages/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol
+++ b/packages/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol
@@ -200,4 +200,42 @@ interface IHorizonStakingTypes {
         uint256 tokensThawing;
         uint256 sharesThawing;
     }
+
+    /**
+     * @notice Legacy allocation representation
+     * @dev Kept for storage compatibility and to check for allocation id collisions.
+     * @param indexer The indexer address
+     * @param subgraphDeploymentID The subgraph deployment ID
+     * @param tokens The amount of tokens allocated to the subgraph deployment
+     * @param createdAtEpoch The epoch when the allocation was created
+     * @param closedAtEpoch The epoch when the allocation was closed
+     * @param collectedFees The amount of collected fees for the allocation
+     * @param __DEPRECATED_effectiveAllocation Deprecated field
+     * @param accRewardsPerAllocatedToken Snapshot used for reward calculation
+     * @param distributedRebates The amount of collected rebates that have been rebated
+     */
+    struct LegacyAllocation {
+        address indexer;
+        bytes32 subgraphDeploymentID;
+        uint256 tokens;
+        uint256 createdAtEpoch;
+        uint256 closedAtEpoch;
+        uint256 collectedFees;
+        uint256 __DEPRECATED_effectiveAllocation;
+        uint256 accRewardsPerAllocatedToken;
+        uint256 distributedRebates;
+    }
+
+    /**
+     * @dev Possible states a legacy allocation can be.
+     * States:
+     * - Null = indexer == address(0)
+     * - Active = not Null && tokens > 0
+     * - Closed = Active && closedAtEpoch != 0
+     */
+    enum LegacyAllocationState {
+        Null,
+        Active,
+        Closed
+    }
 }
diff --git a/packages/interfaces/contracts/subgraph-service/IDisputeManager.sol b/packages/interfaces/contracts/subgraph-service/IDisputeManager.sol
index f0661c6f4..555874b44 100644
--- a/packages/interfaces/contracts/subgraph-service/IDisputeManager.sol
+++ b/packages/interfaces/contracts/subgraph-service/IDisputeManager.sol
@@ -3,6 +3,7 @@
 pragma solidity ^0.8.22;
 
 import { IAttestation } from "./internal/IAttestation.sol";
+import { IIndexingAgreement } from "./internal/IIndexingAgreement.sol";
 import { ISubgraphService } from "./ISubgraphService.sol";
 
 /**
@@ -18,7 +19,8 @@ interface IDisputeManager {
         Null,
         IndexingDispute,
         QueryDispute,
-        LegacyDispute
+        __DEPRECATED_LegacyDispute,
+        IndexingFeeDispute
     }
 
     /// @notice Status of a dispute
@@ -120,48 +122,55 @@ interface IDisputeManager {
     );
 
     /**
-     * @notice Emitted when an indexing dispute is created for `allocationId` and `indexer`
+     * @notice Emitted when an indexing fee dispute is created for `agreementId` and `indexer`
      * by `fisherman`.
-     * The event emits the amount of `tokens` deposited by the fisherman.
+     * @dev The event emits the amount of `tokens` deposited by the fisherman.
      * @param disputeId The dispute id
      * @param indexer The indexer address
      * @param fisherman The fisherman address
      * @param tokens The amount of tokens deposited by the fisherman
-     * @param allocationId The allocation id
-     * @param poi The POI
-     * @param blockNumber The block number for which the POI was calculated
+     * @param payer The address of the payer of the indexing fee
+     * @param agreementId The agreement id
+     * @param poi The POI disputed
+     * @param entities The entities disputed
      * @param stakeSnapshot The stake snapshot of the indexer at the time of the dispute
-     * @param cancellableAt The timestamp when the dispute can be cancelled
      */
-    event IndexingDisputeCreated(
+    event IndexingFeeDisputeCreated(
         bytes32 indexed disputeId,
         address indexed indexer,
         address indexed fisherman,
         uint256 tokens,
-        address allocationId,
+        address payer,
+        bytes16 agreementId,
         bytes32 poi,
-        uint256 blockNumber,
-        uint256 stakeSnapshot,
-        uint256 cancellableAt
+        uint256 entities,
+        uint256 stakeSnapshot
     );
 
     /**
-     * @notice Emitted when a legacy dispute is created for `allocationId` and `fisherman`.
-     * The event emits the amount of `tokensSlash` to slash and `tokensRewards` to reward the fisherman.
+     * @notice Emitted when an indexing dispute is created for `allocationId` and `indexer`
+     * by `fisherman`.
+     * The event emits the amount of `tokens` deposited by the fisherman.
      * @param disputeId The dispute id
      * @param indexer The indexer address
-     * @param fisherman The fisherman address to be credited with the rewards
+     * @param fisherman The fisherman address
+     * @param tokens The amount of tokens deposited by the fisherman
      * @param allocationId The allocation id
-     * @param tokensSlash The amount of tokens to slash
-     * @param tokensRewards The amount of tokens to reward the fisherman
+     * @param poi The POI
+     * @param blockNumber The block number for which the POI was calculated
+     * @param stakeSnapshot The stake snapshot of the indexer at the time of the dispute
+     * @param cancellableAt The timestamp when the dispute can be cancelled
      */
-    event LegacyDisputeCreated(
+    event IndexingDisputeCreated(
         bytes32 indexed disputeId,
         address indexed indexer,
         address indexed fisherman,
+        uint256 tokens,
         address allocationId,
-        uint256 tokensSlash,
-        uint256 tokensRewards
+        bytes32 poi,
+        uint256 blockNumber,
+        uint256 stakeSnapshot,
+        uint256 cancellableAt
     );
 
     /**
@@ -358,6 +367,18 @@ interface IDisputeManager {
      */
     error DisputeManagerSubgraphServiceNotSet();
 
+    /**
+     * @notice Thrown when the Indexing Agreement is not disputable
+     * @param agreementId The indexing agreement id
+     */
+    error DisputeManagerIndexingAgreementNotDisputable(bytes16 agreementId);
+
+    /**
+     * @notice Thrown when the Indexing Agreement is not disputable
+     * @param version The indexing agreement version
+     */
+    error DisputeManagerIndexingAgreementInvalidVersion(IIndexingAgreement.IndexingAgreementVersion version);
+
     /**
      * @notice Initialize this contract.
      * @param owner The owner of the contract
@@ -472,36 +493,26 @@ interface IDisputeManager {
     function createIndexingDispute(address allocationId, bytes32 poi, uint256 blockNumber) external returns (bytes32);
 
     /**
-     * @notice Creates and auto-accepts a legacy dispute.
-     * This disputes can be created to settle outstanding slashing amounts with an indexer that has been
-     * "legacy slashed" during or shortly after the transition period. See {HorizonStakingExtension.legacySlash}
-     * for more details.
-     *
-     * Note that this type of dispute:
-     * - can only be created by the arbitrator
-     * - does not require a bond
-     * - is automatically accepted when created
-     *
-     * Additionally, note that this type of disputes allow the arbitrator to directly set the slash and rewards
-     * amounts, bypassing the usual mechanisms that impose restrictions on those. This is done to give arbitrators
-     * maximum flexibility to ensure outstanding slashing amounts are settled fairly. This function needs to be removed
-     * after the transition period.
+     * @notice Create an indexing fee (version 1) dispute for the arbitrator to resolve.
+     * The disputes are created in reference to a version 1 indexing agreement and specifically
+     * a POI and entities provided when collecting that agreement.
+     * This function is called by a fisherman and it will pull `disputeDeposit` GRT tokens.
      *
      * Requirements:
-     * - Indexer must have been legacy slashed during or shortly after the transition period
-     * - Indexer must have provisioned funds to the Subgraph Service
+     * - fisherman must have previously approved this contract to pull `disputeDeposit` amount
+     *   of tokens from their balance.
      *
-     * @param allocationId The allocation to dispute
-     * @param fisherman The fisherman address to be credited with the rewards
-     * @param tokensSlash The amount of tokens to slash
-     * @param tokensRewards The amount of tokens to reward the fisherman
+     * @param agreementId The indexing agreement to dispute
+     * @param poi The Proof of Indexing (POI) being disputed
+     * @param entities The number of entities disputed
+     * @param blockNumber The block number at which the indexing fee was collected
      * @return The dispute id
      */
-    function createAndAcceptLegacyDispute(
-        address allocationId,
-        address fisherman,
-        uint256 tokensSlash,
-        uint256 tokensRewards
+    function createIndexingFeeDisputeV1(
+        bytes16 agreementId,
+        bytes32 poi,
+        uint256 entities,
+        uint256 blockNumber
     ) external returns (bytes32);
 
     // -- Arbitrator --
diff --git a/packages/interfaces/contracts/subgraph-service/ISubgraphService.sol b/packages/interfaces/contracts/subgraph-service/ISubgraphService.sol
index db0bdae3f..f169dce42 100644
--- a/packages/interfaces/contracts/subgraph-service/ISubgraphService.sol
+++ b/packages/interfaces/contracts/subgraph-service/ISubgraphService.sol
@@ -3,8 +3,10 @@ pragma solidity ^0.8.22;
 
 import { IDataServiceFees } from "../data-service/IDataServiceFees.sol";
 import { IGraphPayments } from "../horizon/IGraphPayments.sol";
+import { IRecurringCollector } from "../horizon/IRecurringCollector.sol";
 
 import { IAllocation } from "./internal/IAllocation.sol";
+import { IIndexingAgreement } from "./internal/IIndexingAgreement.sol";
 import { ILegacyAllocation } from "./internal/ILegacyAllocation.sol";
 
 /**
@@ -68,12 +70,25 @@ interface ISubgraphService is IDataServiceFees {
     event CurationCutSet(uint256 curationCut);
     // solhint-disable-previous-line gas-indexed-events
 
+    /**
+     * @notice Emitted when indexing fees cut is set
+     * @param indexingFeesCut The indexing fees cut
+     */
+    event IndexingFeesCutSet(uint256 indexingFeesCut);
+    // solhint-disable-previous-line gas-indexed-events
+
     /**
      * @notice Thrown when trying to set a curation cut that is not a valid PPM value
      * @param curationCut The curation cut value
      */
     error SubgraphServiceInvalidCurationCut(uint256 curationCut);
 
+    /**
+     * @notice Thrown when trying to set an indexing fees cut that is not a valid PPM value
+     * @param indexingFeesCut The indexing fees cut value
+     */
+    error SubgraphServiceInvalidIndexingFeesCut(uint256 indexingFeesCut);
+
     /**
      * @notice Thrown when an indexer tries to register with an empty URL
      */
@@ -104,7 +119,7 @@ interface ISubgraphService is IDataServiceFees {
     error SubgraphServiceInconsistentCollection(uint256 balanceBefore, uint256 balanceAfter);
 
     /**
-     * @notice @notice Thrown when the service provider in the RAV does not match the expected indexer.
+     * @notice @notice Thrown when the service provider does not match the expected indexer.
      * @param providedIndexer The address of the provided indexer.
      * @param expectedIndexer The address of the expected indexer.
      */
@@ -197,16 +212,6 @@ interface ISubgraphService is IDataServiceFees {
      */
     function resizeAllocation(address indexer, address allocationId, uint256 tokens) external;
 
-    /**
-     * @notice Imports a legacy allocation id into the subgraph service
-     * This is a governor only action that is required to prevent indexers from re-using allocation ids from the
-     * legacy staking contract.
-     * @param indexer The address of the indexer
-     * @param allocationId The id of the allocation
-     * @param subgraphDeploymentId The id of the subgraph deployment
-     */
-    function migrateLegacyAllocation(address indexer, address allocationId, bytes32 subgraphDeploymentId) external;
-
     /**
      * @notice Sets a pause guardian
      * @param pauseGuardian The address of the pause guardian
@@ -246,6 +251,13 @@ interface ISubgraphService is IDataServiceFees {
      */
     function setCurationCut(uint256 curationCut) external;
 
+    /**
+     * @notice Sets the data service payment cut for indexing fees
+     * @dev Emits a {IndexingFeesCutSet} event
+     * @param indexingFeesCut The indexing fees cut for the payment type
+     */
+    function setIndexingFeesCut(uint256 indexingFeesCut) external;
+
     /**
      * @notice Sets the payments destination for an indexer to receive payments
      * @dev Emits a {PaymentsDestinationSet} event
@@ -253,6 +265,46 @@ interface ISubgraphService is IDataServiceFees {
      */
     function setPaymentsDestination(address newPaymentsDestination) external;
 
+    /**
+     * @notice Accept an indexing agreement.
+     * @param allocationId The id of the allocation
+     * @param signedRCA The signed recurring collector agreement (RCA) that the indexer accepts
+     * @return agreementId The ID of the accepted indexing agreement
+     */
+    function acceptIndexingAgreement(
+        address allocationId,
+        IRecurringCollector.SignedRCA calldata signedRCA
+    ) external returns (bytes16);
+
+    /**
+     * @notice Update an indexing agreement.
+     * @param indexer The address of the indexer
+     * @param signedRCAU The signed recurring collector agreement update (RCAU) that the indexer accepts
+     */
+    function updateIndexingAgreement(address indexer, IRecurringCollector.SignedRCAU calldata signedRCAU) external;
+
+    /**
+     * @notice Cancel an indexing agreement by indexer / operator.
+     * @param indexer The address of the indexer
+     * @param agreementId The id of the indexing agreement
+     */
+    function cancelIndexingAgreement(address indexer, bytes16 agreementId) external;
+
+    /**
+     * @notice Cancel an indexing agreement by payer / signer.
+     * @param agreementId The id of the indexing agreement
+     */
+    function cancelIndexingAgreementByPayer(bytes16 agreementId) external;
+
+    /**
+     * @notice Get the indexing agreement for a given agreement ID.
+     * @param agreementId The id of the indexing agreement
+     * @return The indexing agreement details
+     */
+    function getIndexingAgreement(
+        bytes16 agreementId
+    ) external view returns (IIndexingAgreement.AgreementWrapper memory);
+
     /**
      * @notice Gets the details of an allocation
      * For legacy allocations use {getLegacyAllocation}
diff --git a/packages/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol b/packages/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol
index 5c04767c9..3454e7b8f 100644
--- a/packages/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol
+++ b/packages/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol
@@ -83,18 +83,6 @@ interface IAllocationManager {
         bool forceClosed
     );
 
-    /**
-     * @notice Emitted when a legacy allocation is migrated into the subgraph service
-     * @param indexer The address of the indexer
-     * @param allocationId The id of the allocation
-     * @param subgraphDeploymentId The id of the subgraph deployment
-     */
-    event LegacyAllocationMigrated(
-        address indexed indexer,
-        address indexed allocationId,
-        bytes32 indexed subgraphDeploymentId
-    );
-
     /**
      * @notice Emitted when the maximum POI staleness is updated
      * @param maxPOIStaleness The max POI staleness in seconds
diff --git a/packages/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol b/packages/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol
new file mode 100644
index 000000000..1f5c5f475
--- /dev/null
+++ b/packages/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity ^0.8.22;
+
+import { IRecurringCollector } from "../../horizon/IRecurringCollector.sol";
+
+/**
+ * @title Interface for the {IndexingAgreement} library contract.
+ * @author Edge & Node
+ * @notice Interface for managing indexing agreement data and operations
+ * @custom:security-contact Please email security+contracts@thegraph.com if you find any
+ * bugs. We may have an active bug bounty program.
+ */
+interface IIndexingAgreement {
+    /// @notice Versions of Indexing Agreement Metadata
+    enum IndexingAgreementVersion {
+        V1
+    }
+
+    /**
+     * @notice Indexer Agreement Data
+     * @param allocationId The allocation ID
+     * @param version The indexing agreement version
+     */
+    struct State {
+        address allocationId;
+        IndexingAgreementVersion version;
+    }
+
+    /**
+     * @notice Wrapper for Indexing Agreement and Collector Agreement Data
+     * @param agreement The indexing agreement state
+     * @param collectorAgreement The collector agreement data
+     */
+    struct AgreementWrapper {
+        State agreement;
+        IRecurringCollector.AgreementData collectorAgreement;
+    }
+}
diff --git a/packages/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol b/packages/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol
index c5bf7f8c7..b6422fad8 100644
--- a/packages/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol
+++ b/packages/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol
@@ -23,14 +23,8 @@ interface ILegacyAllocation {
     }
 
     /**
-     * @notice Thrown when attempting to migrate an allocation with an existing id
+     * @notice Thrown when attempting to create an allocation with an existing legacy id
      * @param allocationId The allocation id
      */
     error LegacyAllocationAlreadyExists(address allocationId);
-
-    /**
-     * @notice Thrown when trying to get a non-existent allocation
-     * @param allocationId The allocation id
-     */
-    error LegacyAllocationDoesNotExist(address allocationId);
 }
diff --git a/packages/interfaces/hardhat.config.ts b/packages/interfaces/hardhat.config.ts
index 42001f299..f2b7c6803 100644
--- a/packages/interfaces/hardhat.config.ts
+++ b/packages/interfaces/hardhat.config.ts
@@ -3,7 +3,7 @@ import 'hardhat-ignore-warnings'
 
 const config = {
   solidity: {
-    compilers: [{ version: '0.8.27' }, { version: '0.7.6' }],
+    compilers: [{ version: '0.8.27' }, { version: '0.8.33' }, { version: '0.7.6' }],
   },
   typechain: {
     outDir: 'types',
diff --git a/packages/issuance/package.json b/packages/issuance/package.json
index bed1c008a..8eca0250c 100644
--- a/packages/issuance/package.json
+++ b/packages/issuance/package.json
@@ -32,7 +32,7 @@
     "lint": "pnpm lint:ts; pnpm lint:sol; pnpm lint:forge; pnpm lint:md; pnpm lint:json",
     "lint:ts": "eslint '**/*.{js,ts,cjs,mjs,jsx,tsx}' --fix --cache; prettier -w --cache --log-level warn '**/*.{js,ts,cjs,mjs,jsx,tsx}'",
     "lint:sol": "solhint --fix --noPrompt --noPoster 'contracts/**/*.sol'; prettier -w --cache --log-level warn 'contracts/**/*.sol'",
-    "lint:forge": "forge lint",
+    "lint:forge": "forge lint contracts/",
     "lint:md": "markdownlint --fix --ignore-path ../../.gitignore '**/*.md'; prettier -w --cache --log-level warn '**/*.md'",
     "lint:json": "prettier -w --cache --log-level warn '**/*.json'",
     "verify": "hardhat verify",
diff --git a/packages/subgraph-service/contracts/DisputeManager.sol b/packages/subgraph-service/contracts/DisputeManager.sol
index 130182e4b..ebaff5292 100644
--- a/packages/subgraph-service/contracts/DisputeManager.sol
+++ b/packages/subgraph-service/contracts/DisputeManager.sol
@@ -11,10 +11,11 @@ import { IDisputeManager } from "@graphprotocol/interfaces/contracts/subgraph-se
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
 import { IAttestation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAttestation.sol";
 import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
 
 import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
 import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
-import { MathUtils } from "@graphprotocol/horizon/contracts/libraries/MathUtils.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
 import { Attestation } from "./libraries/Attestation.sol";
 
 import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
@@ -138,6 +139,20 @@ contract DisputeManager is
         return _createIndexingDisputeWithAllocation(msg.sender, disputeDeposit, allocationId, poi, blockNumber);
     }
 
+    /// @inheritdoc IDisputeManager
+    function createIndexingFeeDisputeV1(
+        bytes16 agreementId,
+        bytes32 poi,
+        uint256 entities,
+        uint256 blockNumber
+    ) external override returns (bytes32) {
+        // Get funds from fisherman
+        _graphToken().pullTokens(msg.sender, disputeDeposit);
+
+        // Create a dispute
+        return _createIndexingFeeDisputeV1(msg.sender, disputeDeposit, agreementId, poi, entities, blockNumber);
+    }
+
     /// @inheritdoc IDisputeManager
     function createQueryDispute(bytes calldata attestationData) external override returns (bytes32) {
         // Get funds from fisherman
@@ -205,46 +220,6 @@ contract DisputeManager is
         return (dId1, dId2);
     }
 
-    /// @inheritdoc IDisputeManager
-    function createAndAcceptLegacyDispute(
-        address allocationId,
-        address fisherman,
-        uint256 tokensSlash,
-        uint256 tokensRewards
-    ) external override onlyArbitrator returns (bytes32) {
-        // Create a disputeId
-        bytes32 disputeId = keccak256(abi.encodePacked(allocationId, "legacy"));
-
-        // Get the indexer for the legacy allocation
-        address indexer = _graphStaking().getAllocation(allocationId).indexer;
-        require(indexer != address(0), DisputeManagerIndexerNotFound(allocationId));
-
-        // Store dispute
-        disputes[disputeId] = Dispute(
-            indexer,
-            fisherman,
-            0,
-            0,
-            DisputeType.LegacyDispute,
-            IDisputeManager.DisputeStatus.Accepted,
-            block.timestamp,
-            block.timestamp + disputePeriod,
-            0
-        );
-
-        // Slash the indexer
-        ISubgraphService subgraphService_ = _getSubgraphService();
-        subgraphService_.slash(indexer, abi.encode(tokensSlash, tokensRewards));
-
-        // Reward the fisherman
-        _graphToken().pushTokens(fisherman, tokensRewards);
-
-        emit LegacyDisputeCreated(disputeId, indexer, fisherman, allocationId, tokensSlash, tokensRewards);
-        emit DisputeAccepted(disputeId, indexer, fisherman, tokensRewards);
-
-        return disputeId;
-    }
-
     /// @inheritdoc IDisputeManager
     function acceptDispute(
         bytes32 disputeId,
@@ -507,6 +482,75 @@ contract DisputeManager is
         return disputeId;
     }
 
+    /**
+     * @notice Create indexing fee (version 1) dispute internal function.
+     * @param _fisherman The fisherman creating the dispute
+     * @param _deposit Amount of tokens staked as deposit
+     * @param _agreementId The agreement id being disputed
+     * @param _poi The POI being disputed
+     * @param _entities The number of entities disputed
+     * @param _blockNumber The block number of the disputed POI
+     * @return The dispute id
+     */
+    function _createIndexingFeeDisputeV1(
+        address _fisherman,
+        uint256 _deposit,
+        bytes16 _agreementId,
+        bytes32 _poi,
+        uint256 _entities,
+        uint256 _blockNumber
+    ) private returns (bytes32) {
+        IIndexingAgreement.AgreementWrapper memory wrapper = _getSubgraphService().getIndexingAgreement(_agreementId);
+
+        // Agreement must have been collected on and be a version 1
+        require(
+            wrapper.collectorAgreement.lastCollectionAt > 0,
+            DisputeManagerIndexingAgreementNotDisputable(_agreementId)
+        );
+        require(
+            wrapper.agreement.version == IIndexingAgreement.IndexingAgreementVersion.V1,
+            DisputeManagerIndexingAgreementInvalidVersion(wrapper.agreement.version)
+        );
+
+        // Create a disputeId
+        bytes32 disputeId = keccak256(
+            abi.encodePacked("IndexingFeeDisputeWithAgreement", _agreementId, _poi, _entities, _blockNumber)
+        );
+
+        // Only one dispute at a time
+        require(!isDisputeCreated(disputeId), DisputeManagerDisputeAlreadyCreated(disputeId));
+
+        // The indexer must be disputable
+        uint256 stakeSnapshot = _getStakeSnapshot(wrapper.collectorAgreement.serviceProvider);
+        require(stakeSnapshot != 0, DisputeManagerZeroTokens());
+
+        disputes[disputeId] = Dispute(
+            wrapper.collectorAgreement.serviceProvider,
+            _fisherman,
+            _deposit,
+            0, // no related dispute,
+            DisputeType.IndexingFeeDispute,
+            IDisputeManager.DisputeStatus.Pending,
+            block.timestamp,
+            block.timestamp + disputePeriod,
+            stakeSnapshot
+        );
+
+        emit IndexingFeeDisputeCreated(
+            disputeId,
+            wrapper.collectorAgreement.serviceProvider,
+            _fisherman,
+            _deposit,
+            wrapper.collectorAgreement.payer,
+            _agreementId,
+            _poi,
+            _entities,
+            stakeSnapshot
+        );
+
+        return disputeId;
+    }
+
     /**
      * @notice Accept a dispute
      * @param _disputeId The id of the dispute
@@ -588,8 +632,8 @@ contract DisputeManager is
         // - The applied cut is the minimum between the provision's maxVerifierCut and the current fishermanRewardCut. This
         //   protects the indexer from sudden changes to the fishermanRewardCut while ensuring the slashing does not revert due
         //   to excessive rewards being requested.
-        uint256 maxRewardableTokens = MathUtils.min(_tokensSlash, provision.tokens);
-        uint256 effectiveCut = MathUtils.min(provision.maxVerifierCut, fishermanRewardCut);
+        uint256 maxRewardableTokens = Math.min(_tokensSlash, provision.tokens);
+        uint256 effectiveCut = Math.min(provision.maxVerifierCut, fishermanRewardCut);
         uint256 tokensRewards = effectiveCut.mulPPM(maxRewardableTokens);
 
         subgraphService_.slash(_indexer, abi.encode(_tokensSlash, tokensRewards));
diff --git a/packages/subgraph-service/contracts/SubgraphService.sol b/packages/subgraph-service/contracts/SubgraphService.sol
index 2eb8e0a9f..4626c4a05 100644
--- a/packages/subgraph-service/contracts/SubgraphService.sol
+++ b/packages/subgraph-service/contracts/SubgraphService.sol
@@ -8,7 +8,9 @@ import { IRewardsIssuer } from "@graphprotocol/interfaces/contracts/contracts/re
 import { IDataService } from "@graphprotocol/interfaces/contracts/data-service/IDataService.sol";
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
 import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
 import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
 
 import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import { MulticallUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol";
@@ -23,6 +25,8 @@ import { SubgraphServiceV1Storage } from "./SubgraphServiceStorage.sol";
 import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
 import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
 import { Allocation } from "./libraries/Allocation.sol";
+import { IndexingAgreementDecoder } from "./libraries/IndexingAgreementDecoder.sol";
+import { IndexingAgreement } from "./libraries/IndexingAgreement.sol";
 
 /**
  * @title SubgraphService contract
@@ -48,6 +52,7 @@ contract SubgraphService is
     using Allocation for mapping(address => IAllocation.State);
     using Allocation for IAllocation.State;
     using TokenUtils for IGraphToken;
+    using IndexingAgreement for IndexingAgreement.StorageManager;
 
     /**
      * @notice Checks that an indexer is registered
@@ -65,13 +70,18 @@ contract SubgraphService is
      * @param disputeManager The address of the DisputeManager contract
      * @param graphTallyCollector The address of the GraphTallyCollector contract
      * @param curation The address of the Curation contract
+     * @param recurringCollector The address of the RecurringCollector contract
      */
     constructor(
         address graphController,
         address disputeManager,
         address graphTallyCollector,
-        address curation
-    ) DataService(graphController) Directory(address(this), disputeManager, graphTallyCollector, curation) {
+        address curation,
+        address recurringCollector
+    )
+        DataService(graphController)
+        Directory(address(this), disputeManager, graphTallyCollector, curation, recurringCollector)
+    {
         _disableInitializers();
     }
 
@@ -225,13 +235,14 @@ contract SubgraphService is
             _allocations.get(allocationId).indexer == indexer,
             SubgraphServiceAllocationNotAuthorized(indexer, allocationId)
         );
+        _onCloseAllocation(allocationId, false);
         _closeAllocation(allocationId, false);
         emit ServiceStopped(indexer, data);
     }
 
     /**
      * @notice Collects payment for the service provided by the indexer
-     * Allows collecting different types of payments such as query fees and indexing rewards.
+     * Allows collecting different types of payments such as query fees, indexing rewards and indexing fees.
      * It uses Graph Horizon payments protocol to process payments.
      * Reverts if the payment type is not supported.
      * @dev This function is the equivalent of the `collect` function for query fees and the `closeAllocation` function
@@ -245,6 +256,12 @@ contract SubgraphService is
      *
      * For query fees, see {SubgraphService-_collectQueryFees} for more details.
      * For indexing rewards, see {AllocationManager-_collectIndexingRewards} for more details.
+     * For indexing fees, see {SubgraphService-_collectIndexingFees} for more details.
+     *
+     * Note that collecting any type of payment will require locking provisioned stake as collateral for a period of time.
+     * All types of payment share the same pool of provisioned stake however they each have separate accounting:
+     * - Indexing rewards can make full use of the available stake
+     * - Query and indexing fees share the pool, combined they can also make full use of the available stake
      *
      * @param indexer The address of the indexer
      * @param paymentType The type of payment to collect as defined in {IGraphPayments}
@@ -255,6 +272,9 @@ contract SubgraphService is
      *      - address `allocationId`: The id of the allocation
      *      - bytes32 `poi`: The POI being presented
      *      - bytes `poiMetadata`: The metadata associated with the POI. See {AllocationManager-_collectIndexingRewards} for more details.
+     *    - For indexing fees:
+     *      - bytes16 `agreementId`: The id of the indexing agreement
+     *      - bytes `agreementCollectionMetadata`: The metadata required by the indexing agreement version.
      */
     /// @inheritdoc IDataService
     function collect(
@@ -264,10 +284,10 @@ contract SubgraphService is
     )
         external
         override
+        whenNotPaused
         onlyAuthorizedForProvision(indexer)
         onlyValidProvision(indexer)
         onlyRegisteredIndexer(indexer)
-        whenNotPaused
         returns (uint256)
     {
         uint256 paymentCollected = 0;
@@ -276,6 +296,14 @@ contract SubgraphService is
             paymentCollected = _collectQueryFees(indexer, data);
         } else if (paymentType == IGraphPayments.PaymentTypes.IndexingRewards) {
             paymentCollected = _collectIndexingRewards(indexer, data);
+        } else if (paymentType == IGraphPayments.PaymentTypes.IndexingFee) {
+            (bytes16 agreementId, bytes memory iaCollectionData) = IndexingAgreementDecoder.decodeCollectData(data);
+            paymentCollected = _collectIndexingFees(
+                indexer,
+                agreementId,
+                paymentsDestination[indexer],
+                iaCollectionData
+            );
         } else {
             revert SubgraphServiceInvalidPaymentType(paymentType);
         }
@@ -301,6 +329,7 @@ contract SubgraphService is
         IAllocation.State memory allocation = _allocations.get(allocationId);
         require(allocation.isStale(maxPOIStaleness), SubgraphServiceCannotForceCloseAllocation(allocationId));
         require(!allocation.isAltruistic(), SubgraphServiceAllocationIsAltruistic(allocationId));
+        _onCloseAllocation(allocationId, true);
         _closeAllocation(allocationId, true);
     }
 
@@ -323,15 +352,6 @@ contract SubgraphService is
         _resizeAllocation(allocationId, tokens, _delegationRatio);
     }
 
-    /// @inheritdoc ISubgraphService
-    function migrateLegacyAllocation(
-        address indexer,
-        address allocationId,
-        bytes32 subgraphDeploymentId
-    ) external override onlyOwner {
-        _migrateLegacyAllocation(indexer, allocationId, subgraphDeploymentId);
-    }
-
     /// @inheritdoc ISubgraphService
     function setPauseGuardian(address pauseGuardian, bool allowed) external override onlyOwner {
         _setPauseGuardian(pauseGuardian, allowed);
@@ -357,7 +377,6 @@ contract SubgraphService is
         _setStakeToFeesRatio(stakeToFeesRatio_);
     }
 
-    // forge-lint: disable-next-item(mixed-case-function)
     /// @inheritdoc ISubgraphService
     function setMaxPOIStaleness(uint256 maxPoiStaleness_) external override onlyOwner {
         _setMaxPoiStaleness(maxPoiStaleness_);
@@ -370,6 +389,130 @@ contract SubgraphService is
         emit CurationCutSet(curationCut);
     }
 
+    /// @inheritdoc ISubgraphService
+    function setIndexingFeesCut(uint256 indexingFeesCut_) external override onlyOwner {
+        require(PPMMath.isValidPPM(indexingFeesCut_), SubgraphServiceInvalidIndexingFeesCut(indexingFeesCut_));
+        indexingFeesCut = indexingFeesCut_;
+        emit IndexingFeesCutSet(indexingFeesCut_);
+    }
+
+    /**
+     * @inheritdoc ISubgraphService
+     * @notice Accept an indexing agreement.
+     *
+     * See {ISubgraphService.acceptIndexingAgreement}.
+     *
+     * Requirements:
+     * - The agreement's indexer must be registered
+     * - The caller must be authorized by the agreement's indexer
+     * - The provision must be valid according to the subgraph service rules
+     * - Allocation must belong to the indexer and be open
+     * - Agreement must be for this data service
+     * - Agreement's subgraph deployment must match the allocation's subgraph deployment
+     * - Agreement must not have been accepted before
+     * - Allocation must not have an agreement already
+     *
+     * @dev signedRCA.rca.metadata is an encoding of {IndexingAgreement.AcceptIndexingAgreementMetadata}
+     *
+     * Emits {IndexingAgreement.IndexingAgreementAccepted} event
+     *
+     * @param allocationId The id of the allocation
+     * @param signedRCA The signed Recurring Collection Agreement
+     * @return agreementId The ID of the accepted indexing agreement
+     */
+    function acceptIndexingAgreement(
+        address allocationId,
+        IRecurringCollector.SignedRCA calldata signedRCA
+    )
+        external
+        whenNotPaused
+        onlyAuthorizedForProvision(signedRCA.rca.serviceProvider)
+        onlyValidProvision(signedRCA.rca.serviceProvider)
+        onlyRegisteredIndexer(signedRCA.rca.serviceProvider)
+        returns (bytes16)
+    {
+        return IndexingAgreement._getStorageManager().accept(_allocations, allocationId, signedRCA);
+    }
+
+    /**
+     * @inheritdoc ISubgraphService
+     * @notice Update an indexing agreement.
+     *
+     * See {IndexingAgreement.update}.
+     *
+     * Requirements:
+     * - The contract must not be paused
+     * - The indexer must be valid
+     *
+     * @param indexer The indexer address
+     * @param signedRCAU The signed Recurring Collection Agreement Update
+     */
+    function updateIndexingAgreement(
+        address indexer,
+        IRecurringCollector.SignedRCAU calldata signedRCAU
+    )
+        external
+        whenNotPaused
+        onlyAuthorizedForProvision(indexer)
+        onlyValidProvision(indexer)
+        onlyRegisteredIndexer(indexer)
+    {
+        IndexingAgreement._getStorageManager().update(indexer, signedRCAU);
+    }
+
+    /**
+     * @inheritdoc ISubgraphService
+     * @notice Cancel an indexing agreement by indexer / operator.
+     *
+     * See {IndexingAgreement.cancel}.
+     *
+     * @dev Can only be canceled on behalf of a valid indexer.
+     *
+     * Requirements:
+     * - The contract must not be paused
+     * - The indexer must be valid
+     *
+     * @param indexer The indexer address
+     * @param agreementId The id of the agreement
+     */
+    function cancelIndexingAgreement(
+        address indexer,
+        bytes16 agreementId
+    )
+        external
+        whenNotPaused
+        onlyAuthorizedForProvision(indexer)
+        onlyValidProvision(indexer)
+        onlyRegisteredIndexer(indexer)
+    {
+        IndexingAgreement._getStorageManager().cancel(indexer, agreementId);
+    }
+
+    /**
+     * @inheritdoc ISubgraphService
+     * @notice Cancel an indexing agreement by payer / signer.
+     *
+     * See {ISubgraphService.cancelIndexingAgreementByPayer}.
+     *
+     * Requirements:
+     * - The caller must be authorized by the payer
+     * - The agreement must be active
+     *
+     * Emits {IndexingAgreementCanceled} event
+     *
+     * @param agreementId The id of the agreement
+     */
+    function cancelIndexingAgreementByPayer(bytes16 agreementId) external whenNotPaused {
+        IndexingAgreement._getStorageManager().cancelByPayer(agreementId);
+    }
+
+    /// @inheritdoc ISubgraphService
+    function getIndexingAgreement(
+        bytes16 agreementId
+    ) external view returns (IIndexingAgreement.AgreementWrapper memory) {
+        return IndexingAgreement._getStorageManager().get(agreementId);
+    }
+
     /// @inheritdoc ISubgraphService
     function getAllocation(address allocationId) external view override returns (IAllocation.State memory) {
         return _allocations[allocationId];
@@ -425,6 +568,16 @@ contract SubgraphService is
         return _isOverAllocated(indexer, _delegationRatio);
     }
 
+    /**
+     * @notice Internal function to handle closing an allocation
+     * @dev This function is called when an allocation is closed, either by the indexer or by a third party
+     * @param _allocationId The id of the allocation being closed
+     * @param _forceClosed Whether the allocation was force closed
+     */
+    function _onCloseAllocation(address _allocationId, bool _forceClosed) internal {
+        IndexingAgreement._getStorageManager().onCloseAllocation(_allocationId, _forceClosed);
+    }
+
     /**
      * @notice Sets the payments destination for an indexer to receive payments
      * @dev Emits a {PaymentsDestinationSet} event
@@ -585,7 +738,77 @@ contract SubgraphService is
             _allocations.get(allocationId).indexer == _indexer,
             SubgraphServiceAllocationNotAuthorized(_indexer, allocationId)
         );
-        return _presentPoi(allocationId, poi_, poiMetadata_, _delegationRatio, paymentsDestination[_indexer]);
+
+        (uint256 paymentCollected, bool allocationForceClosed) = _presentPoi(
+            allocationId,
+            poi_,
+            poiMetadata_,
+            _delegationRatio,
+            paymentsDestination[_indexer]
+        );
+
+        if (allocationForceClosed) {
+            _onCloseAllocation(allocationId, true);
+        }
+
+        return paymentCollected;
+    }
+
+    /**
+     * @notice Collect Indexing fees
+     * Stake equal to the amount being collected times the `stakeToFeesRatio` is locked into a stake claim.
+     * This claim can be released at a later stage once expired.
+     *
+     * It's important to note that before collecting this function will attempt to release any expired stake claims.
+     * This could lead to an out of gas error if there are too many expired claims. In that case, the indexer will need to
+     * manually release the claims, see {IDataServiceFees-releaseStake}, before attempting to collect again.
+     *
+     * @dev Uses the {RecurringCollector} to collect payment from Graph Horizon payments protocol.
+     * Fees are distributed to service provider and delegators by {GraphPayments}
+     *
+     * Requirements:
+     * - Indexer must have enough available tokens to lock as economic security for fees
+     * - Allocation must be open
+     *
+     * Emits a {StakeClaimsReleased} event, and a {StakeClaimReleased} event for each claim released.
+     * Emits a {StakeClaimLocked} event.
+     * Emits a {IndexingFeesCollectedV1} event.
+     *
+     * @param _indexer The address of the indexer
+     * @param _agreementId The id of the indexing agreement
+     * @param _paymentsDestination The address where the fees should be sent
+     * @param _data The indexing agreement collection data
+     * @return The amount of fees collected
+     */
+    function _collectIndexingFees(
+        address _indexer,
+        bytes16 _agreementId,
+        address _paymentsDestination,
+        bytes memory _data
+    ) private returns (uint256) {
+        (address indexer, uint256 tokensCollected) = IndexingAgreement._getStorageManager().collect(
+            _allocations,
+            IndexingAgreement.CollectParams({
+                indexer: _indexer,
+                agreementId: _agreementId,
+                currentEpoch: _graphEpochManager().currentEpoch(),
+                receiverDestination: _paymentsDestination,
+                data: _data,
+                indexingFeesCut: indexingFeesCut
+            })
+        );
+
+        _releaseStake(indexer, 0);
+        if (tokensCollected > 0) {
+            // lock stake as economic security for fees
+            _lockStake(
+                indexer,
+                tokensCollected * stakeToFeesRatio,
+                block.timestamp + _disputeManager().getDisputePeriod()
+            );
+        }
+
+        return tokensCollected;
     }
 
     /**
diff --git a/packages/subgraph-service/contracts/SubgraphServiceStorage.sol b/packages/subgraph-service/contracts/SubgraphServiceStorage.sol
index 67accbb5a..c1e1dbc6c 100644
--- a/packages/subgraph-service/contracts/SubgraphServiceStorage.sol
+++ b/packages/subgraph-service/contracts/SubgraphServiceStorage.sol
@@ -22,4 +22,7 @@ abstract contract SubgraphServiceV1Storage is ISubgraphService {
 
     /// @notice Destination of indexer payments
     mapping(address indexer => address destination) public override paymentsDestination;
+
+    /// @notice The cut data service takes from indexing fee payments. In PPM.
+    uint256 public indexingFeesCut;
 }
diff --git a/packages/subgraph-service/contracts/libraries/AllocationHandler.sol b/packages/subgraph-service/contracts/libraries/AllocationHandler.sol
new file mode 100644
index 000000000..d45db0ae6
--- /dev/null
+++ b/packages/subgraph-service/contracts/libraries/AllocationHandler.sol
@@ -0,0 +1,692 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.33;
+
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { IEpochManager } from "@graphprotocol/interfaces/contracts/contracts/epochs/IEpochManager.sol";
+import { IGraphToken } from "@graphprotocol/interfaces/contracts/contracts/token/IGraphToken.sol";
+import { IRewardsManager } from "@graphprotocol/interfaces/contracts/contracts/rewards/IRewardsManager.sol";
+import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
+import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
+import { IHorizonStaking } from "@graphprotocol/interfaces/contracts/horizon/IHorizonStaking.sol";
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
+import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
+import { RewardsCondition } from "@graphprotocol/interfaces/contracts/contracts/rewards/RewardsCondition.sol";
+import { ProvisionTracker } from "@graphprotocol/horizon/contracts/data-service/libraries/ProvisionTracker.sol";
+import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
+
+import { Allocation } from "../libraries/Allocation.sol";
+import { LegacyAllocation } from "../libraries/LegacyAllocation.sol";
+
+/**
+ * @title AllocationHandler contract
+ * @author Edge & Node
+ * @notice A helper contract implementing allocation lifecycle management.
+ * Allows opening, resizing, and closing allocations, as well as collecting indexing rewards by presenting a Proof
+ * of Indexing (POI).
+ * @custom:security-contact Please email security+contracts@thegraph.com if you find any
+ * bugs. We may have an active bug bounty program.
+ */
+library AllocationHandler {
+    using ProvisionTracker for mapping(address => uint256);
+    using Allocation for mapping(address => IAllocation.State);
+    using Allocation for IAllocation.State;
+    using LegacyAllocation for mapping(address => ILegacyAllocation.State);
+    using PPMMath for uint256;
+    using TokenUtils for IGraphToken;
+
+    /**
+     * @notice Parameters for the allocation creation
+     * @param currentEpoch The current epoch at the time of allocation creation
+     * @param graphStaking The Horizon staking contract to handle token locking
+     * @param graphRewardsManager The rewards manager to handle rewards distribution
+     * @param _encodeAllocationProof The EIP712 encoded allocation proof
+     * @param _indexer The address of the indexer creating the allocation
+     * @param _delegationRatio The delegation ratio to consider when locking tokens
+     * @param _allocationId The id of the allocation to be created
+     * @param _subgraphDeploymentId The id of the subgraph deployment for which the allocation is created
+     * @param _tokens The amount of tokens to allocate
+     * @param _allocationProof The EIP712 proof, an EIP712 signed message of (indexer,allocationId)
+     */
+    struct AllocateParams {
+        uint256 currentEpoch;
+        IHorizonStaking graphStaking;
+        IRewardsManager graphRewardsManager;
+        bytes32 _encodeAllocationProof;
+        address _indexer;
+        uint32 _delegationRatio;
+        address _allocationId;
+        bytes32 _subgraphDeploymentId;
+        uint256 _tokens;
+        bytes _allocationProof;
+    }
+
+    /**
+     * @notice Parameters for the POI presentation
+     * @param maxPOIStaleness The maximum staleness of the POI in epochs
+     * @param graphEpochManager The epoch manager to get the current epoch
+     * @param graphStaking The Horizon staking contract to handle token locking
+     * @param graphRewardsManager The rewards manager to handle rewards distribution
+     * @param graphToken The Graph token contract to handle token transfers
+     * @param dataService The data service address (for delegation pool lookups)
+     * @param _allocationId The id of the allocation for which the POI is presented
+     * @param _poi The proof of indexing (POI) to be presented
+     * @param _poiMetadata The metadata associated with the POI
+     * @param _delegationRatio The delegation ratio to consider when locking tokens
+     * @param _paymentsDestination The address to which the indexing rewards should be sent
+     */
+    struct PresentParams {
+        uint256 maxPOIStaleness;
+        IEpochManager graphEpochManager;
+        IHorizonStaking graphStaking;
+        IRewardsManager graphRewardsManager;
+        IGraphToken graphToken;
+        address dataService;
+        address _allocationId;
+        bytes32 _poi;
+        bytes _poiMetadata;
+        uint32 _delegationRatio;
+        address _paymentsDestination;
+    }
+
+    /**
+     * @notice Emitted when an indexer creates an allocation
+     * @param indexer The address of the indexer
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param tokens The amount of tokens allocated
+     * @param currentEpoch The current epoch
+     */
+    event AllocationCreated(
+        address indexed indexer,
+        address indexed allocationId,
+        bytes32 indexed subgraphDeploymentId,
+        uint256 tokens,
+        uint256 currentEpoch
+    );
+
+    /**
+     * @notice Emitted when an indexer collects indexing rewards for an allocation
+     * @param indexer The address of the indexer
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param tokensRewards The amount of tokens collected
+     * @param tokensIndexerRewards The amount of tokens collected for the indexer
+     * @param tokensDelegationRewards The amount of tokens collected for delegators
+     * @param poi The POI presented
+     * @param poiMetadata The metadata associated with the POI
+     * @param currentEpoch The current epoch
+     */
+    event IndexingRewardsCollected(
+        address indexed indexer,
+        address indexed allocationId,
+        bytes32 indexed subgraphDeploymentId,
+        uint256 tokensRewards,
+        uint256 tokensIndexerRewards,
+        uint256 tokensDelegationRewards,
+        bytes32 poi,
+        bytes poiMetadata,
+        uint256 currentEpoch
+    );
+
+    /**
+     * @notice Emitted when an indexer resizes an allocation
+     * @param indexer The address of the indexer
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param newTokens The new amount of tokens allocated
+     * @param oldTokens The old amount of tokens allocated
+     */
+    event AllocationResized(
+        address indexed indexer,
+        address indexed allocationId,
+        bytes32 indexed subgraphDeploymentId,
+        uint256 newTokens,
+        uint256 oldTokens
+    );
+
+    /**
+     * @notice Emitted when an indexer closes an allocation
+     * @param indexer The address of the indexer
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param tokens The amount of tokens allocated
+     * @param forceClosed Whether the allocation was force closed
+     */
+    event AllocationClosed(
+        address indexed indexer,
+        address indexed allocationId,
+        bytes32 indexed subgraphDeploymentId,
+        uint256 tokens,
+        bool forceClosed
+    );
+
+    /**
+     * @notice Emitted when a legacy allocation is migrated into the subgraph service
+     * @param indexer The address of the indexer
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     */
+    event LegacyAllocationMigrated(
+        address indexed indexer,
+        address indexed allocationId,
+        bytes32 indexed subgraphDeploymentId
+    );
+
+    /**
+     * @notice Emitted when the maximum POI staleness is updated
+     * @param maxPOIStaleness The max POI staleness in seconds
+     */
+    event MaxPOIStalenessSet(uint256 maxPOIStaleness);
+    // solhint-disable-previous-line gas-indexed-events
+
+    /**
+     * @notice Emitted when an indexer presents a POI for an allocation
+     * @param indexer The address of the indexer
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param poi The POI presented
+     * @param poiMetadata The metadata associated with the POI
+     * @param condition The rewards condition determined for this POI
+     */
+    event POIPresented(
+        address indexed indexer,
+        address indexed allocationId,
+        bytes32 indexed subgraphDeploymentId,
+        bytes32 poi,
+        bytes poiMetadata,
+        bytes32 condition
+    );
+
+    /**
+     * @notice Thrown when an allocation proof is invalid
+     * Both `signer` and `allocationId` should match for a valid proof.
+     * @param signer The address that signed the proof
+     * @param allocationId The id of the allocation
+     */
+    error AllocationHandlerInvalidAllocationProof(address signer, address allocationId);
+
+    /**
+     * @notice Thrown when attempting to create an allocation with a zero allocation id
+     */
+    error AllocationHandlerInvalidZeroAllocationId();
+
+    /**
+     * @notice Thrown when attempting to collect indexing rewards on a closed allocation
+     * @param allocationId The id of the allocation
+     */
+    error AllocationHandlerAllocationClosed(address allocationId);
+
+    /**
+     * @notice Thrown when attempting to resize an allocation with the same size
+     * @param allocationId The id of the allocation
+     * @param tokens The amount of tokens
+     */
+    error AllocationHandlerAllocationSameSize(address allocationId, uint256 tokens);
+
+    /**
+     * @notice Create an allocation
+     * @dev The `_allocationProof` is a 65-bytes Ethereum signed message of `keccak256(indexerAddress,allocationId)`
+     *
+     * Requirements:
+     * - `_allocationId` must not be the zero address
+     *
+     * Emits a {AllocationCreated} event
+     *
+     * @param _allocations The mapping of allocation ids to allocation states
+     * @param _legacyAllocations The mapping of legacy allocation ids to legacy allocation states
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param _subgraphAllocatedTokens The mapping of subgraph deployment ids to their allocated tokens
+     * @param params The parameters for the allocation
+     */
+    function allocate(
+        mapping(address allocationId => IAllocation.State allocation) storage _allocations,
+        mapping(address allocationId => ILegacyAllocation.State allocation) storage _legacyAllocations,
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        mapping(bytes32 subgraphDeploymentId => uint256 tokens) storage _subgraphAllocatedTokens,
+        AllocateParams calldata params
+    ) external {
+        require(params._allocationId != address(0), AllocationHandler.AllocationHandlerInvalidZeroAllocationId());
+
+        _verifyAllocationProof(params._encodeAllocationProof, params._allocationId, params._allocationProof);
+
+        // Ensure allocation id is not reused
+        // need to check both subgraph service (on allocations.create()) and legacy allocations
+        _legacyAllocations.revertIfExists(params.graphStaking, params._allocationId);
+
+        IAllocation.State memory allocation = _allocations.create(
+            params._indexer,
+            params._allocationId,
+            params._subgraphDeploymentId,
+            params._tokens,
+            params.graphRewardsManager.onSubgraphAllocationUpdate(params._subgraphDeploymentId),
+            params.currentEpoch
+        );
+
+        // Check that the indexer has enough tokens available
+        // Note that the delegation ratio ensures overdelegation cannot be used
+        allocationProvisionTracker.lock(params.graphStaking, params._indexer, params._tokens, params._delegationRatio);
+
+        // Update total allocated tokens for the subgraph deployment
+        _subgraphAllocatedTokens[allocation.subgraphDeploymentId] =
+            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] + allocation.tokens;
+
+        emit AllocationHandler.AllocationCreated(
+            params._indexer,
+            params._allocationId,
+            params._subgraphDeploymentId,
+            allocation.tokens,
+            params.currentEpoch
+        );
+    }
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @notice Present a POI to collect indexing rewards for an allocation
+     * Mints indexing rewards using the {RewardsManager} and distributes them to the indexer and delegators.
+     *
+     * Requirements for indexing rewards:
+     * - POI must be non-zero
+     * - POI must not be stale (older than `maxPOIStaleness`)
+     * - Allocation must be open for at least one epoch (returns early with 0 if too young)
+     *
+     * ## Reward Paths
+     *
+     * Rewards follow one of three paths based on allocation and POI state:
+     *
+     * **CLAIMED** (normal path): Valid POI, not stale, allocation mature, subgraph not denied
+     * - Calls `takeRewards()` to mint tokens to this contract
+     * - Distributes to indexer (stake or payments destination) and delegators
+     * - Snapshots allocation to prevent double-counting
+     *
+     * **RECLAIMED** (redirect path): STALE_POI or ZERO_POI conditions
+     * - Calls `reclaimRewards()` to mint tokens to configured reclaim address
+     * - If no reclaim address configured, rewards are dropped (not minted)
+     * - Snapshots allocation to prevent double-counting
+     *
+     * **DEFERRED** (early return): ALLOCATION_TOO_YOUNG or SUBGRAPH_DENIED conditions
+     * - Returns 0 without calling take or reclaim
+     * - Does NOT snapshot allocation (preserves rewards for later collection)
+     * - Allows rewards to be claimed when condition clears
+     *
+     * Emits a {POIPresented} event.
+     * Emits a {IndexingRewardsCollected} event.
+     *
+     * @param _allocations The mapping of allocation ids to allocation states
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param _subgraphAllocatedTokens The mapping of subgraph deployment ids to their allocated tokens
+     * @param params The parameters for the POI presentation
+     * @return rewardsCollected The amount of tokens collected
+     * @return allocationForceClosed True if the allocation was automatically closed due to over-allocation, false otherwise
+     */
+    function presentPOI(
+        mapping(address allocationId => IAllocation.State allocation) storage _allocations,
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        mapping(bytes32 subgraphDeploymentId => uint256 tokens) storage _subgraphAllocatedTokens,
+        PresentParams calldata params
+    ) external returns (uint256 rewardsCollected, bool allocationForceClosed) {
+        IAllocation.State memory allocation = _allocations.get(params._allocationId);
+        require(allocation.isOpen(), AllocationHandler.AllocationHandlerAllocationClosed(params._allocationId));
+        _allocations.presentPOI(params._allocationId); // Always record POI presentation to prevent staleness
+
+        uint256 currentEpoch = params.graphEpochManager.currentEpoch();
+        // Scoped for stack management
+        {
+            // Determine rewards condition
+            bytes32 condition = RewardsCondition.NONE;
+            if (allocation.isStale(params.maxPOIStaleness)) condition = RewardsCondition.STALE_POI;
+            else if (params._poi == bytes32(0))
+                condition = RewardsCondition.ZERO_POI;
+                // solhint-disable-next-line gas-strict-inequalities
+            else if (currentEpoch <= allocation.createdAtEpoch) condition = RewardsCondition.ALLOCATION_TOO_YOUNG;
+            else if (params.graphRewardsManager.isDenied(allocation.subgraphDeploymentId))
+                condition = RewardsCondition.SUBGRAPH_DENIED;
+
+            emit AllocationHandler.POIPresented(
+                allocation.indexer,
+                params._allocationId,
+                allocation.subgraphDeploymentId,
+                params._poi,
+                params._poiMetadata,
+                condition
+            );
+
+            // Early return skips the overallocation check intentionally to avoid loss of uncollected rewards
+            if (condition == RewardsCondition.ALLOCATION_TOO_YOUNG || condition == RewardsCondition.SUBGRAPH_DENIED) {
+                // Keep reward and reclaim accumulation current even if rewards are not collected
+                params.graphRewardsManager.onSubgraphAllocationUpdate(allocation.subgraphDeploymentId);
+
+                return (0, false);
+            }
+
+            bool rewardsReclaimable = condition == RewardsCondition.STALE_POI || condition == RewardsCondition.ZERO_POI;
+            if (rewardsReclaimable) params.graphRewardsManager.reclaimRewards(condition, params._allocationId);
+            else rewardsCollected = params.graphRewardsManager.takeRewards(params._allocationId);
+        }
+
+        // Snapshot rewards to prevent accumulation for next POI, then clear pending
+        _allocations.snapshotRewards(
+            params._allocationId,
+            params.graphRewardsManager.onSubgraphAllocationUpdate(allocation.subgraphDeploymentId)
+        );
+        _allocations.clearPendingRewards(params._allocationId);
+
+        // Scoped for stack management
+        {
+            (uint256 tokensIndexerRewards, uint256 tokensDelegationRewards) = _distributeIndexingRewards(
+                allocation,
+                rewardsCollected,
+                params
+            );
+
+            emit AllocationHandler.IndexingRewardsCollected(
+                allocation.indexer,
+                params._allocationId,
+                allocation.subgraphDeploymentId,
+                rewardsCollected,
+                tokensIndexerRewards,
+                tokensDelegationRewards,
+                params._poi,
+                params._poiMetadata,
+                currentEpoch
+            );
+        }
+
+        // Check if the indexer is over-allocated and force close the allocation if necessary
+        if (
+            _isOverAllocated(
+                allocationProvisionTracker,
+                params.graphStaking,
+                allocation.indexer,
+                params._delegationRatio
+            )
+        ) {
+            allocationForceClosed = true;
+            _closeAllocation(
+                _allocations,
+                allocationProvisionTracker,
+                _subgraphAllocatedTokens,
+                params.graphRewardsManager,
+                params._allocationId,
+                true
+            );
+        }
+    }
+    /* solhint-enable function-max-lines */
+
+    /**
+     * @notice Close an allocation
+     * Does not require presenting a POI, use {_collectIndexingRewards} to present a POI and collect rewards
+     * @dev Note that allocations are long lived. All service payments, including indexing rewards, should be collected periodically
+     * without the need of closing the allocation. Allocations should only be closed when indexers want to reclaim the allocated
+     * tokens for other purposes.
+     *
+     * Emits a {AllocationClosed} event
+     *
+     * @param _allocations The mapping of allocation ids to allocation states
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param _subgraphAllocatedTokens The mapping of subgraph deployment ids to their allocated tokens
+     * @param graphRewardsManager The rewards manager to handle rewards distribution
+     * @param _allocationId The id of the allocation to be closed
+     * @param _forceClosed Whether the allocation was force closed
+     */
+    function closeAllocation(
+        mapping(address allocationId => IAllocation.State allocation) storage _allocations,
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        mapping(bytes32 subgraphDeploymentId => uint256 tokens) storage _subgraphAllocatedTokens,
+        IRewardsManager graphRewardsManager,
+        address _allocationId,
+        bool _forceClosed
+    ) external {
+        _closeAllocation(
+            _allocations,
+            allocationProvisionTracker,
+            _subgraphAllocatedTokens,
+            graphRewardsManager,
+            _allocationId,
+            _forceClosed
+        );
+    }
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @notice Resize an allocation
+     * @dev Will lock or release tokens in the provision tracker depending on the new allocation size.
+     * Rewards accrued but not issued before the resize will be accounted for as pending rewards,
+     * unless the allocation is stale, in which case pending rewards are reclaimed.
+     * These will be paid out when the indexer presents a POI.
+     *
+     * Requirements:
+     * - `_indexer` must be the owner of the allocation
+     * - Allocation must be open
+     * - `_tokens` must be different from the current allocation size
+     *
+     * Emits a {AllocationResized} event.
+     *
+     * @param _allocations The mapping of allocation ids to allocation states
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param _subgraphAllocatedTokens The mapping of subgraph deployment ids to their allocated tokens
+     * @param graphStaking The Horizon staking contract to handle token locking
+     * @param graphRewardsManager The rewards manager to handle rewards distribution
+     * @param _allocationId The id of the allocation to be resized
+     * @param _tokens The new amount of tokens to allocate
+     * @param _delegationRatio The delegation ratio to consider when locking tokens
+     * @param _maxPOIStaleness The maximum staleness of the POI in seconds
+     */
+    function resizeAllocation(
+        mapping(address allocationId => IAllocation.State allocation) storage _allocations,
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        mapping(bytes32 subgraphDeploymentId => uint256 tokens) storage _subgraphAllocatedTokens,
+        IHorizonStaking graphStaking,
+        IRewardsManager graphRewardsManager,
+        address _allocationId,
+        uint256 _tokens,
+        uint32 _delegationRatio,
+        uint256 _maxPOIStaleness
+    ) external {
+        IAllocation.State memory allocation = _allocations.get(_allocationId);
+        require(allocation.isOpen(), AllocationHandler.AllocationHandlerAllocationClosed(_allocationId));
+        require(
+            _tokens != allocation.tokens,
+            AllocationHandler.AllocationHandlerAllocationSameSize(_allocationId, _tokens)
+        );
+
+        // Update provision tracker
+        uint256 oldTokens = allocation.tokens;
+        if (_tokens > oldTokens) {
+            allocationProvisionTracker.lock(graphStaking, allocation.indexer, _tokens - oldTokens, _delegationRatio);
+        } else {
+            allocationProvisionTracker.release(allocation.indexer, oldTokens - _tokens);
+        }
+
+        // Calculate rewards that have been accrued since the last snapshot but not yet issued
+        uint256 accRewardsPerAllocatedToken = graphRewardsManager.onSubgraphAllocationUpdate(
+            allocation.subgraphDeploymentId
+        );
+        uint256 accRewardsPerAllocatedTokenPending = !allocation.isAltruistic()
+            ? accRewardsPerAllocatedToken - allocation.accRewardsPerAllocatedToken
+            : 0;
+
+        // Update the allocation
+        _allocations[_allocationId].tokens = _tokens;
+        _allocations[_allocationId].accRewardsPerAllocatedToken = accRewardsPerAllocatedToken;
+        _allocations[_allocationId].accRewardsPending += graphRewardsManager.calcRewards(
+            oldTokens,
+            accRewardsPerAllocatedTokenPending
+        );
+
+        // If allocation is stale, reclaim pending rewards defensively.
+        // Stale allocations are not performing, so rewards should not accumulate.
+        if (allocation.isStale(_maxPOIStaleness)) {
+            graphRewardsManager.reclaimRewards(RewardsCondition.STALE_POI, _allocationId);
+            _allocations.clearPendingRewards(_allocationId);
+        }
+
+        // Update total allocated tokens for the subgraph deployment
+        if (_tokens > oldTokens) {
+            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] += (_tokens - oldTokens);
+        } else {
+            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] -= (oldTokens - _tokens);
+        }
+
+        emit AllocationHandler.AllocationResized(
+            allocation.indexer,
+            _allocationId,
+            allocation.subgraphDeploymentId,
+            _tokens,
+            oldTokens
+        );
+    }
+    /* solhint-enable function-max-lines */
+
+    /**
+     * @notice Checks if an allocation is over-allocated
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param graphStaking The Horizon staking contract to check delegation ratios
+     * @param _indexer The address of the indexer
+     * @param _delegationRatio The delegation ratio to consider when locking tokens
+     * @return True if the allocation is over-allocated, false otherwise
+     */
+    function isOverAllocated(
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        IHorizonStaking graphStaking,
+        address _indexer,
+        uint32 _delegationRatio
+    ) external view returns (bool) {
+        return _isOverAllocated(allocationProvisionTracker, graphStaking, _indexer, _delegationRatio);
+    }
+
+    /**
+     * @notice Close an allocation (internal)
+     * @dev Reclaims uncollected rewards before closing.
+     *
+     * Emits a {AllocationClosed} event
+     *
+     * @param _allocations The mapping of allocation ids to allocation states
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param _subgraphAllocatedTokens The mapping of subgraph deployment ids to their allocated tokens
+     * @param graphRewardsManager The rewards manager to handle rewards distribution
+     * @param _allocationId The id of the allocation to be closed
+     * @param _forceClosed Whether the allocation was force closed
+     */
+    function _closeAllocation(
+        mapping(address allocationId => IAllocation.State allocation) storage _allocations,
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        mapping(bytes32 subgraphDeploymentId => uint256 tokens) storage _subgraphAllocatedTokens,
+        IRewardsManager graphRewardsManager,
+        address _allocationId,
+        bool _forceClosed
+    ) private {
+        IAllocation.State memory allocation = _allocations.get(_allocationId);
+
+        // Reclaim uncollected rewards before closing
+        uint256 reclaimedRewards = graphRewardsManager.reclaimRewards(RewardsCondition.CLOSE_ALLOCATION, _allocationId);
+
+        // Take rewards snapshot to prevent other allos from counting tokens from this allo
+        _allocations.snapshotRewards(
+            _allocationId,
+            graphRewardsManager.onSubgraphAllocationUpdate(allocation.subgraphDeploymentId)
+        );
+
+        // Clear pending rewards only if rewards were reclaimed. This marks them as consumed,
+        // which could be useful for future logic that searches for unconsumed rewards.
+        // Known limitation: This capture is incomplete due to other code paths (e.g., _presentPOI)
+        // that clear pending even when rewards are not consumed.
+        if (0 < reclaimedRewards) _allocations.clearPendingRewards(_allocationId);
+
+        _allocations.close(_allocationId);
+        allocationProvisionTracker.release(allocation.indexer, allocation.tokens);
+
+        // Update total allocated tokens for the subgraph deployment
+        _subgraphAllocatedTokens[allocation.subgraphDeploymentId] =
+            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] - allocation.tokens;
+
+        emit AllocationHandler.AllocationClosed(
+            allocation.indexer,
+            _allocationId,
+            allocation.subgraphDeploymentId,
+            allocation.tokens,
+            _forceClosed
+        );
+    }
+
+    /**
+     * @notice Distributes indexing rewards to delegators and indexer
+     * @param _allocation The allocation state
+     * @param _rewardsCollected Total rewards to distribute
+     * @param _params The present params containing staking, token, and destination info
+     * @return tokensIndexerRewards Amount sent to indexer
+     * @return tokensDelegationRewards Amount sent to delegation pool
+     */
+    function _distributeIndexingRewards(
+        IAllocation.State memory _allocation,
+        uint256 _rewardsCollected,
+        PresentParams memory _params
+    ) private returns (uint256 tokensIndexerRewards, uint256 tokensDelegationRewards) {
+        if (_rewardsCollected == 0) return (0, 0);
+
+        // Calculate and distribute delegator share
+        uint256 delegatorCut = _params.graphStaking.getDelegationFeeCut(
+            _allocation.indexer,
+            _params.dataService,
+            IGraphPayments.PaymentTypes.IndexingRewards
+        );
+        IHorizonStakingTypes.DelegationPool memory pool = _params.graphStaking.getDelegationPool(
+            _allocation.indexer,
+            _params.dataService
+        );
+        tokensDelegationRewards = pool.shares > 0 ? _rewardsCollected.mulPPM(delegatorCut) : 0;
+        if (tokensDelegationRewards > 0) {
+            _params.graphToken.approve(address(_params.graphStaking), tokensDelegationRewards);
+            _params.graphStaking.addToDelegationPool(_allocation.indexer, _params.dataService, tokensDelegationRewards);
+        }
+
+        // Distribute indexer share
+        tokensIndexerRewards = _rewardsCollected - tokensDelegationRewards;
+        if (tokensIndexerRewards > 0) {
+            if (_params._paymentsDestination == address(0)) {
+                _params.graphToken.approve(address(_params.graphStaking), tokensIndexerRewards);
+                _params.graphStaking.stakeToProvision(_allocation.indexer, _params.dataService, tokensIndexerRewards);
+            } else {
+                _params.graphToken.pushTokens(_params._paymentsDestination, tokensIndexerRewards);
+            }
+        }
+    }
+
+    /**
+     * @notice Checks if an allocation is over-allocated
+     * @param allocationProvisionTracker The mapping of indexers to their locked tokens
+     * @param graphStaking The Horizon staking contract to check delegation ratios
+     * @param _indexer The address of the indexer
+     * @param _delegationRatio The delegation ratio to consider when locking tokens
+     * @return True if the allocation is over-allocated, false otherwise
+     */
+    function _isOverAllocated(
+        mapping(address indexer => uint256 tokens) storage allocationProvisionTracker,
+        IHorizonStaking graphStaking,
+        address _indexer,
+        uint32 _delegationRatio
+    ) private view returns (bool) {
+        return !allocationProvisionTracker.check(graphStaking, _indexer, _delegationRatio);
+    }
+
+    /**
+     * @notice Verifies ownership of an allocation id by verifying an EIP712 allocation proof
+     * @dev Requirements:
+     * - Signer must be the allocation id address
+     * @param _encodeAllocationProof The EIP712 encoded allocation proof
+     * @param _allocationId The id of the allocation
+     * @param _proof The EIP712 proof, an EIP712 signed message of (indexer,allocationId)
+     */
+    function _verifyAllocationProof(
+        bytes32 _encodeAllocationProof,
+        address _allocationId,
+        bytes memory _proof
+    ) private pure {
+        address signer = ECDSA.recover(_encodeAllocationProof, _proof);
+        require(
+            signer == _allocationId,
+            AllocationHandler.AllocationHandlerInvalidAllocationProof(signer, _allocationId)
+        );
+    }
+}
diff --git a/packages/subgraph-service/contracts/libraries/IndexingAgreement.sol b/packages/subgraph-service/contracts/libraries/IndexingAgreement.sol
new file mode 100644
index 000000000..7d7bce017
--- /dev/null
+++ b/packages/subgraph-service/contracts/libraries/IndexingAgreement.sol
@@ -0,0 +1,798 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.33;
+
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
+import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
+
+import { AllocationHandler } from "../libraries/AllocationHandler.sol";
+import { Directory } from "../utilities/Directory.sol";
+import { Allocation } from "./Allocation.sol";
+import { IndexingAgreementDecoder } from "./IndexingAgreementDecoder.sol";
+
+/**
+ * @title IndexingAgreement library
+ * @author Edge & Node
+ * @notice Manages indexing agreement lifecycle: acceptance, updates, cancellation and fee collection.
+ * @custom:security-contact Please email security+contracts@thegraph.com if you find any
+ * bugs. We may have an active bug bounty program.
+ */
+library IndexingAgreement {
+    using IndexingAgreement for StorageManager;
+    using Allocation for IAllocation.State;
+    using Allocation for mapping(address => IAllocation.State);
+
+    /**
+     * @notice Accept Indexing Agreement metadata
+     * @param subgraphDeploymentId The subgraph deployment ID
+     * @param version The indexing agreement version
+     * @param terms The indexing agreement terms
+     */
+    struct AcceptIndexingAgreementMetadata {
+        bytes32 subgraphDeploymentId;
+        IIndexingAgreement.IndexingAgreementVersion version;
+        bytes terms;
+    }
+
+    /**
+     * @notice Update Indexing Agreement metadata
+     * @param version The indexing agreement version
+     * @param terms The indexing agreement terms
+     */
+    struct UpdateIndexingAgreementMetadata {
+        IIndexingAgreement.IndexingAgreementVersion version;
+        bytes terms;
+    }
+
+    /**
+     * @notice Indexing Agreement Terms (Version 1)
+     * @param tokensPerSecond The amount of tokens per second
+     * @param tokensPerEntityPerSecond The amount of tokens per entity per second
+     */
+    struct IndexingAgreementTermsV1 {
+        uint256 tokensPerSecond;
+        uint256 tokensPerEntityPerSecond;
+    }
+
+    /**
+     * @notice Parameters for collecting indexing fees
+     * @param indexer The address of the indexer
+     * @param agreementId The ID of the indexing agreement
+     * @param currentEpoch The current epoch
+     * @param receiverDestination The address where the collected fees should be sent
+     * @param data The encoded data containing the number of entities indexed, proof of indexing, and epoch
+     * @param indexingFeesCut The indexing fees cut in PPM
+     */
+    struct CollectParams {
+        address indexer;
+        bytes16 agreementId;
+        uint256 currentEpoch;
+        address receiverDestination;
+        bytes data;
+        uint256 indexingFeesCut;
+    }
+
+    /**
+     * @notice Nested data for collecting indexing fees V1.
+     *
+     * @param entities The number of entities
+     * @param poi The proof of indexing (POI)
+     * @param poiBlockNumber The block number of the POI
+     * @param metadata Additional metadata associated with the collection
+     * @param maxSlippage Max acceptable tokens to lose due to rate limiting, or type(uint256).max to ignore
+     */
+    struct CollectIndexingFeeDataV1 {
+        uint256 entities;
+        bytes32 poi;
+        uint256 poiBlockNumber;
+        bytes metadata;
+        uint256 maxSlippage;
+    }
+
+    /**
+     * @notice Storage manager for indexing agreements
+     * @dev This struct holds the state of indexing agreements and their terms.
+     * It is used to manage the lifecycle of indexing agreements in the subgraph service.
+     * @param agreements Mapping of agreement IDs to their states
+     * @param termsV1 Mapping of agreement IDs to their terms for version 1 agreements
+     * @param allocationToActiveAgreementId Mapping of allocation IDs to their active agreement IDs
+     * @custom:storage-location erc7201:graphprotocol.subgraph-service.storage.StorageManager.IndexingAgreement
+     */
+    struct StorageManager {
+        mapping(bytes16 => IIndexingAgreement.State) agreements;
+        mapping(bytes16 agreementId => IndexingAgreementTermsV1 data) termsV1;
+        mapping(address allocationId => bytes16 agreementId) allocationToActiveAgreementId;
+    }
+
+    /**
+     * @notice Storage location for the indexing agreement storage manager
+     * @dev Equals keccak256(abi.encode(uint256(keccak256("graphprotocol.subgraph-service.storage.StorageManager.IndexingAgreement")) - 1)) & ~bytes32(uint256(0xff))
+     */
+    bytes32 public constant INDEXING_AGREEMENT_STORAGE_MANAGER_LOCATION =
+        0xb59b65b7215c7fb95ac34d2ad5aed7c775c8bc77ad936b1b43e17b95efc8e400;
+
+    /**
+     * @notice Emitted when an indexer collects indexing fees from a V1 agreement
+     * @param indexer The address of the indexer
+     * @param payer The address paying for the indexing fees
+     * @param agreementId The id of the agreement
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param currentEpoch The current epoch
+     * @param tokensCollected The amount of tokens collected
+     * @param entities The number of entities indexed
+     * @param poi The proof of indexing
+     * @param poiBlockNumber The block number of the proof of indexing
+     * @param metadata Additional metadata associated with the collection
+     */
+    event IndexingFeesCollectedV1(
+        address indexed indexer,
+        address indexed payer,
+        bytes16 indexed agreementId,
+        address allocationId,
+        bytes32 subgraphDeploymentId,
+        uint256 currentEpoch,
+        uint256 tokensCollected,
+        uint256 entities,
+        bytes32 poi,
+        uint256 poiBlockNumber,
+        bytes metadata
+    );
+
+    /**
+     * @notice Emitted when an indexing agreement is canceled
+     * @param indexer The address of the indexer
+     * @param payer The address of the payer
+     * @param agreementId The id of the agreement
+     * @param canceledOnBehalfOf The address of the entity that canceled the agreement
+     */
+    event IndexingAgreementCanceled(
+        address indexed indexer,
+        address indexed payer,
+        bytes16 indexed agreementId,
+        address canceledOnBehalfOf
+    );
+
+    /**
+     * @notice Emitted when an indexing agreement is accepted
+     * @param indexer The address of the indexer
+     * @param payer The address of the payer
+     * @param agreementId The id of the agreement
+     * @param allocationId The id of the allocation
+     * @param subgraphDeploymentId The id of the subgraph deployment
+     * @param version The version of the indexing agreement
+     * @param versionTerms The version data of the indexing agreement
+     */
+    event IndexingAgreementAccepted(
+        address indexed indexer,
+        address indexed payer,
+        bytes16 indexed agreementId,
+        address allocationId,
+        bytes32 subgraphDeploymentId,
+        IIndexingAgreement.IndexingAgreementVersion version,
+        bytes versionTerms
+    );
+
+    /**
+     * @notice Emitted when an indexing agreement is updated
+     * @param indexer The address of the indexer
+     * @param payer The address of the payer
+     * @param agreementId The id of the agreement
+     * @param allocationId The id of the allocation
+     * @param version The version of the indexing agreement
+     * @param versionTerms The version data of the indexing agreement
+     */
+    event IndexingAgreementUpdated(
+        address indexed indexer,
+        address indexed payer,
+        bytes16 indexed agreementId,
+        address allocationId,
+        IIndexingAgreement.IndexingAgreementVersion version,
+        bytes versionTerms
+    );
+
+    /**
+     * @notice Thrown when trying to interact with an agreement with an invalid version
+     * @param version The invalid version
+     */
+    error IndexingAgreementInvalidVersion(IIndexingAgreement.IndexingAgreementVersion version);
+
+    /**
+     * @notice Thrown when an agreement is not for the subgraph data service
+     * @param expectedDataService The expected data service address
+     * @param wrongDataService The wrong data service address
+     */
+    error IndexingAgreementWrongDataService(address expectedDataService, address wrongDataService);
+
+    /**
+     * @notice Thrown when an agreement and the allocation correspond to different deployment IDs
+     * @param agreementDeploymentId The agreement's deployment ID
+     * @param allocationId The allocation ID
+     * @param allocationDeploymentId The allocation's deployment ID
+     */
+    error IndexingAgreementDeploymentIdMismatch(
+        bytes32 agreementDeploymentId,
+        address allocationId,
+        bytes32 allocationDeploymentId
+    );
+
+    /**
+     * @notice Thrown when the agreement is already accepted
+     * @param agreementId The agreement ID
+     */
+    error IndexingAgreementAlreadyAccepted(bytes16 agreementId);
+
+    /**
+     * @notice Thrown when an allocation already has an active agreement
+     * @param allocationId The allocation ID
+     */
+    error AllocationAlreadyHasIndexingAgreement(address allocationId);
+
+    /**
+     * @notice Thrown when caller or proxy can not cancel an agreement
+     * @param owner The address of the owner of the agreement
+     * @param unauthorized The unauthorized caller
+     */
+    error IndexingAgreementNonCancelableBy(address owner, address unauthorized);
+
+    /**
+     * @notice Thrown when the agreement is not active
+     * @param agreementId The agreement ID
+     */
+    error IndexingAgreementNotActive(bytes16 agreementId);
+
+    /**
+     * @notice Thrown when the agreement is not collectable
+     * @param agreementId The agreement ID
+     */
+    error IndexingAgreementNotCollectable(bytes16 agreementId);
+
+    /**
+     * @notice Thrown when trying to interact with an agreement not owned by the indexer
+     * @param agreementId The agreement ID
+     * @param unauthorizedIndexer The unauthorized indexer
+     */
+    error IndexingAgreementNotAuthorized(bytes16 agreementId, address unauthorizedIndexer);
+
+    /**
+     * @notice Thrown when indexing agreement terms are invalid
+     * @param tokensPerSecond The indexing agreement tokens per second
+     * @param maxOngoingTokensPerSecond The RCA maximum tokens per second
+     */
+    error IndexingAgreementInvalidTerms(uint256 tokensPerSecond, uint256 maxOngoingTokensPerSecond);
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @notice Accept an indexing agreement.
+     *
+     * Requirements:
+     * - Allocation must belong to the indexer and be open
+     * - Agreement must be for this data service
+     * - Agreement's subgraph deployment must match the allocation's subgraph deployment
+     * - Agreement must not have been accepted before
+     * - Allocation must not have an agreement already
+     *
+     * @dev signedRCA.rca.metadata is an encoding of {IndexingAgreement.AcceptIndexingAgreementMetadata}
+     *
+     * Emits {IndexingAgreementAccepted} event
+     *
+     * @param self The indexing agreement storage manager
+     * @param allocations The mapping of allocation IDs to their states
+     * @param allocationId The id of the allocation
+     * @param signedRCA The signed Recurring Collection Agreement
+     * @return The agreement ID assigned to the accepted indexing agreement
+     */
+    function accept(
+        StorageManager storage self,
+        mapping(address allocationId => IAllocation.State allocation) storage allocations,
+        address allocationId,
+        IRecurringCollector.SignedRCA calldata signedRCA
+    ) external returns (bytes16) {
+        IAllocation.State memory allocation = _requireValidAllocation(
+            allocations,
+            allocationId,
+            signedRCA.rca.serviceProvider
+        );
+
+        require(
+            signedRCA.rca.dataService == address(this),
+            IndexingAgreementWrongDataService(address(this), signedRCA.rca.dataService)
+        );
+
+        AcceptIndexingAgreementMetadata memory metadata = IndexingAgreementDecoder.decodeRCAMetadata(
+            signedRCA.rca.metadata
+        );
+
+        bytes16 agreementId = _directory().recurringCollector().generateAgreementId(
+            signedRCA.rca.payer,
+            signedRCA.rca.dataService,
+            signedRCA.rca.serviceProvider,
+            signedRCA.rca.deadline,
+            signedRCA.rca.nonce
+        );
+
+        IIndexingAgreement.State storage agreement = self.agreements[agreementId];
+
+        require(agreement.allocationId == address(0), IndexingAgreementAlreadyAccepted(agreementId));
+
+        require(
+            allocation.subgraphDeploymentId == metadata.subgraphDeploymentId,
+            IndexingAgreementDeploymentIdMismatch(
+                metadata.subgraphDeploymentId,
+                allocationId,
+                allocation.subgraphDeploymentId
+            )
+        );
+
+        // Ensure that an allocation can only have one active indexing agreement
+        require(
+            self.allocationToActiveAgreementId[allocationId] == bytes16(0),
+            AllocationAlreadyHasIndexingAgreement(allocationId)
+        );
+        self.allocationToActiveAgreementId[allocationId] = agreementId;
+
+        agreement.version = metadata.version;
+        agreement.allocationId = allocationId;
+
+        require(
+            metadata.version == IIndexingAgreement.IndexingAgreementVersion.V1,
+            IndexingAgreementInvalidVersion(metadata.version)
+        );
+        _setTermsV1(self, agreementId, metadata.terms, signedRCA.rca.maxOngoingTokensPerSecond);
+
+        emit IndexingAgreementAccepted(
+            signedRCA.rca.serviceProvider,
+            signedRCA.rca.payer,
+            agreementId,
+            allocationId,
+            metadata.subgraphDeploymentId,
+            metadata.version,
+            metadata.terms
+        );
+
+        require(_directory().recurringCollector().accept(signedRCA) == agreementId, "internal: agreement ID mismatch");
+        return agreementId;
+    }
+    /* solhint-enable function-max-lines */
+
+    /**
+     * @notice Update an indexing agreement.
+     *
+     * Requirements:
+     * - Agreement must be active
+     * - The indexer must be the service provider of the agreement
+     *
+     * @dev signedRCA.rcau.metadata is an encoding of {IndexingAgreement.UpdateIndexingAgreementMetadata}
+     *
+     * Emits {IndexingAgreementUpdated} event
+     *
+     * @param self The indexing agreement storage manager
+     * @param indexer The indexer address
+     * @param signedRCAU The signed Recurring Collection Agreement Update
+     */
+    function update(
+        StorageManager storage self,
+        address indexer,
+        IRecurringCollector.SignedRCAU calldata signedRCAU
+    ) external {
+        IIndexingAgreement.AgreementWrapper memory wrapper = _get(self, signedRCAU.rcau.agreementId);
+        require(_isActive(wrapper), IndexingAgreementNotActive(signedRCAU.rcau.agreementId));
+        require(
+            wrapper.collectorAgreement.serviceProvider == indexer,
+            IndexingAgreementNotAuthorized(signedRCAU.rcau.agreementId, indexer)
+        );
+
+        UpdateIndexingAgreementMetadata memory metadata = IndexingAgreementDecoder.decodeRCAUMetadata(
+            signedRCAU.rcau.metadata
+        );
+
+        require(
+            wrapper.agreement.version == IIndexingAgreement.IndexingAgreementVersion.V1,
+            "internal: invalid version"
+        );
+        require(
+            metadata.version == IIndexingAgreement.IndexingAgreementVersion.V1,
+            IndexingAgreementInvalidVersion(metadata.version)
+        );
+        _setTermsV1(
+            self,
+            signedRCAU.rcau.agreementId,
+            metadata.terms,
+            wrapper.collectorAgreement.maxOngoingTokensPerSecond
+        );
+
+        emit IndexingAgreementUpdated({
+            indexer: wrapper.collectorAgreement.serviceProvider,
+            payer: wrapper.collectorAgreement.payer,
+            agreementId: signedRCAU.rcau.agreementId,
+            allocationId: wrapper.agreement.allocationId,
+            version: metadata.version,
+            versionTerms: metadata.terms
+        });
+
+        _directory().recurringCollector().update(signedRCAU);
+    }
+
+    /**
+     * @notice Cancel an indexing agreement.
+     *
+     * @dev This function allows the indexer to cancel an indexing agreement.
+     *
+     * Requirements:
+     * - Agreement must be active
+     * - The indexer must be the service provider of the agreement
+     *
+     * Emits {IndexingAgreementCanceled} event
+     *
+     * @param self The indexing agreement storage manager
+     * @param indexer The indexer address
+     * @param agreementId The id of the agreement to cancel
+     */
+    function cancel(StorageManager storage self, address indexer, bytes16 agreementId) external {
+        IIndexingAgreement.AgreementWrapper memory wrapper = _get(self, agreementId);
+        require(_isActive(wrapper), IndexingAgreementNotActive(agreementId));
+        require(
+            wrapper.collectorAgreement.serviceProvider == indexer,
+            IndexingAgreementNonCancelableBy(wrapper.collectorAgreement.serviceProvider, indexer)
+        );
+        _cancel(
+            self,
+            agreementId,
+            wrapper.agreement,
+            wrapper.collectorAgreement,
+            IRecurringCollector.CancelAgreementBy.ServiceProvider
+        );
+    }
+
+    /**
+     * @notice Cancel an allocation's indexing agreement if it exists.
+     *
+     * @dev This function is to be called by the data service when an allocation is closed.
+     *
+     * Requirements:
+     * - The allocation must have an active agreement
+     * - Agreement must be active
+     *
+     * Emits {IndexingAgreementCanceled} event
+     *
+     * @param self The indexing agreement storage manager
+     * @param _allocationId The allocation ID
+     * @param forceClosed Whether the allocation was force closed
+     *
+     */
+    function onCloseAllocation(StorageManager storage self, address _allocationId, bool forceClosed) external {
+        bytes16 agreementId = self.allocationToActiveAgreementId[_allocationId];
+        if (agreementId == bytes16(0)) {
+            return;
+        }
+
+        IIndexingAgreement.AgreementWrapper memory wrapper = _get(self, agreementId);
+        if (!_isActive(wrapper)) {
+            return;
+        }
+
+        _cancel(
+            self,
+            agreementId,
+            wrapper.agreement,
+            wrapper.collectorAgreement,
+            forceClosed
+                ? IRecurringCollector.CancelAgreementBy.ThirdParty
+                : IRecurringCollector.CancelAgreementBy.ServiceProvider
+        );
+    }
+
+    /**
+     * @notice Cancel an indexing agreement by the payer.
+     *
+     * @dev This function allows the payer to cancel an indexing agreement.
+     *
+     * Requirements:
+     * - Agreement must be active
+     * - The caller must be authorized to cancel the agreement in the collector on the payer's behalf
+     *
+     * Emits {IndexingAgreementCanceled} event
+     *
+     * @param self The indexing agreement storage manager
+     * @param agreementId The id of the agreement to cancel
+     */
+    function cancelByPayer(StorageManager storage self, bytes16 agreementId) external {
+        IIndexingAgreement.AgreementWrapper memory wrapper = _get(self, agreementId);
+        require(_isActive(wrapper), IndexingAgreementNotActive(agreementId));
+        require(
+            _directory().recurringCollector().isAuthorized(wrapper.collectorAgreement.payer, msg.sender),
+            IndexingAgreementNonCancelableBy(wrapper.collectorAgreement.payer, msg.sender)
+        );
+        _cancel(
+            self,
+            agreementId,
+            wrapper.agreement,
+            wrapper.collectorAgreement,
+            IRecurringCollector.CancelAgreementBy.Payer
+        );
+    }
+
+    /* solhint-disable function-max-lines */
+    /**
+     * @notice Collect Indexing fees
+     * @dev Uses the {RecurringCollector} to collect payment from Graph Horizon payments protocol.
+     * Fees are distributed to service provider and delegators by {GraphPayments}
+     *
+     * Requirements:
+     * - Allocation must be open
+     * - Agreement must be active
+     * - Agreement must be of version V1
+     * - The data must be encoded as per {IndexingAgreementDecoder.decodeCollectIndexingFeeDataV1}
+     *
+     * Emits a {IndexingFeesCollectedV1} event.
+     *
+     * @param self The indexing agreement storage manager
+     * @param allocations The mapping of allocation IDs to their states
+     * @param params The parameters for collecting indexing fees
+     * @return The address of the service provider that collected the fees
+     * @return The amount of fees collected
+     */
+    function collect(
+        StorageManager storage self,
+        mapping(address allocationId => IAllocation.State allocation) storage allocations,
+        CollectParams calldata params
+    ) external returns (address, uint256) {
+        IIndexingAgreement.AgreementWrapper memory wrapper = _get(self, params.agreementId);
+        IAllocation.State memory allocation = _requireValidAllocation(
+            allocations,
+            wrapper.agreement.allocationId,
+            wrapper.collectorAgreement.serviceProvider
+        );
+        require(
+            allocation.indexer == params.indexer,
+            IndexingAgreementNotAuthorized(params.agreementId, params.indexer)
+        );
+        // Get collection info from RecurringCollector (single source of truth for temporal logic)
+        (bool isCollectable, uint256 collectionSeconds, ) = _directory().recurringCollector().getCollectionInfo(
+            wrapper.collectorAgreement
+        );
+        require(_isValid(wrapper) && isCollectable, IndexingAgreementNotCollectable(params.agreementId));
+
+        require(
+            wrapper.agreement.version == IIndexingAgreement.IndexingAgreementVersion.V1,
+            IndexingAgreementInvalidVersion(wrapper.agreement.version)
+        );
+
+        CollectIndexingFeeDataV1 memory data = IndexingAgreementDecoder.decodeCollectIndexingFeeDataV1(params.data);
+
+        uint256 expectedTokens = (data.entities == 0 && data.poi == bytes32(0))
+            ? 0
+            : _tokensToCollect(self, params.agreementId, data.entities, collectionSeconds);
+
+        // `tokensCollected` <= `expectedTokens` because the recurring collector will further narrow
+        // down the tokens allowed, based on the RCA terms.
+        uint256 tokensCollected = _directory().recurringCollector().collect(
+            IGraphPayments.PaymentTypes.IndexingFee,
+            abi.encode(
+                IRecurringCollector.CollectParams({
+                    agreementId: params.agreementId,
+                    collectionId: bytes32(uint256(uint160(wrapper.agreement.allocationId))),
+                    tokens: expectedTokens,
+                    dataServiceCut: params.indexingFeesCut,
+                    receiverDestination: params.receiverDestination,
+                    maxSlippage: data.maxSlippage
+                })
+            )
+        );
+
+        emit IndexingFeesCollectedV1(
+            wrapper.collectorAgreement.serviceProvider,
+            wrapper.collectorAgreement.payer,
+            params.agreementId,
+            wrapper.agreement.allocationId,
+            allocation.subgraphDeploymentId,
+            params.currentEpoch,
+            tokensCollected,
+            data.entities,
+            data.poi,
+            data.poiBlockNumber,
+            data.metadata
+        );
+
+        return (wrapper.collectorAgreement.serviceProvider, tokensCollected);
+    }
+    /* solhint-enable function-max-lines */
+
+    /**
+     * @notice Get the indexing agreement for a given agreement ID.
+     *
+     * @param self The indexing agreement storage manager
+     * @param agreementId The id of the indexing agreement
+     * @return The indexing agreement wrapper containing the agreement state and collector agreement data
+     */
+    function get(
+        StorageManager storage self,
+        bytes16 agreementId
+    ) external view returns (IIndexingAgreement.AgreementWrapper memory) {
+        IIndexingAgreement.AgreementWrapper memory wrapper = _get(self, agreementId);
+        require(wrapper.collectorAgreement.dataService == address(this), IndexingAgreementNotActive(agreementId));
+
+        return wrapper;
+    }
+
+    /**
+     * @notice Get the storage manager for indexing agreements.
+     * @dev This function retrieves the storage manager for indexing agreements.
+     * @return m The storage manager for indexing agreements
+     */
+    function _getStorageManager() internal pure returns (StorageManager storage m) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            m.slot := INDEXING_AGREEMENT_STORAGE_MANAGER_LOCATION
+        }
+    }
+
+    /**
+     * @notice Set the terms for an indexing agreement of version V1.
+     * @dev This function updates the terms of an indexing agreement in the storage manager.
+     * @param _manager The indexing agreement storage manager
+     * @param _agreementId The id of the agreement to update
+     * @param _data The encoded terms data
+     * @param maxOngoingTokensPerSecond The RCA maximum tokens per second limit for validation
+     */
+    function _setTermsV1(
+        StorageManager storage _manager,
+        bytes16 _agreementId,
+        bytes memory _data,
+        uint256 maxOngoingTokensPerSecond
+    ) private {
+        IndexingAgreementTermsV1 memory newTerms = IndexingAgreementDecoder.decodeIndexingAgreementTermsV1(_data);
+        _validateTermsAgainstRCA(newTerms, maxOngoingTokensPerSecond);
+        _manager.termsV1[_agreementId].tokensPerSecond = newTerms.tokensPerSecond;
+        _manager.termsV1[_agreementId].tokensPerEntityPerSecond = newTerms.tokensPerEntityPerSecond;
+    }
+
+    /**
+     * @notice Cancel an indexing agreement.
+     *
+     * @dev This function does the actual agreement cancelation.
+     *
+     * Emits {IndexingAgreementCanceled} event
+     *
+     * @param _manager The indexing agreement storage manager
+     * @param _agreementId The id of the agreement to cancel
+     * @param _agreement The indexing agreement state
+     * @param _collectorAgreement The collector agreement data
+     * @param _cancelBy The entity that is canceling the agreement
+     */
+    function _cancel(
+        StorageManager storage _manager,
+        bytes16 _agreementId,
+        IIndexingAgreement.State memory _agreement,
+        IRecurringCollector.AgreementData memory _collectorAgreement,
+        IRecurringCollector.CancelAgreementBy _cancelBy
+    ) private {
+        // Delete the allocation to active agreement link, so that the allocation
+        // can be assigned a new indexing agreement in the future.
+        delete _manager.allocationToActiveAgreementId[_agreement.allocationId];
+
+        emit IndexingAgreementCanceled(
+            _collectorAgreement.serviceProvider,
+            _collectorAgreement.payer,
+            _agreementId,
+            _cancelBy == IRecurringCollector.CancelAgreementBy.Payer
+                ? _collectorAgreement.payer
+                : _collectorAgreement.serviceProvider
+        );
+
+        _directory().recurringCollector().cancel(_agreementId, _cancelBy);
+    }
+
+    /**
+     * @notice Requires that the allocation is valid and owned by the indexer.
+     *
+     * Requirements:
+     * - Allocation must belong to the indexer
+     * - Allocation must be open
+     *
+     * @param _allocations The mapping of allocation IDs to their states
+     * @param _allocationId The id of the allocation
+     * @param _indexer The address of the indexer
+     * @return The allocation state
+     */
+    function _requireValidAllocation(
+        mapping(address => IAllocation.State) storage _allocations,
+        address _allocationId,
+        address _indexer
+    ) private view returns (IAllocation.State memory) {
+        IAllocation.State memory allocation = _allocations.get(_allocationId);
+        require(
+            allocation.indexer == _indexer,
+            ISubgraphService.SubgraphServiceAllocationNotAuthorized(_indexer, _allocationId)
+        );
+        require(allocation.isOpen(), AllocationHandler.AllocationHandlerAllocationClosed(_allocationId));
+
+        return allocation;
+    }
+
+    /**
+     * @notice Calculate tokens to collect based on pre-validated duration
+     * @param _manager The storage manager
+     * @param _agreementId The agreement ID
+     * @param _entities The number of entities indexed
+     * @param _collectionSeconds Pre-calculated valid collection duration
+     * @return The number of tokens to collect
+     */
+    function _tokensToCollect(
+        StorageManager storage _manager,
+        bytes16 _agreementId,
+        uint256 _entities,
+        uint256 _collectionSeconds
+    ) private view returns (uint256) {
+        IndexingAgreementTermsV1 memory termsV1 = _manager.termsV1[_agreementId];
+        return _collectionSeconds * (termsV1.tokensPerSecond + termsV1.tokensPerEntityPerSecond * _entities);
+    }
+
+    /**
+     * @notice Checks if the agreement is active
+     * Requirements:
+     * - The indexing agreement is valid
+     * - The underlying collector agreement has been accepted
+     * @param wrapper The agreement wrapper containing the indexing agreement and collector agreement data
+     * @return True if the agreement is active, false otherwise
+     **/
+    function _isActive(IIndexingAgreement.AgreementWrapper memory wrapper) private view returns (bool) {
+        return _isValid(wrapper) && wrapper.collectorAgreement.state == IRecurringCollector.AgreementState.Accepted;
+    }
+
+    /**
+     * @notice Checks if the agreement is valid
+     * Requirements:
+     * - The underlying collector agreement's data service is this contract
+     * - The indexing agreement has been accepted and has a valid allocation ID
+     * @param wrapper The agreement wrapper containing the indexing agreement and collector agreement data
+     * @return True if the agreement is valid, false otherwise
+     **/
+    function _isValid(IIndexingAgreement.AgreementWrapper memory wrapper) private view returns (bool) {
+        return wrapper.collectorAgreement.dataService == address(this) && wrapper.agreement.allocationId != address(0);
+    }
+
+    /**
+     * @notice Gets the Directory
+     * @return The Directory contract
+     */
+    function _directory() private view returns (Directory) {
+        return Directory(address(this));
+    }
+
+    /**
+     * @notice Gets the indexing agreement wrapper for a given agreement ID.
+     * @dev This function retrieves the indexing agreement wrapper containing the agreement state and collector agreement data.
+     * @param self The indexing agreement storage manager
+     * @param agreementId The id of the indexing agreement
+     * @return The indexing agreement wrapper containing the agreement state and collector agreement data
+     */
+    function _get(
+        StorageManager storage self,
+        bytes16 agreementId
+    ) private view returns (IIndexingAgreement.AgreementWrapper memory) {
+        return
+            IIndexingAgreement.AgreementWrapper({
+                agreement: self.agreements[agreementId],
+                collectorAgreement: _directory().recurringCollector().getAgreement(agreementId)
+            });
+    }
+
+    /**
+     * @notice Validates indexing agreement terms against RCA limits
+     * @param terms The indexing agreement terms to validate
+     * @param maxOngoingTokensPerSecond The RCA maximum tokens per second limit
+     */
+    function _validateTermsAgainstRCA(
+        IndexingAgreementTermsV1 memory terms,
+        uint256 maxOngoingTokensPerSecond
+    ) private pure {
+        require(
+            // solhint-disable-next-line gas-strict-inequalities
+            terms.tokensPerSecond <= maxOngoingTokensPerSecond,
+            IndexingAgreementInvalidTerms(terms.tokensPerSecond, maxOngoingTokensPerSecond)
+        );
+    }
+}
diff --git a/packages/subgraph-service/contracts/libraries/IndexingAgreementDecoder.sol b/packages/subgraph-service/contracts/libraries/IndexingAgreementDecoder.sol
new file mode 100644
index 000000000..3cd57b979
--- /dev/null
+++ b/packages/subgraph-service/contracts/libraries/IndexingAgreementDecoder.sol
@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.33;
+
+import { IndexingAgreementDecoderRaw } from "./IndexingAgreementDecoderRaw.sol";
+import { IndexingAgreement } from "./IndexingAgreement.sol";
+
+/**
+ * @title IndexingAgreementDecoder library
+ * @author Edge & Node
+ * @notice Safe decoder for indexing agreement data structures, reverting with typed errors on malformed input.
+ */
+library IndexingAgreementDecoder {
+    /**
+     * @notice Thrown when the data can't be decoded as expected
+     * @param t The type of data that was expected
+     * @param data The invalid data
+     */
+    error IndexingAgreementDecoderInvalidData(string t, bytes data);
+
+    /**
+     * @notice Decodes the data for collecting indexing fees.
+     *
+     * @param data The data to decode.
+     * @return agreementId The agreement ID
+     * @return nestedData The nested encoded data
+     */
+    function decodeCollectData(bytes memory data) public pure returns (bytes16, bytes memory) {
+        try IndexingAgreementDecoderRaw.decodeCollectData(data) returns (bytes16 agreementId, bytes memory nestedData) {
+            return (agreementId, nestedData);
+        } catch {
+            revert IndexingAgreementDecoderInvalidData("decodeCollectData", data);
+        }
+    }
+
+    /**
+     * @notice Decodes the RCA metadata.
+     *
+     * @param data The data to decode.
+     * @return The decoded data. See {IndexingAgreement.AcceptIndexingAgreementMetadata}
+     */
+    function decodeRCAMetadata(
+        bytes memory data
+    ) public pure returns (IndexingAgreement.AcceptIndexingAgreementMetadata memory) {
+        try IndexingAgreementDecoderRaw.decodeRCAMetadata(data) returns (
+            IndexingAgreement.AcceptIndexingAgreementMetadata memory decoded
+        ) {
+            return decoded;
+        } catch {
+            revert IndexingAgreementDecoderInvalidData("decodeRCAMetadata", data);
+        }
+    }
+
+    /**
+     * @notice Decodes the RCAU metadata.
+     *
+     * @param data The data to decode.
+     * @return The decoded data. See {IndexingAgreement.UpdateIndexingAgreementMetadata}
+     */
+    function decodeRCAUMetadata(
+        bytes memory data
+    ) public pure returns (IndexingAgreement.UpdateIndexingAgreementMetadata memory) {
+        try IndexingAgreementDecoderRaw.decodeRCAUMetadata(data) returns (
+            IndexingAgreement.UpdateIndexingAgreementMetadata memory decoded
+        ) {
+            return decoded;
+        } catch {
+            revert IndexingAgreementDecoderInvalidData("decodeRCAUMetadata", data);
+        }
+    }
+
+    /**
+     * @notice Decodes the collect data for indexing fees V1.
+     *
+     * @param data The data to decode.
+     * @return The decoded data structure. See {IndexingAgreement.CollectIndexingFeeDataV1}
+     */
+    function decodeCollectIndexingFeeDataV1(
+        bytes memory data
+    ) public pure returns (IndexingAgreement.CollectIndexingFeeDataV1 memory) {
+        try IndexingAgreementDecoderRaw.decodeCollectIndexingFeeDataV1(data) returns (
+            IndexingAgreement.CollectIndexingFeeDataV1 memory decoded
+        ) {
+            return decoded;
+        } catch {
+            revert IndexingAgreementDecoderInvalidData("decodeCollectIndexingFeeDataV1", data);
+        }
+    }
+
+    /**
+     * @notice Decodes the data for indexing agreement terms V1.
+     *
+     * @param data The data to decode.
+     * @return The decoded data structure. See {IndexingAgreement.IndexingAgreementTermsV1}
+     */
+    function decodeIndexingAgreementTermsV1(
+        bytes memory data
+    ) public pure returns (IndexingAgreement.IndexingAgreementTermsV1 memory) {
+        try IndexingAgreementDecoderRaw.decodeIndexingAgreementTermsV1(data) returns (
+            IndexingAgreement.IndexingAgreementTermsV1 memory decoded
+        ) {
+            return decoded;
+        } catch {
+            revert IndexingAgreementDecoderInvalidData("decodeIndexingAgreementTermsV1", data);
+        }
+    }
+}
diff --git a/packages/subgraph-service/contracts/libraries/IndexingAgreementDecoderRaw.sol b/packages/subgraph-service/contracts/libraries/IndexingAgreementDecoderRaw.sol
new file mode 100644
index 000000000..c0adb5375
--- /dev/null
+++ b/packages/subgraph-service/contracts/libraries/IndexingAgreementDecoderRaw.sol
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.33;
+
+import { IndexingAgreement } from "./IndexingAgreement.sol";
+
+/**
+ * @title IndexingAgreementDecoderRaw library
+ * @author Edge & Node
+ * @notice Low-level decoder for indexing agreement data structures, propagating native revert on malformed input.
+ */
+library IndexingAgreementDecoderRaw {
+    /**
+     * @notice See {IndexingAgreementDecoder.decodeCollectIndexingFeeData}
+     * @param data The data to decode
+     * @return agreementId The agreement ID
+     * @return nestedData The nested encoded data
+     */
+    function decodeCollectData(bytes calldata data) public pure returns (bytes16, bytes memory) {
+        return abi.decode(data, (bytes16, bytes));
+    }
+
+    /**
+     * @notice See {IndexingAgreementDecoder.decodeRCAMetadata}
+     * @dev The data should be encoded as {IndexingAgreement.AcceptIndexingAgreementMetadata}
+     * @param data The data to decode
+     * @return The decoded data
+     */
+    function decodeRCAMetadata(
+        bytes calldata data
+    ) public pure returns (IndexingAgreement.AcceptIndexingAgreementMetadata memory) {
+        return abi.decode(data, (IndexingAgreement.AcceptIndexingAgreementMetadata));
+    }
+
+    /**
+     * @notice See {IndexingAgreementDecoder.decodeRCAUMetadata}
+     * @dev The data should be encoded as {IndexingAgreement.UpdateIndexingAgreementMetadata}
+     * @param data The data to decode
+     * @return The decoded data
+     */
+    function decodeRCAUMetadata(
+        bytes calldata data
+    ) public pure returns (IndexingAgreement.UpdateIndexingAgreementMetadata memory) {
+        return abi.decode(data, (IndexingAgreement.UpdateIndexingAgreementMetadata));
+    }
+
+    /**
+     * @notice See {IndexingAgreementDecoder.decodeCollectIndexingFeeDataV1}
+     * @dev The data should be encoded as (uint256 entities, bytes32 poi, uint256 epoch)
+     * @param data The data to decode
+     * @return The decoded collect indexing fee V1 data
+     *
+     */
+    function decodeCollectIndexingFeeDataV1(
+        bytes memory data
+    ) public pure returns (IndexingAgreement.CollectIndexingFeeDataV1 memory) {
+        return abi.decode(data, (IndexingAgreement.CollectIndexingFeeDataV1));
+    }
+
+    /**
+     * @notice See {IndexingAgreementDecoder.decodeIndexingAgreementTermsV1}
+     * @dev The data should be encoded as {IndexingAgreement.IndexingAgreementTermsV1}
+     * @param data The data to decode
+     * @return The decoded indexing agreement terms
+     */
+    function decodeIndexingAgreementTermsV1(
+        bytes memory data
+    ) public pure returns (IndexingAgreement.IndexingAgreementTermsV1 memory) {
+        return abi.decode(data, (IndexingAgreement.IndexingAgreementTermsV1));
+    }
+}
diff --git a/packages/subgraph-service/contracts/libraries/LegacyAllocation.sol b/packages/subgraph-service/contracts/libraries/LegacyAllocation.sol
index 97b2be1dc..746d124ee 100644
--- a/packages/subgraph-service/contracts/libraries/LegacyAllocation.sol
+++ b/packages/subgraph-service/contracts/libraries/LegacyAllocation.sol
@@ -14,45 +14,9 @@ import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-
 library LegacyAllocation {
     using LegacyAllocation for ILegacyAllocation.State;
 
-    /**
-     * @notice Migrate a legacy allocation
-     * @dev Requirements:
-     * - The allocation must not have been previously migrated
-     * @param self The legacy allocation list mapping
-     * @param indexer The indexer that owns the allocation
-     * @param allocationId The allocation id
-     * @param subgraphDeploymentId The subgraph deployment id the allocation is for
-     * @custom:error LegacyAllocationAlreadyMigrated if the allocation has already been migrated
-     */
-    function migrate(
-        mapping(address => ILegacyAllocation.State) storage self,
-        address indexer,
-        address allocationId,
-        bytes32 subgraphDeploymentId
-    ) internal {
-        require(!self[allocationId].exists(), ILegacyAllocation.LegacyAllocationAlreadyExists(allocationId));
-
-        self[allocationId] = ILegacyAllocation.State({ indexer: indexer, subgraphDeploymentId: subgraphDeploymentId });
-    }
-
-    /**
-     * @notice Get a legacy allocation
-     * @param self The legacy allocation list mapping
-     * @param allocationId The allocation id
-     * @return The legacy allocation details
-     */
-    function get(
-        mapping(address => ILegacyAllocation.State) storage self,
-        address allocationId
-    ) internal view returns (ILegacyAllocation.State memory) {
-        return _get(self, allocationId);
-    }
-
     /**
      * @notice Revert if a legacy allocation exists
-     * @dev We first check the migrated mapping then the old staking contract.
-     * @dev TRANSITION PERIOD: after the transition period when all the allocations are migrated we can
-     * remove the call to the staking contract.
+     * @dev We check both the migrated allocations mapping and the legacy staking contract.
      * @param self The legacy allocation list mapping
      * @param graphStaking The Horizon Staking contract
      * @param allocationId The allocation id
@@ -77,19 +41,4 @@ library LegacyAllocation {
     function exists(ILegacyAllocation.State memory self) internal pure returns (bool) {
         return self.indexer != address(0);
     }
-
-    /**
-     * @notice Get a legacy allocation
-     * @param self The legacy allocation list mapping
-     * @param allocationId The allocation id
-     * @return The legacy allocation details
-     */
-    function _get(
-        mapping(address => ILegacyAllocation.State) storage self,
-        address allocationId
-    ) private view returns (ILegacyAllocation.State storage) {
-        ILegacyAllocation.State storage allocation = self[allocationId];
-        require(allocation.exists(), ILegacyAllocation.LegacyAllocationDoesNotExist(allocationId));
-        return allocation;
-    }
 }
diff --git a/packages/subgraph-service/contracts/utilities/AllocationManager.sol b/packages/subgraph-service/contracts/utilities/AllocationManager.sol
index e78fbc6f8..32329482d 100644
--- a/packages/subgraph-service/contracts/utilities/AllocationManager.sol
+++ b/packages/subgraph-service/contracts/utilities/AllocationManager.sol
@@ -1,24 +1,21 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.33;
 
-import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 import { IGraphToken } from "@graphprotocol/interfaces/contracts/contracts/token/IGraphToken.sol";
-import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
 import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
 import { IAllocationManager } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol";
 import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
-import { RewardsCondition } from "@graphprotocol/interfaces/contracts/contracts/rewards/RewardsCondition.sol";
 
 import { GraphDirectory } from "@graphprotocol/horizon/contracts/utilities/GraphDirectory.sol";
 import { AllocationManagerV1Storage } from "./AllocationManagerStorage.sol";
 
 import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
-import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { EIP712Upgradeable } from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
 import { Allocation } from "../libraries/Allocation.sol";
 import { LegacyAllocation } from "../libraries/LegacyAllocation.sol";
 import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
 import { ProvisionTracker } from "@graphprotocol/horizon/contracts/data-service/libraries/ProvisionTracker.sol";
+import { AllocationHandler } from "../libraries/AllocationHandler.sol";
 
 /**
  * @title AllocationManager contract
@@ -47,7 +44,6 @@ abstract contract AllocationManager is
         keccak256("AllocationIdProof(address indexer,address allocationId)");
     // solhint-disable-previous-line gas-small-strings
 
-    // forge-lint: disable-next-item(mixed-case-function)
     /**
      * @notice Initializes the contract and parent contracts
      * @param _name The name to use for EIP712 domain separation
@@ -58,25 +54,11 @@ abstract contract AllocationManager is
         __AllocationManager_init_unchained();
     }
 
-    // forge-lint: disable-next-item(mixed-case-function)
     /**
      * @notice Initializes the contract
      */
     function __AllocationManager_init_unchained() internal onlyInitializing {}
 
-    /**
-     * @notice Imports a legacy allocation id into the subgraph service
-     * This is a governor only action that is required to prevent indexers from re-using allocation ids from the
-     * legacy staking contract. It will revert with LegacyAllocationAlreadyMigrated if the allocation has already been migrated.
-     * @param _indexer The address of the indexer
-     * @param _allocationId The id of the allocation
-     * @param _subgraphDeploymentId The id of the subgraph deployment
-     */
-    function _migrateLegacyAllocation(address _indexer, address _allocationId, bytes32 _subgraphDeploymentId) internal {
-        _legacyAllocations.migrate(_indexer, _allocationId, _subgraphDeploymentId);
-        emit LegacyAllocationMigrated(_indexer, _allocationId, _subgraphDeploymentId);
-    }
-
     /**
      * @notice Create an allocation
      * @dev The `_allocationProof` is a 65-bytes Ethereum signed message of `keccak256(indexerAddress,allocationId)`
@@ -101,76 +83,33 @@ abstract contract AllocationManager is
         bytes memory _allocationProof,
         uint32 _delegationRatio
     ) internal {
-        require(_allocationId != address(0), AllocationManagerInvalidZeroAllocationId());
-
-        _verifyAllocationProof(_indexer, _allocationId, _allocationProof);
-
-        // Ensure allocation id is not reused
-        // need to check both subgraph service (on allocations.create()) and legacy allocations
-        _legacyAllocations.revertIfExists(_graphStaking(), _allocationId);
-
-        uint256 currentEpoch = _graphEpochManager().currentEpoch();
-        IAllocation.State memory allocation = _allocations.create(
-            _indexer,
-            _allocationId,
-            _subgraphDeploymentId,
-            _tokens,
-            _graphRewardsManager().onSubgraphAllocationUpdate(_subgraphDeploymentId),
-            currentEpoch
+        AllocationHandler.allocate(
+            _allocations,
+            _legacyAllocations,
+            allocationProvisionTracker,
+            _subgraphAllocatedTokens,
+            AllocationHandler.AllocateParams({
+                _allocationId: _allocationId,
+                _allocationProof: _allocationProof,
+                _encodeAllocationProof: _encodeAllocationProof(_indexer, _allocationId),
+                _delegationRatio: _delegationRatio,
+                _indexer: _indexer,
+                _subgraphDeploymentId: _subgraphDeploymentId,
+                _tokens: _tokens,
+                currentEpoch: _graphEpochManager().currentEpoch(),
+                graphRewardsManager: _graphRewardsManager(),
+                graphStaking: _graphStaking()
+            })
         );
-
-        // Check that the indexer has enough tokens available
-        // Note that the delegation ratio ensures overdelegation cannot be used
-        allocationProvisionTracker.lock(_graphStaking(), _indexer, _tokens, _delegationRatio);
-
-        // Update total allocated tokens for the subgraph deployment
-        _subgraphAllocatedTokens[allocation.subgraphDeploymentId] =
-            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] + allocation.tokens;
-
-        emit AllocationCreated(_indexer, _allocationId, _subgraphDeploymentId, allocation.tokens, currentEpoch);
     }
 
     /**
      * @notice Present a POI to collect indexing rewards for an allocation
      * Mints indexing rewards using the {RewardsManager} and distributes them to the indexer and delegators.
      *
-     * Requirements for indexing rewards:
-     * - POI must be non-zero
-     * - POI must not be stale (older than `maxPOIStaleness`)
-     * - Allocation must be open for at least one epoch (returns early with 0 if too young)
-     *
-     * ## Reward Paths
-     *
-     * Rewards follow one of three paths based on allocation and POI state:
-     *
-     * **CLAIMED** (normal path): Valid POI, not stale, allocation mature, subgraph not denied
-     * - Calls `takeRewards()` to mint tokens to this contract
-     * - Distributes to indexer (stake or payments destination) and delegators
-     * - Snapshots allocation to prevent double-counting
-     *
-     * **RECLAIMED** (redirect path): STALE_POI or ZERO_POI conditions
-     * - Calls `reclaimRewards()` to mint tokens to configured reclaim address
-     * - If no reclaim address configured, rewards are dropped (not minted)
-     * - Snapshots allocation to prevent double-counting
-     *
-     * **DEFERRED** (early return): ALLOCATION_TOO_YOUNG or SUBGRAPH_DENIED conditions
-     * - Returns 0 without calling take or reclaim
-     * - Does NOT snapshot allocation (preserves rewards for later collection)
-     * - Allows rewards to be claimed when condition clears
-     *
-     * ## Subgraph Denial (Soft Deny)
-     *
-     * When a subgraph is denied, this function implements "soft deny":
-     * - Returns early without claiming or reclaiming
-     * - Allocation state is preserved (pending rewards not cleared)
-     * - Pre-denial rewards remain claimable after undeny
-     * - Ongoing issuance during denial is reclaimed at RewardsManager level (hard deny)
-     *
-     * Note: Indexers should present POIs at least every `maxPOIStaleness` to avoid being locked out of rewards.
-     * A zero POI can be presented if a valid one is unavailable, to prevent staleness and slashing.
-     *
-     * Note: Reclaim address changes in RewardsManager apply retroactively to all unclaimed rewards.
+     * See {AllocationHandler-presentPOI} for detailed reward path documentation.
      *
+     * Emits a {POIPresented} event.
      * Emits a {IndexingRewardsCollected} event.
      *
      * @param _allocationId The id of the allocation to collect rewards for
@@ -179,6 +118,7 @@ abstract contract AllocationManager is
      * @param _delegationRatio The delegation ratio to consider when locking tokens
      * @param _paymentsDestination The address where indexing rewards should be sent
      * @return rewardsCollected Indexing rewards collected
+     * @return allocationForceClosed True if the allocation was force closed due to over-allocation
      */
     // solhint-disable-next-line function-max-lines
     function _presentPoi(
@@ -187,75 +127,26 @@ abstract contract AllocationManager is
         bytes memory _poiMetadata,
         uint32 _delegationRatio,
         address _paymentsDestination
-    ) internal returns (uint256 rewardsCollected) {
-        IAllocation.State memory allocation = _allocations.get(_allocationId);
-        require(allocation.isOpen(), AllocationManagerAllocationClosed(_allocationId));
-        _allocations.presentPOI(_allocationId); // Always record POI presentation to prevent staleness
-
-        uint256 currentEpoch = _graphEpochManager().currentEpoch();
-        // Scoped for stack management
-        {
-            // Determine rewards condition
-            bytes32 condition = RewardsCondition.NONE;
-            if (allocation.isStale(maxPOIStaleness)) condition = RewardsCondition.STALE_POI;
-            else if (_poi == bytes32(0))
-                condition = RewardsCondition.ZERO_POI;
-                // solhint-disable-next-line gas-strict-inequalities
-            else if (currentEpoch <= allocation.createdAtEpoch) condition = RewardsCondition.ALLOCATION_TOO_YOUNG;
-            else if (_graphRewardsManager().isDenied(allocation.subgraphDeploymentId))
-                condition = RewardsCondition.SUBGRAPH_DENIED;
-
-            emit POIPresented(
-                allocation.indexer,
-                _allocationId,
-                allocation.subgraphDeploymentId,
-                _poi,
-                _poiMetadata,
-                condition
-            );
-
-            // Early return skips the overallocation check intentionally to avoid loss of uncollected rewards
-            if (condition == RewardsCondition.ALLOCATION_TOO_YOUNG || condition == RewardsCondition.SUBGRAPH_DENIED) {
-                // Keep reward and reclaim accumulation current even if rewards are not collected
-                _graphRewardsManager().onSubgraphAllocationUpdate(allocation.subgraphDeploymentId);
-
-                return 0;
-            }
-
-            bool rewardsReclaimable = condition == RewardsCondition.STALE_POI || condition == RewardsCondition.ZERO_POI;
-            if (rewardsReclaimable) _graphRewardsManager().reclaimRewards(condition, _allocationId);
-            else rewardsCollected = _graphRewardsManager().takeRewards(_allocationId);
-        }
-
-        // Snapshot rewards to prevent accumulation for next POI, then clear pending
-        _allocations.snapshotRewards(
-            _allocationId,
-            _graphRewardsManager().onSubgraphAllocationUpdate(allocation.subgraphDeploymentId)
-        );
-        _allocations.clearPendingRewards(_allocationId);
-
-        // Scoped for stack management
-        {
-            (uint256 tokensIndexerRewards, uint256 tokensDelegationRewards) = _distributeIndexingRewards(
-                allocation,
-                rewardsCollected,
-                _paymentsDestination
-            );
-
-            emit IndexingRewardsCollected(
-                allocation.indexer,
-                _allocationId,
-                allocation.subgraphDeploymentId,
-                rewardsCollected,
-                tokensIndexerRewards,
-                tokensDelegationRewards,
-                _poi,
-                _poiMetadata,
-                currentEpoch
+    ) internal returns (uint256, bool) {
+        return
+            AllocationHandler.presentPOI(
+                _allocations,
+                allocationProvisionTracker,
+                _subgraphAllocatedTokens,
+                AllocationHandler.PresentParams({
+                    maxPOIStaleness: maxPOIStaleness,
+                    graphEpochManager: _graphEpochManager(),
+                    graphStaking: _graphStaking(),
+                    graphRewardsManager: _graphRewardsManager(),
+                    graphToken: _graphToken(),
+                    dataService: address(this),
+                    _allocationId: _allocationId,
+                    _poi: _poi,
+                    _poiMetadata: _poiMetadata,
+                    _delegationRatio: _delegationRatio,
+                    _paymentsDestination: _paymentsDestination
+                })
             );
-        }
-
-        if (_isOverAllocated(allocation.indexer, _delegationRatio)) _closeAllocation(_allocationId, true);
     }
 
     /**
@@ -277,49 +168,17 @@ abstract contract AllocationManager is
      * @param _delegationRatio The delegation ratio to consider when locking tokens
      */
     function _resizeAllocation(address _allocationId, uint256 _tokens, uint32 _delegationRatio) internal {
-        IAllocation.State memory allocation = _allocations.get(_allocationId);
-        require(allocation.isOpen(), AllocationManagerAllocationClosed(_allocationId));
-        require(_tokens != allocation.tokens, AllocationManagerAllocationSameSize(_allocationId, _tokens));
-
-        // Update provision tracker
-        uint256 oldTokens = allocation.tokens;
-        if (_tokens > oldTokens) {
-            allocationProvisionTracker.lock(_graphStaking(), allocation.indexer, _tokens - oldTokens, _delegationRatio);
-        } else {
-            allocationProvisionTracker.release(allocation.indexer, oldTokens - _tokens);
-        }
-
-        // Calculate rewards that have been accrued since the last snapshot but not yet issued
-        uint256 accRewardsPerAllocatedToken = _graphRewardsManager().onSubgraphAllocationUpdate(
-            allocation.subgraphDeploymentId
-        );
-        uint256 accRewardsPerAllocatedTokenPending = !allocation.isAltruistic()
-            ? accRewardsPerAllocatedToken - allocation.accRewardsPerAllocatedToken
-            : 0;
-
-        // Update the allocation
-        _allocations[_allocationId].tokens = _tokens;
-        _allocations[_allocationId].accRewardsPerAllocatedToken = accRewardsPerAllocatedToken;
-        _allocations[_allocationId].accRewardsPending += _graphRewardsManager().calcRewards(
-            oldTokens,
-            accRewardsPerAllocatedTokenPending
+        AllocationHandler.resizeAllocation(
+            _allocations,
+            allocationProvisionTracker,
+            _subgraphAllocatedTokens,
+            _graphStaking(),
+            _graphRewardsManager(),
+            _allocationId,
+            _tokens,
+            _delegationRatio,
+            maxPOIStaleness
         );
-
-        // If allocation is stale, reclaim pending rewards defensively.
-        // Stale allocations are not performing, so rewards should not accumulate.
-        if (allocation.isStale(maxPOIStaleness)) {
-            _graphRewardsManager().reclaimRewards(RewardsCondition.STALE_POI, _allocationId);
-            _allocations.clearPendingRewards(_allocationId);
-        }
-
-        // Update total allocated tokens for the subgraph deployment
-        if (_tokens > oldTokens) {
-            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] += (_tokens - oldTokens);
-        } else {
-            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] -= (oldTokens - _tokens);
-        }
-
-        emit AllocationResized(allocation.indexer, _allocationId, allocation.subgraphDeploymentId, _tokens, oldTokens);
     }
 
     /**
@@ -334,49 +193,18 @@ abstract contract AllocationManager is
      * - If reclaim address configured: tokens minted to that address
      * - If no reclaim address: rewards are dropped (not minted anywhere)
      *
-     * ## Known Limitation
-     *
-     * `clearPendingRewards()` is only called when `0 < reclaimedRewards`. This means:
-     * - If no reclaim address is configured, `accRewardsPending` may remain non-zero
-     *
      * Emits a {AllocationClosed} event
      *
      * @param _allocationId The id of the allocation to be closed
      * @param _forceClosed Whether the allocation was force closed
      */
     function _closeAllocation(address _allocationId, bool _forceClosed) internal {
-        IAllocation.State memory allocation = _allocations.get(_allocationId);
-
-        // Reclaim uncollected rewards before closing
-        uint256 reclaimedRewards = _graphRewardsManager().reclaimRewards(
-            RewardsCondition.CLOSE_ALLOCATION,
-            _allocationId
-        );
-
-        // Take rewards snapshot to prevent other allos from counting tokens from this allo
-        _allocations.snapshotRewards(
+        AllocationHandler.closeAllocation(
+            _allocations,
+            allocationProvisionTracker,
+            _subgraphAllocatedTokens,
+            _graphRewardsManager(),
             _allocationId,
-            _graphRewardsManager().onSubgraphAllocationUpdate(allocation.subgraphDeploymentId)
-        );
-
-        // Clear pending rewards only if rewards were reclaimed. This marks them as consumed,
-        // which could be useful for future logic that searches for unconsumed rewards.
-        // Known limitation: This capture is incomplete due to other code paths (e.g., _presentPOI)
-        // that clear pending even when rewards are not consumed.
-        if (0 < reclaimedRewards) _allocations.clearPendingRewards(_allocationId);
-
-        _allocations.close(_allocationId);
-        allocationProvisionTracker.release(allocation.indexer, allocation.tokens);
-
-        // Update total allocated tokens for the subgraph deployment
-        _subgraphAllocatedTokens[allocation.subgraphDeploymentId] =
-            _subgraphAllocatedTokens[allocation.subgraphDeploymentId] - allocation.tokens;
-
-        emit AllocationClosed(
-            allocation.indexer,
-            _allocationId,
-            allocation.subgraphDeploymentId,
-            allocation.tokens,
             _forceClosed
         );
     }
@@ -408,62 +236,7 @@ abstract contract AllocationManager is
      * @return True if the allocation is over-allocated, false otherwise
      */
     function _isOverAllocated(address _indexer, uint32 _delegationRatio) internal view returns (bool) {
-        return !allocationProvisionTracker.check(_graphStaking(), _indexer, _delegationRatio);
-    }
-
-    /**
-     * @notice Distributes indexing rewards to delegators and indexer
-     * @param _allocation The allocation state
-     * @param _rewardsCollected Total rewards to distribute
-     * @param _paymentsDestination Where to send indexer rewards (0 = stake)
-     * @return tokensIndexerRewards Amount sent to indexer
-     * @return tokensDelegationRewards Amount sent to delegation pool
-     */
-    function _distributeIndexingRewards(
-        IAllocation.State memory _allocation,
-        uint256 _rewardsCollected,
-        address _paymentsDestination
-    ) private returns (uint256 tokensIndexerRewards, uint256 tokensDelegationRewards) {
-        if (_rewardsCollected == 0) return (0, 0);
-
-        // Calculate and distribute delegator share
-        uint256 delegatorCut = _graphStaking().getDelegationFeeCut(
-            _allocation.indexer,
-            address(this),
-            IGraphPayments.PaymentTypes.IndexingRewards
-        );
-        IHorizonStakingTypes.DelegationPool memory pool = _graphStaking().getDelegationPool(
-            _allocation.indexer,
-            address(this)
-        );
-        tokensDelegationRewards = pool.shares > 0 ? _rewardsCollected.mulPPM(delegatorCut) : 0;
-        if (tokensDelegationRewards > 0) {
-            _graphToken().approve(address(_graphStaking()), tokensDelegationRewards);
-            _graphStaking().addToDelegationPool(_allocation.indexer, address(this), tokensDelegationRewards);
-        }
-
-        // Distribute indexer share
-        tokensIndexerRewards = _rewardsCollected - tokensDelegationRewards;
-        if (tokensIndexerRewards > 0) {
-            if (_paymentsDestination == address(0)) {
-                _graphToken().approve(address(_graphStaking()), tokensIndexerRewards);
-                _graphStaking().stakeToProvision(_allocation.indexer, address(this), tokensIndexerRewards);
-            } else {
-                _graphToken().pushTokens(_paymentsDestination, tokensIndexerRewards);
-            }
-        }
-    }
-
-    /**
-     * @notice Verifies ownership of an allocation id by verifying an EIP712 allocation proof
-     * @dev Requirements:
-     * - Signer must be the allocation id address
-     * @param _indexer The address of the indexer
-     * @param _allocationId The id of the allocation
-     * @param _proof The EIP712 proof, an EIP712 signed message of (indexer,allocationId)
-     */
-    function _verifyAllocationProof(address _indexer, address _allocationId, bytes memory _proof) private view {
-        address signer = ECDSA.recover(_encodeAllocationProof(_indexer, _allocationId), _proof);
-        require(signer == _allocationId, AllocationManagerInvalidAllocationProof(signer, _allocationId));
+        return
+            AllocationHandler.isOverAllocated(allocationProvisionTracker, _graphStaking(), _indexer, _delegationRatio);
     }
 }
diff --git a/packages/subgraph-service/contracts/utilities/Directory.sol b/packages/subgraph-service/contracts/utilities/Directory.sol
index 09d180a5d..f5912f95e 100644
--- a/packages/subgraph-service/contracts/utilities/Directory.sol
+++ b/packages/subgraph-service/contracts/utilities/Directory.sol
@@ -8,6 +8,7 @@ pragma solidity 0.8.33;
 import { IDisputeManager } from "@graphprotocol/interfaces/contracts/subgraph-service/IDisputeManager.sol";
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
 import { IGraphTallyCollector } from "@graphprotocol/interfaces/contracts/horizon/IGraphTallyCollector.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
 import { ICuration } from "@graphprotocol/interfaces/contracts/contracts/curation/ICuration.sol";
 
 /**
@@ -30,6 +31,10 @@ abstract contract Directory {
     /// @dev Required to collect payments via Graph Horizon payments protocol
     IGraphTallyCollector private immutable GRAPH_TALLY_COLLECTOR;
 
+    /// @notice The Recurring Collector contract address
+    /// @dev Required to collect indexing agreement payments via Graph Horizon payments protocol
+    IRecurringCollector private immutable RECURRING_COLLECTOR;
+
     /// @notice The Curation contract address
     /// @dev Required for curation fees distribution
     ICuration private immutable CURATION;
@@ -40,12 +45,14 @@ abstract contract Directory {
      * @param disputeManager The Dispute Manager contract address
      * @param graphTallyCollector The Graph Tally Collector contract address
      * @param curation The Curation contract address
+     * @param recurringCollector The Recurring Collector contract address
      */
     event SubgraphServiceDirectoryInitialized(
         address subgraphService,
         address disputeManager,
         address graphTallyCollector,
-        address curation
+        address curation,
+        address recurringCollector
     );
 
     /**
@@ -72,14 +79,36 @@ abstract contract Directory {
      * @param disputeManager The Dispute Manager contract address
      * @param graphTallyCollector The Graph Tally Collector contract address
      * @param curation The Curation contract address
+     * @param recurringCollector_ The Recurring Collector contract address
      */
-    constructor(address subgraphService, address disputeManager, address graphTallyCollector, address curation) {
+    constructor(
+        address subgraphService,
+        address disputeManager,
+        address graphTallyCollector,
+        address curation,
+        address recurringCollector_
+    ) {
         SUBGRAPH_SERVICE = ISubgraphService(subgraphService);
         DISPUTE_MANAGER = IDisputeManager(disputeManager);
         GRAPH_TALLY_COLLECTOR = IGraphTallyCollector(graphTallyCollector);
         CURATION = ICuration(curation);
+        RECURRING_COLLECTOR = IRecurringCollector(recurringCollector_);
 
-        emit SubgraphServiceDirectoryInitialized(subgraphService, disputeManager, graphTallyCollector, curation);
+        emit SubgraphServiceDirectoryInitialized(
+            subgraphService,
+            disputeManager,
+            graphTallyCollector,
+            curation,
+            recurringCollector_
+        );
+    }
+
+    /**
+     * @notice Returns the Recurring Collector contract address
+     * @return The Recurring Collector contract
+     */
+    function recurringCollector() external view returns (IRecurringCollector) {
+        return RECURRING_COLLECTOR;
     }
 
     /**
diff --git a/packages/subgraph-service/foundry.toml b/packages/subgraph-service/foundry.toml
index 26b73ce91..6dc1fcf17 100644
--- a/packages/subgraph-service/foundry.toml
+++ b/packages/subgraph-service/foundry.toml
@@ -12,3 +12,7 @@ evm_version = 'cancun'
 
 # Exclude test files from coverage reports
 no_match_coverage = "(^test/|/mocks/)"
+
+# Lint configuration
+[lint]
+exclude_lints = ["mixed-case-function", "mixed-case-variable"]
diff --git a/packages/subgraph-service/package.json b/packages/subgraph-service/package.json
index a00a28e57..cb671a6be 100644
--- a/packages/subgraph-service/package.json
+++ b/packages/subgraph-service/package.json
@@ -21,7 +21,7 @@
     "lint": "pnpm lint:ts; pnpm lint:sol; pnpm lint:forge; pnpm lint:md; pnpm lint:json",
     "lint:ts": "eslint --fix --cache '**/*.{js,ts,cjs,mjs,jsx,tsx}'; prettier -w --cache --log-level warn '**/*.{js,ts,cjs,mjs,jsx,tsx}'",
     "lint:sol": "solhint --fix --noPrompt --noPoster 'contracts/**/*.sol'; prettier -w --cache --log-level warn '**/*.sol'",
-    "lint:forge": "forge lint",
+    "lint:forge": "forge lint contracts/",
     "lint:md": "markdownlint --fix --ignore-path ../../.gitignore '**/*.md'; prettier -w --cache --log-level warn '**/*.md'",
     "lint:json": "prettier -w --cache --log-level warn '**/*.json'",
     "clean": "rm -rf build dist cache cache_forge typechain-types",
diff --git a/packages/subgraph-service/scripts/integration b/packages/subgraph-service/scripts/integration
index d5d7f1c0d..58a7ba4fe 100755
--- a/packages/subgraph-service/scripts/integration
+++ b/packages/subgraph-service/scripts/integration
@@ -124,13 +124,6 @@ npx hardhat deploy:migrate --network localhost --horizon-config integration --st
 cd ../subgraph-service
 npx hardhat test:seed --network localhost
 
-# Run integration tests - During transition period
-npx hardhat test:integration --phase during-transition-period --network localhost
-
-# Clear thawing period
-cd ../horizon
-npx hardhat transition:clear-thawing --network localhost --governor-index 1
-
 # Run integration tests - After transition period
 cd ../subgraph-service
 npx hardhat test:integration --phase after-transition-period --network localhost
diff --git a/packages/subgraph-service/tasks/test/integration.ts b/packages/subgraph-service/tasks/test/integration.ts
index 130058e90..ef63c42f4 100644
--- a/packages/subgraph-service/tasks/test/integration.ts
+++ b/packages/subgraph-service/tasks/test/integration.ts
@@ -4,13 +4,9 @@ import { TASK_TEST } from 'hardhat/builtin-tasks/task-names'
 import { task } from 'hardhat/config'
 
 task('test:integration', 'Runs all integration tests')
-  .addParam(
-    'phase',
-    'Test phase to run: "during-transition-period", "after-transition-period", "after-delegation-slashing-enabled"',
-  )
+  .addParam('phase', 'Test phase to run: "after-transition-period", "after-delegation-slashing-enabled"')
   .setAction(async (taskArgs, hre) => {
     // Get test files for each phase
-    const duringTransitionPeriodFiles = await glob('test/integration/during-transition-period/**/*.{js,ts}')
     const afterTransitionPeriodFiles = await glob('test/integration/after-transition-period/**/*.{js,ts}')
 
     // Display banner for the current test phase
@@ -18,15 +14,12 @@ task('test:integration', 'Runs all integration tests')
 
     // Run tests for the current phase
     switch (taskArgs.phase) {
-      case 'during-transition-period':
-        await hre.run(TASK_TEST, { testFiles: duringTransitionPeriodFiles })
-        break
       case 'after-transition-period':
         await hre.run(TASK_TEST, { testFiles: afterTransitionPeriodFiles })
         break
       default:
         throw new Error(
-          'Invalid phase. Must be "during-transition-period", "after-transition-period", "after-delegation-slashing-enabled", or "all"',
+          'Invalid phase. Must be "after-transition-period", "after-delegation-slashing-enabled", or "all"',
         )
     }
   })
diff --git a/packages/subgraph-service/test/integration/during-transition-period/dispute-manager.test.ts b/packages/subgraph-service/test/integration/during-transition-period/dispute-manager.test.ts
deleted file mode 100644
index a24f9703a..000000000
--- a/packages/subgraph-service/test/integration/during-transition-period/dispute-manager.test.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-import {
-  DisputeManager,
-  HorizonStaking,
-  L2GraphToken,
-  LegacyDisputeManager,
-  SubgraphService,
-} from '@graphprotocol/interfaces'
-import { generateLegacyIndexingDisputeId, generateLegacyTypeDisputeId } from '@graphprotocol/toolshed'
-import { indexersData as indexers } from '@graphprotocol/toolshed/fixtures'
-import { setGRTBalance } from '@graphprotocol/toolshed/hardhat'
-import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import { ethers } from 'hardhat'
-import hre from 'hardhat'
-
-describe('Dispute Manager', () => {
-  let disputeManager: DisputeManager
-  let legacyDisputeManager: LegacyDisputeManager
-  let graphToken: L2GraphToken
-  let staking: HorizonStaking
-  let subgraphService: SubgraphService
-
-  let snapshotId: string
-
-  // Test addresses
-  let governor: HardhatEthersSigner
-  let fisherman: HardhatEthersSigner
-  let arbitrator: HardhatEthersSigner
-  let indexer: HardhatEthersSigner
-
-  let disputeDeposit: bigint
-
-  // Allocation variables
-  let allocationId: string
-
-  before(async () => {
-    // Get contracts
-    const graph = hre.graph()
-    disputeManager = graph.subgraphService.contracts.DisputeManager
-    legacyDisputeManager = graph.subgraphService.contracts.LegacyDisputeManager
-    graphToken = graph.horizon.contracts.GraphToken
-    staking = graph.horizon.contracts.HorizonStaking
-    subgraphService = graph.subgraphService.contracts.SubgraphService
-
-    // Get signers
-    governor = await graph.accounts.getGovernor()
-    arbitrator = await graph.accounts.getArbitrator()
-    ;[fisherman] = await graph.accounts.getTestAccounts()
-
-    // Get indexer
-    const indexerFixture = indexers[0]
-    indexer = await ethers.getSigner(indexerFixture.address)
-
-    // Get allocation
-    const allocation = indexerFixture.legacyAllocations[0]
-    allocationId = allocation.allocationID
-
-    // Get dispute deposit
-    disputeDeposit = ethers.parseEther('10000')
-
-    // Set GRT balance for fisherman
-    await setGRTBalance(graph.provider, graphToken.target, fisherman.address, ethers.parseEther('1000000'))
-
-    // Set arbitrator
-    await legacyDisputeManager.connect(governor).setArbitrator(arbitrator.address)
-  })
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Legacy dispute type', () => {
-    describe('Arbitrator', () => {
-      it('should allow arbitrator to create and accept a legacy dispute on the new dispute manager after slashing on the legacy dispute manager', async () => {
-        // Create an indexing dispute on legacy dispute manager
-        await graphToken.connect(fisherman).approve(legacyDisputeManager.target, disputeDeposit)
-        await legacyDisputeManager.connect(fisherman).createIndexingDispute(allocationId, disputeDeposit)
-        const legacyDisputeId = generateLegacyIndexingDisputeId(allocationId)
-
-        // Accept the dispute on the legacy dispute manager
-        await legacyDisputeManager.connect(arbitrator).acceptDispute(legacyDisputeId)
-
-        // Get fisherman's balance before creating dispute
-        const fishermanBalanceBefore = await graphToken.balanceOf(fisherman.address)
-
-        // Get indexer's provision before creating dispute
-        const provision = await staking.getProviderTokensAvailable(indexer.address, await subgraphService.getAddress())
-
-        // Create and accept legacy dispute using the same allocation ID
-        const tokensToSlash = ethers.parseEther('100000')
-        const tokensToReward = tokensToSlash / 2n
-        await disputeManager
-          .connect(arbitrator)
-          .createAndAcceptLegacyDispute(allocationId, fisherman.address, tokensToSlash, tokensToReward)
-
-        // Get dispute ID from event
-        const disputeId = generateLegacyTypeDisputeId(allocationId)
-
-        // Verify dispute was created and accepted
-        const dispute = await disputeManager.disputes(disputeId)
-        expect(dispute.indexer).to.equal(indexer.address, 'Indexer address mismatch')
-        expect(dispute.fisherman).to.equal(fisherman.address, 'Fisherman address mismatch')
-        expect(dispute.disputeType).to.equal(3, 'Dispute type should be legacy')
-        expect(dispute.status).to.equal(1, 'Dispute status should be accepted')
-
-        // Verify indexer's stake was slashed
-        const updatedProvision = await staking.getProviderTokensAvailable(
-          indexer.address,
-          await subgraphService.getAddress(),
-        )
-        expect(updatedProvision).to.equal(provision - tokensToSlash, 'Indexer stake should be slashed')
-
-        // Verify fisherman got the reward
-        const fishermanBalance = await graphToken.balanceOf(fisherman.address)
-        expect(fishermanBalance).to.equal(
-          fishermanBalanceBefore + tokensToReward,
-          'Fisherman balance should be increased by the reward',
-        )
-      })
-
-      it('should not allow creating a legacy dispute for non-existent allocation', async () => {
-        const tokensToSlash = ethers.parseEther('1000')
-        const tokensToReward = tokensToSlash / 2n
-
-        // Attempt to create legacy dispute with non-existent allocation
-        await expect(
-          disputeManager
-            .connect(arbitrator)
-            .createAndAcceptLegacyDispute(
-              ethers.Wallet.createRandom().address,
-              fisherman.address,
-              tokensToSlash,
-              tokensToReward,
-            ),
-        ).to.be.revertedWithCustomError(disputeManager, 'DisputeManagerIndexerNotFound')
-      })
-    })
-
-    it('should not allow non-arbitrator to create a legacy dispute', async () => {
-      const tokensToSlash = ethers.parseEther('1000')
-      const tokensToReward = tokensToSlash / 2n
-
-      // Attempt to create legacy dispute as fisherman
-      await expect(
-        disputeManager
-          .connect(fisherman)
-          .createAndAcceptLegacyDispute(allocationId, fisherman.address, tokensToSlash, tokensToReward),
-      ).to.be.revertedWithCustomError(disputeManager, 'DisputeManagerNotArbitrator')
-    })
-  })
-})
diff --git a/packages/subgraph-service/test/integration/during-transition-period/governance.test.ts b/packages/subgraph-service/test/integration/during-transition-period/governance.test.ts
deleted file mode 100644
index ad638b306..000000000
--- a/packages/subgraph-service/test/integration/during-transition-period/governance.test.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { SubgraphService } from '@graphprotocol/interfaces'
-import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import { ethers } from 'hardhat'
-import hre from 'hardhat'
-
-describe('Governance', () => {
-  let subgraphService: SubgraphService
-  let snapshotId: string
-
-  // Test addresses
-  let governor: HardhatEthersSigner
-  let indexer: HardhatEthersSigner
-  let nonOwner: HardhatEthersSigner
-  let allocationId: string
-  let subgraphDeploymentId: string
-
-  const graph = hre.graph()
-
-  before(() => {
-    subgraphService = graph.subgraphService.contracts.SubgraphService
-  })
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-
-    // Get signers
-    governor = await graph.accounts.getGovernor()
-    ;[indexer, nonOwner] = await graph.accounts.getTestAccounts()
-
-    // Generate test addresses
-    allocationId = ethers.Wallet.createRandom().address
-    subgraphDeploymentId = ethers.keccak256(ethers.toUtf8Bytes('test-subgraph-deployment'))
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Legacy Allocation Migration', () => {
-    it('should migrate legacy allocation', async () => {
-      // Migrate legacy allocation
-      await subgraphService
-        .connect(governor)
-        .migrateLegacyAllocation(indexer.address, allocationId, subgraphDeploymentId)
-
-      // Verify the legacy allocation was migrated
-      const legacyAllocation = await subgraphService.getLegacyAllocation(allocationId)
-      expect(legacyAllocation.indexer).to.equal(indexer.address)
-      expect(legacyAllocation.subgraphDeploymentId).to.equal(subgraphDeploymentId)
-    })
-
-    it('should not allow non-owner to migrate legacy allocation', async () => {
-      // Attempt to migrate legacy allocation as non-owner
-      await expect(
-        subgraphService.connect(nonOwner).migrateLegacyAllocation(indexer.address, allocationId, subgraphDeploymentId),
-      ).to.be.revertedWithCustomError(subgraphService, 'OwnableUnauthorizedAccount')
-    })
-
-    it('should not allow migrating a legacy allocation that was already migrated', async () => {
-      // First migration
-      await subgraphService
-        .connect(governor)
-        .migrateLegacyAllocation(indexer.address, allocationId, subgraphDeploymentId)
-
-      // Attempt to migrate the same allocation again
-      await expect(
-        subgraphService.connect(governor).migrateLegacyAllocation(indexer.address, allocationId, subgraphDeploymentId),
-      )
-        .to.be.revertedWithCustomError(subgraphService, 'LegacyAllocationAlreadyExists')
-        .withArgs(allocationId)
-    })
-  })
-})
diff --git a/packages/subgraph-service/test/integration/during-transition-period/indexer.test.ts b/packages/subgraph-service/test/integration/during-transition-period/indexer.test.ts
deleted file mode 100644
index 7fd508c40..000000000
--- a/packages/subgraph-service/test/integration/during-transition-period/indexer.test.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { SubgraphService } from '@graphprotocol/interfaces'
-import { encodeStartServiceData, generateAllocationProof } from '@graphprotocol/toolshed'
-import { indexersData as indexers } from '@graphprotocol/toolshed/fixtures'
-import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import { ethers } from 'hardhat'
-import hre from 'hardhat'
-
-describe('Indexer', () => {
-  let subgraphService: SubgraphService
-  let snapshotId: string
-  let chainId: number
-
-  // Test addresses
-  let governor: HardhatEthersSigner
-  let indexer: HardhatEthersSigner
-  let allocationId: string
-  let subgraphDeploymentId: string
-  let allocationPrivateKey: string
-  let subgraphServiceAddress: string
-
-  const graph = hre.graph()
-
-  before(async () => {
-    // Get contracts
-    subgraphService = graph.subgraphService.contracts.SubgraphService
-
-    // Get governor and non-owner
-    governor = await graph.accounts.getGovernor()
-
-    // Get chain id
-    chainId = Number((await hre.ethers.provider.getNetwork()).chainId)
-
-    // Get subgraph service address
-    subgraphServiceAddress = await subgraphService.getAddress()
-  })
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Allocation', () => {
-    beforeEach(async () => {
-      // Get indexer
-      const indexerFixture = indexers[0]
-      indexer = await ethers.getSigner(indexerFixture.address)
-
-      // Generate test addresses
-      const allocation = indexerFixture.legacyAllocations[0]
-      allocationId = allocation.allocationID
-      subgraphDeploymentId = allocation.subgraphDeploymentID
-      allocationPrivateKey = allocation.allocationPrivateKey
-    })
-
-    it('should not be able to create an allocation with an AllocationID that already exists in HorizonStaking contract', async () => {
-      // Build allocation proof
-      const signature = await generateAllocationProof(
-        indexer.address,
-        allocationPrivateKey,
-        subgraphServiceAddress,
-        chainId,
-      )
-
-      // Attempt to create an allocation with the same ID
-      const data = encodeStartServiceData(subgraphDeploymentId, 1000n, allocationId, signature)
-
-      await expect(subgraphService.connect(indexer).startService(indexer.address, data))
-        .to.be.revertedWithCustomError(subgraphService, 'LegacyAllocationAlreadyExists')
-        .withArgs(allocationId)
-    })
-
-    it('should not be able to create an allocation that was already migrated by the owner', async () => {
-      // Migrate legacy allocation
-      await subgraphService
-        .connect(governor)
-        .migrateLegacyAllocation(indexer.address, allocationId, subgraphDeploymentId)
-
-      // Build allocation proof
-      const signature = await generateAllocationProof(
-        indexer.address,
-        allocationPrivateKey,
-        subgraphServiceAddress,
-        chainId,
-      )
-
-      // Attempt to create the same allocation
-      const data = encodeStartServiceData(subgraphDeploymentId, 1000n, allocationId, signature)
-
-      await expect(subgraphService.connect(indexer).startService(indexer.address, data))
-        .to.be.revertedWithCustomError(subgraphService, 'LegacyAllocationAlreadyExists')
-        .withArgs(allocationId)
-    })
-  })
-})
diff --git a/packages/subgraph-service/test/integration/during-transition-period/legacy-dispute-manager.test.ts b/packages/subgraph-service/test/integration/during-transition-period/legacy-dispute-manager.test.ts
deleted file mode 100644
index 51cfc557c..000000000
--- a/packages/subgraph-service/test/integration/during-transition-period/legacy-dispute-manager.test.ts
+++ /dev/null
@@ -1,256 +0,0 @@
-import { HorizonStaking, L2GraphToken, LegacyDisputeManager } from '@graphprotocol/interfaces'
-import {
-  generateAttestationData,
-  generateLegacyIndexingDisputeId,
-  generateLegacyQueryDisputeId,
-} from '@graphprotocol/toolshed'
-import { indexersData as indexers } from '@graphprotocol/toolshed/fixtures'
-import { setGRTBalance } from '@graphprotocol/toolshed/hardhat'
-import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
-import { expect } from 'chai'
-import { ethers } from 'hardhat'
-import hre from 'hardhat'
-
-describe('Legacy Dispute Manager', () => {
-  let legacyDisputeManager: LegacyDisputeManager
-  let graphToken: L2GraphToken
-  let staking: HorizonStaking
-
-  let snapshotId: string
-
-  let governor: HardhatEthersSigner
-  let arbitrator: HardhatEthersSigner
-  let indexer: HardhatEthersSigner
-  let fisherman: HardhatEthersSigner
-
-  let disputeDeposit: bigint
-
-  const graph = hre.graph()
-
-  // We have to use Aribtrm Sepolia since we're testing an already deployed contract but running on a hardhat fork
-  const chainId = 421614
-
-  before(async () => {
-    governor = await graph.accounts.getGovernor()
-    ;[arbitrator, fisherman] = await graph.accounts.getTestAccounts()
-
-    // Get contract instances with correct types
-    legacyDisputeManager = graph.subgraphService.contracts.LegacyDisputeManager
-    graphToken = graph.horizon.contracts.GraphToken
-    staking = graph.horizon.contracts.HorizonStaking
-
-    // Set GRT balances
-    await setGRTBalance(graph.provider, graphToken.target, fisherman.address, ethers.parseEther('100000'))
-  })
-
-  beforeEach(async () => {
-    // Take a snapshot before each test
-    snapshotId = await ethers.provider.send('evm_snapshot', [])
-
-    // Legacy dispute manager
-    disputeDeposit = ethers.parseEther('10000')
-
-    // Set arbitrator
-    await legacyDisputeManager.connect(governor).setArbitrator(arbitrator.address)
-  })
-
-  afterEach(async () => {
-    // Revert to the snapshot after each test
-    await ethers.provider.send('evm_revert', [snapshotId])
-  })
-
-  describe('Indexing Disputes', () => {
-    let allocationId: string
-
-    beforeEach(async () => {
-      // Get Indexer
-      const indexerFixture = indexers[0]
-      indexer = await ethers.getSigner(indexerFixture.address)
-
-      // Get allocation
-      allocationId = indexerFixture.legacyAllocations[0].allocationID
-    })
-
-    it('should allow creating and accepting indexing disputes', async () => {
-      // Create an indexing dispute
-      await graphToken.connect(fisherman).approve(legacyDisputeManager.target, disputeDeposit)
-      await legacyDisputeManager.connect(fisherman).createIndexingDispute(allocationId, disputeDeposit)
-      const disputeId = generateLegacyIndexingDisputeId(allocationId)
-
-      // Verify dispute was created
-      const disputeExists = await legacyDisputeManager.isDisputeCreated(disputeId)
-      expect(disputeExists).to.be.true
-
-      // Get state before slashing
-      const idxSlashingPercentage = 25000n
-      const indexerStakeBefore = (await staking.getServiceProvider(indexer.address)).tokensStaked
-      const slashedAmount = (indexerStakeBefore * idxSlashingPercentage) / 1_000_000n
-      const fishermanBalanceBefore = await graphToken.balanceOf(fisherman.address)
-
-      // Accept the dispute
-      await legacyDisputeManager.connect(arbitrator).acceptDispute(disputeId)
-
-      // Verify indexer was slashed for 2.5% of their stake
-      const indexerStake = (await staking.getServiceProvider(indexer.address)).tokensStaked
-      expect(indexerStake).to.equal(indexerStakeBefore - slashedAmount, 'Indexer stake was not slashed correctly')
-
-      // Verify fisherman received their deposit and 50% of the slashed amount
-      const fishermanBalance = await graphToken.balanceOf(fisherman.address)
-      expect(fishermanBalance).to.equal(
-        fishermanBalanceBefore + slashedAmount / 2n + disputeDeposit,
-        'Fisherman balance was not updated correctly',
-      )
-    })
-  })
-
-  describe('Query Disputes', () => {
-    let allocationPrivateKey: string
-    let subgraphDeploymentId: string
-
-    beforeEach(async () => {
-      // Get Indexer
-      const indexerFixture = indexers[0]
-      indexer = await ethers.getSigner(indexerFixture.address)
-
-      // Get allocation
-      const allocation = indexerFixture.legacyAllocations[0]
-      allocationPrivateKey = allocation.allocationPrivateKey
-      subgraphDeploymentId = allocation.subgraphDeploymentID
-    })
-
-    it('should allow creating and accepting query disputes', async () => {
-      // Create attestation data
-      const queryHash = ethers.keccak256(ethers.toUtf8Bytes('test-query'))
-      const responseHash = ethers.keccak256(ethers.toUtf8Bytes('test-response'))
-      const attestationData = await generateAttestationData(
-        queryHash,
-        responseHash,
-        subgraphDeploymentId,
-        allocationPrivateKey,
-        await legacyDisputeManager.getAddress(),
-        chainId,
-      )
-
-      // Create a query dispute
-      await graphToken.connect(fisherman).approve(legacyDisputeManager.target, disputeDeposit)
-      await legacyDisputeManager.connect(fisherman).createQueryDispute(attestationData, disputeDeposit)
-      const disputeId = generateLegacyQueryDisputeId(
-        queryHash,
-        responseHash,
-        subgraphDeploymentId,
-        indexer.address,
-        fisherman.address,
-      )
-
-      // Verify dispute was created
-      const disputeExists = await legacyDisputeManager.isDisputeCreated(disputeId)
-      expect(disputeExists).to.be.true
-
-      // Get state before slashing
-      const qrySlashingPercentage = 25000n
-      const indexerStakeBefore = (await staking.getServiceProvider(indexer.address)).tokensStaked
-      const slashedAmount = (indexerStakeBefore * qrySlashingPercentage) / 1_000_000n
-      const fishermanBalanceBefore = await graphToken.balanceOf(fisherman.address)
-
-      // Accept the dispute
-      await legacyDisputeManager.connect(arbitrator).acceptDispute(disputeId)
-
-      // Verify indexer was slashed for 2.5% of their stake
-      const indexerStake = (await staking.getServiceProvider(indexer.address)).tokensStaked
-      expect(indexerStake).to.equal(indexerStakeBefore - slashedAmount, 'Indexer stake was not slashed correctly')
-
-      // Verify fisherman received their deposit and 50% of the slashed amount
-      const fishermanBalance = await graphToken.balanceOf(fisherman.address)
-      expect(fishermanBalance).to.equal(
-        fishermanBalanceBefore + slashedAmount / 2n + disputeDeposit,
-        'Fisherman balance was not updated correctly',
-      )
-    })
-  })
-
-  describe('Query Dispute Conflict', () => {
-    let allocationPrivateKey: string
-    let subgraphDeploymentId: string
-
-    beforeEach(async () => {
-      // Get Indexer
-      const indexerFixture = indexers[0]
-      indexer = await ethers.getSigner(indexerFixture.address)
-
-      // Get allocation
-      const allocation = indexerFixture.legacyAllocations[0]
-      allocationPrivateKey = allocation.allocationPrivateKey
-      subgraphDeploymentId = allocation.subgraphDeploymentID
-    })
-
-    it('should allow creating conflicting query disputes', async () => {
-      // Create first attestation data
-      const queryHash = ethers.keccak256(ethers.toUtf8Bytes('test-query'))
-      const responseHash1 = ethers.keccak256(ethers.toUtf8Bytes('test-response-1'))
-      const attestationData1 = await generateAttestationData(
-        queryHash,
-        responseHash1,
-        subgraphDeploymentId,
-        allocationPrivateKey,
-        await legacyDisputeManager.getAddress(),
-        chainId,
-      )
-
-      // Create second attestation data with different query/response
-      const responseHash2 = ethers.keccak256(ethers.toUtf8Bytes('test-response-2'))
-      const attestationData2 = await generateAttestationData(
-        queryHash,
-        responseHash2,
-        subgraphDeploymentId,
-        allocationPrivateKey,
-        await legacyDisputeManager.getAddress(),
-        chainId,
-      )
-
-      // Create query dispute
-      await legacyDisputeManager.connect(fisherman).createQueryDisputeConflict(attestationData1, attestationData2)
-
-      // Create dispute IDs
-      const disputeId1 = generateLegacyQueryDisputeId(
-        queryHash,
-        responseHash1,
-        subgraphDeploymentId,
-        indexer.address,
-        fisherman.address,
-      )
-      const disputeId2 = generateLegacyQueryDisputeId(
-        queryHash,
-        responseHash2,
-        subgraphDeploymentId,
-        indexer.address,
-        fisherman.address,
-      )
-
-      // Verify both disputes were created
-      const disputeExists1 = await legacyDisputeManager.isDisputeCreated(disputeId1)
-      const disputeExists2 = await legacyDisputeManager.isDisputeCreated(disputeId2)
-      expect(disputeExists1).to.be.true
-      expect(disputeExists2).to.be.true
-
-      // Get state before slashing
-      const qrySlashingPercentage = 25000n
-      const indexerStakeBefore = (await staking.getServiceProvider(indexer.address)).tokensStaked
-      const slashedAmount = (indexerStakeBefore * qrySlashingPercentage) / 1_000_000n
-      const fishermanBalanceBefore = await graphToken.balanceOf(fisherman.address)
-
-      // Accept one dispute
-      await legacyDisputeManager.connect(arbitrator).acceptDispute(disputeId1)
-
-      // Verify indexer was slashed for 2.5% of their stake
-      const indexerStake = (await staking.getServiceProvider(indexer.address)).tokensStaked
-      expect(indexerStake).to.equal(indexerStakeBefore - slashedAmount, 'Indexer stake was not slashed correctly')
-
-      // Verify fisherman received 50% of the slashed amount
-      const fishermanBalance = await graphToken.balanceOf(fisherman.address)
-      expect(fishermanBalance).to.equal(
-        fishermanBalanceBefore + slashedAmount / 2n,
-        'Fisherman balance was not updated correctly',
-      )
-    })
-  })
-})
diff --git a/packages/subgraph-service/test/unit/SubgraphBaseTest.t.sol b/packages/subgraph-service/test/unit/SubgraphBaseTest.t.sol
index dcaaf77e5..31f18bbe0 100644
--- a/packages/subgraph-service/test/unit/SubgraphBaseTest.t.sol
+++ b/packages/subgraph-service/test/unit/SubgraphBaseTest.t.sol
@@ -6,10 +6,10 @@ import { GraphPayments } from "@graphprotocol/horizon/contracts/payments/GraphPa
 import { GraphProxy } from "@graphprotocol/contracts/contracts/upgrades/GraphProxy.sol";
 import { GraphProxyAdmin } from "@graphprotocol/contracts/contracts/upgrades/GraphProxyAdmin.sol";
 import { HorizonStaking } from "@graphprotocol/horizon/contracts/staking/HorizonStaking.sol";
-import { HorizonStakingExtension } from "@graphprotocol/horizon/contracts/staking/HorizonStakingExtension.sol";
 import { IHorizonStaking } from "@graphprotocol/interfaces/contracts/horizon/IHorizonStaking.sol";
 import { IPaymentsEscrow } from "@graphprotocol/interfaces/contracts/horizon/IPaymentsEscrow.sol";
 import { GraphTallyCollector } from "@graphprotocol/horizon/contracts/payments/collectors/GraphTallyCollector.sol";
+import { RecurringCollector } from "@graphprotocol/horizon/contracts/payments/collectors/RecurringCollector.sol";
 import { PaymentsEscrow } from "@graphprotocol/horizon/contracts/payments/PaymentsEscrow.sol";
 import { UnsafeUpgrades } from "@openzeppelin/foundry-upgrades/src/Upgrades.sol";
 
@@ -39,9 +39,9 @@ abstract contract SubgraphBaseTest is Utils, Constants {
     GraphPayments graphPayments;
     IPaymentsEscrow escrow;
     GraphTallyCollector graphTallyCollector;
+    RecurringCollector recurringCollector;
 
     HorizonStaking private stakingBase;
-    HorizonStakingExtension private stakingExtension;
 
     MockCuration curation;
     MockGRTToken token;
@@ -152,12 +152,20 @@ abstract contract SubgraphBaseTest is Utils, Constants {
             address(controller),
             REVOKE_SIGNER_THAWING_PERIOD
         );
+        recurringCollector = new RecurringCollector(
+            "RecurringCollector",
+            "1",
+            address(controller),
+            REVOKE_SIGNER_THAWING_PERIOD
+        );
+
         address subgraphServiceImplementation = address(
             new SubgraphService(
                 address(controller),
                 address(disputeManager),
                 address(graphTallyCollector),
-                address(curation)
+                address(curation),
+                address(recurringCollector)
             )
         );
         address subgraphServiceProxy = UnsafeUpgrades.deployTransparentProxy(
@@ -170,8 +178,7 @@ abstract contract SubgraphBaseTest is Utils, Constants {
         );
         subgraphService = SubgraphService(subgraphServiceProxy);
 
-        stakingExtension = new HorizonStakingExtension(address(controller), address(subgraphService));
-        stakingBase = new HorizonStaking(address(controller), address(stakingExtension), address(subgraphService));
+        stakingBase = new HorizonStaking(address(controller), address(subgraphService));
 
         graphPayments = new GraphPayments{ salt: saltGraphPayments }(address(controller), PROTOCOL_PAYMENT_CUT);
         escrow = new PaymentsEscrow{ salt: saltEscrow }(address(controller), WITHDRAW_ESCROW_THAWING_PERIOD);
diff --git a/packages/subgraph-service/test/unit/disputeManager/DisputeManager.t.sol b/packages/subgraph-service/test/unit/disputeManager/DisputeManager.t.sol
index 8354e1cf0..7662dc1c3 100644
--- a/packages/subgraph-service/test/unit/disputeManager/DisputeManager.t.sol
+++ b/packages/subgraph-service/test/unit/disputeManager/DisputeManager.t.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.27;
 
-import { MathUtils } from "@graphprotocol/horizon/contracts/libraries/MathUtils.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
 import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
 import { IDisputeManager } from "@graphprotocol/interfaces/contracts/subgraph-service/IDisputeManager.sol";
 import { IAttestation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAttestation.sol";
@@ -203,81 +203,6 @@ contract DisputeManagerTest is SubgraphServiceSharedTest {
         return _disputeId;
     }
 
-    struct Balances {
-        uint256 indexer;
-        uint256 fisherman;
-        uint256 arbitrator;
-        uint256 disputeManager;
-        uint256 staking;
-    }
-
-    function _createAndAcceptLegacyDispute(
-        address _allocationId,
-        address _fisherman,
-        uint256 _tokensSlash,
-        uint256 _tokensRewards
-    ) internal returns (bytes32) {
-        (, address arbitrator, ) = vm.readCallers();
-        address indexer = staking.getAllocation(_allocationId).indexer;
-
-        Balances memory beforeBalances = Balances({
-            indexer: token.balanceOf(indexer),
-            fisherman: token.balanceOf(_fisherman),
-            arbitrator: token.balanceOf(arbitrator),
-            disputeManager: token.balanceOf(address(disputeManager)),
-            staking: token.balanceOf(address(staking))
-        });
-
-        vm.expectEmit(address(disputeManager));
-        emit IDisputeManager.LegacyDisputeCreated(
-            keccak256(abi.encodePacked(_allocationId, "legacy")),
-            indexer,
-            _fisherman,
-            _allocationId,
-            _tokensSlash,
-            _tokensRewards
-        );
-        vm.expectEmit(address(disputeManager));
-        emit IDisputeManager.DisputeAccepted(
-            keccak256(abi.encodePacked(_allocationId, "legacy")),
-            indexer,
-            _fisherman,
-            _tokensRewards
-        );
-        bytes32 _disputeId = disputeManager.createAndAcceptLegacyDispute(
-            _allocationId,
-            _fisherman,
-            _tokensSlash,
-            _tokensRewards
-        );
-
-        Balances memory afterBalances = Balances({
-            indexer: token.balanceOf(indexer),
-            fisherman: token.balanceOf(_fisherman),
-            arbitrator: token.balanceOf(arbitrator),
-            disputeManager: token.balanceOf(address(disputeManager)),
-            staking: token.balanceOf(address(staking))
-        });
-
-        assertEq(afterBalances.indexer, beforeBalances.indexer);
-        assertEq(afterBalances.fisherman, beforeBalances.fisherman + _tokensRewards);
-        assertEq(afterBalances.arbitrator, beforeBalances.arbitrator);
-        assertEq(afterBalances.disputeManager, beforeBalances.disputeManager);
-        assertEq(afterBalances.staking, beforeBalances.staking - _tokensSlash);
-
-        IDisputeManager.Dispute memory dispute = _getDispute(_disputeId);
-        assertEq(dispute.indexer, indexer);
-        assertEq(dispute.fisherman, _fisherman);
-        assertEq(dispute.deposit, 0);
-        assertEq(dispute.relatedDisputeId, bytes32(0));
-        assertEq(uint8(dispute.disputeType), uint8(IDisputeManager.DisputeType.LegacyDispute));
-        assertEq(uint8(dispute.status), uint8(IDisputeManager.DisputeStatus.Accepted));
-        assertEq(dispute.createdAt, block.timestamp);
-        assertEq(dispute.stakeSnapshot, 0);
-
-        return _disputeId;
-    }
-
     struct BeforeValuesCreateQueryDisputeConflict {
         IAttestation.State attestation1;
         IAttestation.State attestation2;
@@ -423,10 +348,7 @@ contract DisputeManagerTest is SubgraphServiceSharedTest {
             uint32 provisionMaxVerifierCut = staking
                 .getProvision(dispute.indexer, address(subgraphService))
                 .maxVerifierCut;
-            uint256 fishermanRewardPercentage = MathUtils.min(
-                disputeManager.fishermanRewardCut(),
-                provisionMaxVerifierCut
-            );
+            uint256 fishermanRewardPercentage = Math.min(disputeManager.fishermanRewardCut(), provisionMaxVerifierCut);
             fishermanReward = _tokensSlash.mulPPM(fishermanRewardPercentage);
         }
 
diff --git a/packages/subgraph-service/test/unit/disputeManager/disputes/legacy.t.sol b/packages/subgraph-service/test/unit/disputeManager/disputes/legacy.t.sol
deleted file mode 100644
index c6f57df93..000000000
--- a/packages/subgraph-service/test/unit/disputeManager/disputes/legacy.t.sol
+++ /dev/null
@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.27;
-
-import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
-import { IDisputeManager } from "@graphprotocol/interfaces/contracts/subgraph-service/IDisputeManager.sol";
-import { DisputeManagerTest } from "../DisputeManager.t.sol";
-
-contract DisputeManagerLegacyDisputeTest is DisputeManagerTest {
-    using PPMMath for uint256;
-
-    bytes32 private requestCid = keccak256(abi.encodePacked("Request CID"));
-    bytes32 private responseCid = keccak256(abi.encodePacked("Response CID"));
-    bytes32 private subgraphDeploymentId = keccak256(abi.encodePacked("Subgraph Deployment ID"));
-
-    /*
-     * TESTS
-     */
-
-    function test_LegacyDispute(
-        uint256 tokensStaked,
-        uint256 tokensProvisioned,
-        uint256 tokensSlash,
-        uint256 tokensRewards
-    ) public {
-        vm.assume(tokensStaked <= MAX_TOKENS);
-        vm.assume(tokensStaked >= MINIMUM_PROVISION_TOKENS);
-        tokensProvisioned = bound(tokensProvisioned, MINIMUM_PROVISION_TOKENS, tokensStaked);
-        tokensSlash = bound(tokensSlash, 2, tokensProvisioned);
-        tokensRewards = bound(tokensRewards, 1, tokensSlash.mulPPM(FISHERMAN_REWARD_PERCENTAGE));
-
-        // setup indexer state
-        resetPrank(users.indexer);
-        _stake(tokensStaked);
-        _setStorageAllocationHardcoded(users.indexer, allocationId, tokensStaked - tokensProvisioned);
-        _provision(users.indexer, tokensProvisioned, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
-
-        resetPrank(users.arbitrator);
-        _createAndAcceptLegacyDispute(allocationId, users.fisherman, tokensSlash, tokensRewards);
-    }
-
-    function test_LegacyDispute_RevertIf_NotArbitrator() public useIndexer {
-        vm.expectRevert(abi.encodeWithSelector(IDisputeManager.DisputeManagerNotArbitrator.selector));
-        disputeManager.createAndAcceptLegacyDispute(allocationId, users.fisherman, 0, 0);
-    }
-
-    function test_LegacyDispute_RevertIf_AllocationNotFound() public useIndexer {
-        resetPrank(users.arbitrator);
-        vm.expectRevert(abi.encodeWithSelector(IDisputeManager.DisputeManagerIndexerNotFound.selector, address(0)));
-        disputeManager.createAndAcceptLegacyDispute(address(0), users.fisherman, 0, 0);
-    }
-}
diff --git a/packages/subgraph-service/test/unit/libraries/IndexingAgreement.t.sol b/packages/subgraph-service/test/unit/libraries/IndexingAgreement.t.sol
new file mode 100644
index 000000000..cb5c99ec8
--- /dev/null
+++ b/packages/subgraph-service/test/unit/libraries/IndexingAgreement.t.sol
@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.33;
+
+import { Test } from "forge-std/Test.sol";
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
+import { IndexingAgreement } from "../../../contracts/libraries/IndexingAgreement.sol";
+import { Directory } from "../../../contracts/utilities/Directory.sol";
+
+contract IndexingAgreementTest is Test {
+    IndexingAgreement.StorageManager private _storageManager;
+    address private _mockCollector;
+
+    function setUp() public {
+        _mockCollector = makeAddr("mockCollector");
+    }
+
+    function test_IndexingAgreement_Get(bytes16 agreementId) public {
+        vm.assume(agreementId != bytes16(0));
+
+        vm.mockCall(
+            address(this),
+            abi.encodeWithSelector(Directory.recurringCollector.selector),
+            abi.encode(IRecurringCollector(_mockCollector))
+        );
+
+        IRecurringCollector.AgreementData memory collectorAgreement;
+        vm.mockCall(
+            _mockCollector,
+            abi.encodeWithSelector(IRecurringCollector.getAgreement.selector, agreementId),
+            abi.encode(collectorAgreement)
+        );
+
+        vm.expectRevert(abi.encodeWithSelector(IndexingAgreement.IndexingAgreementNotActive.selector, agreementId));
+        IndexingAgreement.get(_storageManager, agreementId);
+
+        collectorAgreement.dataService = address(this);
+        vm.mockCall(
+            _mockCollector,
+            abi.encodeWithSelector(IRecurringCollector.getAgreement.selector, agreementId),
+            abi.encode(collectorAgreement)
+        );
+
+        IIndexingAgreement.AgreementWrapper memory wrapper = IndexingAgreement.get(_storageManager, agreementId);
+        assertEq(wrapper.collectorAgreement.dataService, address(this));
+    }
+
+    function test_IndexingAgreement_OnCloseAllocation(bytes16 agreementId, address allocationId, bool stale) public {
+        vm.assume(agreementId != bytes16(0));
+        vm.assume(allocationId != address(0));
+
+        delete _storageManager;
+        vm.clearMockedCalls();
+
+        // No active agreement for allocation ID, returns early, no assertions needed
+        IndexingAgreement.onCloseAllocation(_storageManager, allocationId, stale);
+
+        // Active agreement for allocation ID, but collector agreement is not set, returns early, no assertions needed
+        _storageManager.allocationToActiveAgreementId[allocationId] = agreementId;
+
+        IRecurringCollector.AgreementData memory collectorAgreement;
+
+        vm.mockCall(
+            address(this),
+            abi.encodeWithSelector(Directory.recurringCollector.selector),
+            abi.encode(IRecurringCollector(_mockCollector))
+        );
+
+        vm.mockCall(
+            _mockCollector,
+            abi.encodeWithSelector(IRecurringCollector.getAgreement.selector, agreementId),
+            abi.encode(collectorAgreement)
+        );
+
+        IndexingAgreement.onCloseAllocation(_storageManager, allocationId, stale);
+
+        // Active agreement for allocation ID, collector agreement is set, should cancel the agreement
+        collectorAgreement.dataService = address(this);
+        collectorAgreement.state = IRecurringCollector.AgreementState.Accepted;
+
+        _storageManager.agreements[agreementId] = IIndexingAgreement.State({
+            allocationId: allocationId,
+            version: IIndexingAgreement.IndexingAgreementVersion.V1
+        });
+
+        vm.mockCall(
+            _mockCollector,
+            abi.encodeWithSelector(IRecurringCollector.getAgreement.selector, agreementId),
+            abi.encode(collectorAgreement)
+        );
+
+        vm.expectCall(_mockCollector, abi.encodeWithSelector(IRecurringCollector.cancel.selector, agreementId));
+
+        IndexingAgreement.onCloseAllocation(_storageManager, allocationId, stale);
+    }
+
+    function test_IndexingAgreement_StorageManagerLocation() public pure {
+        assertEq(
+            IndexingAgreement.INDEXING_AGREEMENT_STORAGE_MANAGER_LOCATION,
+            keccak256(
+                abi.encode(
+                    uint256(keccak256("graphprotocol.subgraph-service.storage.StorageManager.IndexingAgreement")) - 1
+                )
+            ) & ~bytes32(uint256(0xff))
+        );
+    }
+}
diff --git a/packages/subgraph-service/test/unit/libraries/LegacyAllocationLibrary.t.sol b/packages/subgraph-service/test/unit/libraries/LegacyAllocationLibrary.t.sol
deleted file mode 100644
index 5cb34703e..000000000
--- a/packages/subgraph-service/test/unit/libraries/LegacyAllocationLibrary.t.sol
+++ /dev/null
@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.27;
-
-import { Test } from "forge-std/Test.sol";
-import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
-import { LegacyAllocationHarness } from "../mocks/LegacyAllocationHarness.sol";
-
-contract LegacyAllocationLibraryTest is Test {
-    LegacyAllocationHarness private harness;
-    address private allocationId;
-
-    function setUp() public {
-        harness = new LegacyAllocationHarness();
-        allocationId = makeAddr("allocationId");
-    }
-
-    function test_LegacyAllocation_Get() public {
-        // forge-lint: disable-next-line(unsafe-typecast)
-        harness.migrate(address(1), allocationId, bytes32("sdid"));
-
-        ILegacyAllocation.State memory alloc = harness.get(allocationId);
-        assertEq(alloc.indexer, address(1));
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(alloc.subgraphDeploymentId, bytes32("sdid"));
-    }
-
-    function test_LegacyAllocation_Get_RevertWhen_NotExists() public {
-        address nonExistent = makeAddr("nonExistent");
-        vm.expectRevert(abi.encodeWithSelector(ILegacyAllocation.LegacyAllocationDoesNotExist.selector, nonExistent));
-        harness.get(nonExistent);
-    }
-}
diff --git a/packages/subgraph-service/test/unit/mocks/LegacyAllocationHarness.sol b/packages/subgraph-service/test/unit/mocks/LegacyAllocationHarness.sol
deleted file mode 100644
index 30b4147aa..000000000
--- a/packages/subgraph-service/test/unit/mocks/LegacyAllocationHarness.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.27;
-
-import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
-import { LegacyAllocation } from "../../../contracts/libraries/LegacyAllocation.sol";
-
-/// @notice Test harness to exercise LegacyAllocation library guard branches directly
-contract LegacyAllocationHarness {
-    using LegacyAllocation for mapping(address => ILegacyAllocation.State);
-
-    mapping(address => ILegacyAllocation.State) private _legacyAllocations;
-
-    function migrate(address indexer, address allocationId, bytes32 subgraphDeploymentId) external {
-        _legacyAllocations.migrate(indexer, allocationId, subgraphDeploymentId);
-    }
-
-    function get(address allocationId) external view returns (ILegacyAllocation.State memory) {
-        return _legacyAllocations.get(allocationId);
-    }
-}
diff --git a/packages/subgraph-service/test/unit/shared/HorizonStakingShared.t.sol b/packages/subgraph-service/test/unit/shared/HorizonStakingShared.t.sol
index 093890d3c..c48622106 100644
--- a/packages/subgraph-service/test/unit/shared/HorizonStakingShared.t.sol
+++ b/packages/subgraph-service/test/unit/shared/HorizonStakingShared.t.sol
@@ -3,7 +3,6 @@ pragma solidity ^0.8.27;
 
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingTypes.sol";
-import { IHorizonStakingExtension } from "@graphprotocol/interfaces/contracts/horizon/internal/IHorizonStakingExtension.sol";
 
 import { SubgraphBaseTest } from "../SubgraphBaseTest.t.sol";
 
@@ -36,6 +35,12 @@ abstract contract HorizonStakingSharedTest is SubgraphBaseTest {
         staking.addToProvision(_indexer, address(subgraphService), _tokens);
     }
 
+    function _removeFromProvision(address _indexer, uint256 _tokens) internal {
+        staking.thaw(_indexer, address(subgraphService), _tokens);
+        skip(staking.getProvision(_indexer, address(subgraphService)).thawingPeriod + 1);
+        staking.deprovision(_indexer, address(subgraphService), 0);
+    }
+
     function _delegate(address _indexer, address _verifier, uint256 _tokens, uint256 _minSharesOut) internal {
         staking.delegate(_indexer, _verifier, _tokens, _minSharesOut);
     }
@@ -75,68 +80,6 @@ abstract contract HorizonStakingSharedTest is SubgraphBaseTest {
         staking.setProvisionParameters(_indexer, _verifier, _maxVerifierCut, _thawingPeriod);
     }
 
-    function _setStorageAllocationHardcoded(address indexer, address allocationId, uint256 tokens) internal {
-        IHorizonStakingExtension.Allocation memory allocation = IHorizonStakingExtension.Allocation({
-            indexer: indexer,
-            // forge-lint: disable-next-line(unsafe-typecast)
-            subgraphDeploymentID: bytes32("0x12344321"),
-            tokens: tokens,
-            createdAtEpoch: 1234,
-            closedAtEpoch: 1235,
-            collectedFees: 1234,
-            __DEPRECATED_effectiveAllocation: 1222234,
-            accRewardsPerAllocatedToken: 1233334,
-            distributedRebates: 1244434
-        });
-
-        // __DEPRECATED_allocations
-        uint256 allocationsSlot = 15;
-        bytes32 allocationBaseSlot = keccak256(abi.encode(allocationId, allocationsSlot));
-        vm.store(address(staking), allocationBaseSlot, bytes32(uint256(uint160(allocation.indexer))));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 1), allocation.subgraphDeploymentID);
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 2), bytes32(tokens));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 3), bytes32(allocation.createdAtEpoch));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 4), bytes32(allocation.closedAtEpoch));
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 5), bytes32(allocation.collectedFees));
-        vm.store(
-            address(staking),
-            bytes32(uint256(allocationBaseSlot) + 6),
-            bytes32(allocation.__DEPRECATED_effectiveAllocation)
-        );
-        vm.store(
-            address(staking),
-            bytes32(uint256(allocationBaseSlot) + 7),
-            bytes32(allocation.accRewardsPerAllocatedToken)
-        );
-        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 8), bytes32(allocation.distributedRebates));
-
-        // _serviceProviders
-        uint256 serviceProviderSlot = 14;
-        bytes32 serviceProviderBaseSlot = keccak256(abi.encode(allocation.indexer, serviceProviderSlot));
-        uint256 currentTokensStaked = uint256(vm.load(address(staking), serviceProviderBaseSlot));
-        uint256 currentTokensProvisioned = uint256(
-            vm.load(address(staking), bytes32(uint256(serviceProviderBaseSlot) + 1))
-        );
-        vm.store(
-            address(staking),
-            bytes32(uint256(serviceProviderBaseSlot) + 0),
-            bytes32(currentTokensStaked + tokens)
-        );
-        vm.store(
-            address(staking),
-            bytes32(uint256(serviceProviderBaseSlot) + 1),
-            bytes32(currentTokensProvisioned + tokens)
-        );
-
-        // __DEPRECATED_subgraphAllocations
-        uint256 subgraphsAllocationsSlot = 16;
-        bytes32 subgraphAllocationsBaseSlot = keccak256(
-            abi.encode(allocation.subgraphDeploymentID, subgraphsAllocationsSlot)
-        );
-        uint256 currentAllocatedTokens = uint256(vm.load(address(staking), subgraphAllocationsBaseSlot));
-        vm.store(address(staking), subgraphAllocationsBaseSlot, bytes32(currentAllocatedTokens + tokens));
-    }
-
     function _stakeTo(address _indexer, uint256 _tokens) internal {
         token.approve(address(staking), _tokens);
         staking.stakeTo(_indexer, _tokens);
diff --git a/packages/subgraph-service/test/unit/subgraphService/SubgraphService.t.sol b/packages/subgraph-service/test/unit/subgraphService/SubgraphService.t.sol
index bd3091935..5002900f1 100644
--- a/packages/subgraph-service/test/unit/subgraphService/SubgraphService.t.sol
+++ b/packages/subgraph-service/test/unit/subgraphService/SubgraphService.t.sol
@@ -8,12 +8,12 @@ import { IHorizonStakingTypes } from "@graphprotocol/interfaces/contracts/horizo
 import { IGraphTallyCollector } from "@graphprotocol/interfaces/contracts/horizon/IGraphTallyCollector.sol";
 import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { LinkedList } from "@graphprotocol/horizon/contracts/libraries/LinkedList.sol";
-import { IDataServiceFees } from "@graphprotocol/interfaces/contracts/data-service/IDataServiceFees.sol";
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
 import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
 import { IAllocationManager } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol";
 import { ILinkedList } from "@graphprotocol/interfaces/contracts/horizon/internal/ILinkedList.sol";
 import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
+import { StakeClaims } from "@graphprotocol/horizon/contracts/data-service/libraries/StakeClaims.sol";
 
 import { Allocation } from "../../../contracts/libraries/Allocation.sol";
 import { SubgraphServiceSharedTest } from "../shared/SubgraphServiceShared.t.sol";
@@ -202,7 +202,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         uint256 paymentCollected = 0;
         address allocationId;
         IndexingRewardsData memory indexingRewardsData;
-        CollectPaymentData memory collectPaymentDataBefore = _collectPaymentDataBefore(_indexer);
+        CollectPaymentData memory collectPaymentDataBefore = _collectPaymentData(_indexer);
 
         if (_paymentType == IGraphPayments.PaymentTypes.QueryFee) {
             paymentCollected = _handleQueryFeeCollection(_indexer, _data);
@@ -216,7 +216,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         // collect rewards
         subgraphService.collect(_indexer, _paymentType, _data);
 
-        CollectPaymentData memory collectPaymentDataAfter = _collectPaymentDataAfter(_indexer);
+        CollectPaymentData memory collectPaymentDataAfter = _collectPaymentData(_indexer);
 
         if (_paymentType == IGraphPayments.PaymentTypes.QueryFee) {
             _verifyQueryFeeCollection(
@@ -237,42 +237,24 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         }
     }
 
-    function _collectPaymentDataBefore(address _indexer) private view returns (CollectPaymentData memory) {
+    function _collectPaymentData(
+        address _indexer
+    ) internal view returns (CollectPaymentData memory collectPaymentData) {
         address paymentsDestination = subgraphService.paymentsDestination(_indexer);
-        CollectPaymentData memory collectPaymentDataBefore;
-        collectPaymentDataBefore.rewardsDestinationBalance = token.balanceOf(paymentsDestination);
-        collectPaymentDataBefore.indexerProvisionBalance = staking.getProviderTokensAvailable(
+        collectPaymentData.rewardsDestinationBalance = token.balanceOf(paymentsDestination);
+        collectPaymentData.indexerProvisionBalance = staking.getProviderTokensAvailable(
             _indexer,
             address(subgraphService)
         );
-        collectPaymentDataBefore.delegationPoolBalance = staking.getDelegatedTokensAvailable(
+        collectPaymentData.delegationPoolBalance = staking.getDelegatedTokensAvailable(
             _indexer,
             address(subgraphService)
         );
-        collectPaymentDataBefore.indexerBalance = token.balanceOf(_indexer);
-        collectPaymentDataBefore.curationBalance = token.balanceOf(address(curation));
-        collectPaymentDataBefore.lockedTokens = subgraphService.feesProvisionTracker(_indexer);
-        collectPaymentDataBefore.indexerStake = staking.getStake(_indexer);
-        return collectPaymentDataBefore;
-    }
-
-    function _collectPaymentDataAfter(address _indexer) private view returns (CollectPaymentData memory) {
-        CollectPaymentData memory collectPaymentDataAfter;
-        address paymentsDestination = subgraphService.paymentsDestination(_indexer);
-        collectPaymentDataAfter.rewardsDestinationBalance = token.balanceOf(paymentsDestination);
-        collectPaymentDataAfter.indexerProvisionBalance = staking.getProviderTokensAvailable(
-            _indexer,
-            address(subgraphService)
-        );
-        collectPaymentDataAfter.delegationPoolBalance = staking.getDelegatedTokensAvailable(
-            _indexer,
-            address(subgraphService)
-        );
-        collectPaymentDataAfter.indexerBalance = token.balanceOf(_indexer);
-        collectPaymentDataAfter.curationBalance = token.balanceOf(address(curation));
-        collectPaymentDataAfter.lockedTokens = subgraphService.feesProvisionTracker(_indexer);
-        collectPaymentDataAfter.indexerStake = staking.getStake(_indexer);
-        return collectPaymentDataAfter;
+        collectPaymentData.indexerBalance = token.balanceOf(_indexer);
+        collectPaymentData.curationBalance = token.balanceOf(address(curation));
+        collectPaymentData.lockedTokens = subgraphService.feesProvisionTracker(_indexer);
+        collectPaymentData.indexerStake = staking.getStake(_indexer);
+        return collectPaymentData;
     }
 
     function _handleQueryFeeCollection(
@@ -423,7 +405,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         // Check the stake claim
         ILinkedList.List memory claimsList = _getClaimList(_indexer);
         bytes32 claimId = _buildStakeClaimId(_indexer, claimsList.nonce - 1);
-        IDataServiceFees.StakeClaim memory stakeClaim = _getStakeClaim(claimId);
+        StakeClaims.StakeClaim memory stakeClaim = _getStakeClaim(claimId);
         uint64 disputePeriod = disputeManager.getDisputePeriod();
         assertEq(stakeClaim.tokens, tokensToLock);
         assertEq(stakeClaim.createdAt, block.timestamp);
@@ -494,16 +476,61 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
     }
 
     function _migrateLegacyAllocation(address _indexer, address _allocationId, bytes32 _subgraphDeploymentId) internal {
-        vm.expectEmit(address(subgraphService));
-        emit IAllocationManager.LegacyAllocationMigrated(_indexer, _allocationId, _subgraphDeploymentId);
+        // migrate fn was removed, we simulate history by manually setting the storage state
+        uint256 legacyAllocationsSlot = 208;
+        bytes32 legacyAllocationBaseSlot = keccak256(abi.encode(_allocationId, legacyAllocationsSlot));
 
-        subgraphService.migrateLegacyAllocation(_indexer, _allocationId, _subgraphDeploymentId);
+        vm.store(address(subgraphService), legacyAllocationBaseSlot, bytes32(uint256(uint160(_indexer))));
+        vm.store(
+            address(subgraphService),
+            bytes32(uint256(legacyAllocationBaseSlot) + 1),
+            bytes32(_subgraphDeploymentId)
+        );
 
         ILegacyAllocation.State memory afterLegacyAllocation = subgraphService.getLegacyAllocation(_allocationId);
         assertEq(afterLegacyAllocation.indexer, _indexer);
         assertEq(afterLegacyAllocation.subgraphDeploymentId, _subgraphDeploymentId);
     }
 
+    /**
+     * @notice Sets a legacy allocation directly in HorizonStaking storage
+     * @dev The __DEPRECATED_allocations mapping is at storage slot 15 in HorizonStaking
+     * Use `forge inspect HorizonStaking storage-layout` to verify
+     * The LegacyAllocation struct has the following layout:
+     * - slot 0: indexer (address)
+     * - slot 1: subgraphDeploymentID (bytes32)
+     * - slot 2: tokens (uint256)
+     * - slot 3: createdAtEpoch (uint256)
+     * - slot 4: closedAtEpoch (uint256)
+     * - slot 5: collectedFees (uint256)
+     * - slot 6: __DEPRECATED_effectiveAllocation (uint256)
+     * - slot 7: accRewardsPerAllocatedToken (uint256)
+     * - slot 8: distributedRebates (uint256)
+     */
+    function _setLegacyAllocationInStaking(
+        address _allocationId,
+        address _indexer,
+        bytes32 _subgraphDeploymentId
+    ) internal {
+        // Storage slot for __DEPRECATED_allocations mapping in HorizonStaking
+        uint256 allocationsSlot = 15;
+        bytes32 allocationBaseSlot = keccak256(abi.encode(_allocationId, allocationsSlot));
+
+        // Set indexer (slot 0)
+        vm.store(address(staking), allocationBaseSlot, bytes32(uint256(uint160(_indexer))));
+        // Set subgraphDeploymentID (slot 1)
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 1), _subgraphDeploymentId);
+        // Set tokens (slot 2) - non-zero to indicate active allocation
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 2), bytes32(uint256(1000 ether)));
+        // Set createdAtEpoch (slot 3) - non-zero
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 3), bytes32(uint256(1)));
+        // Set closedAtEpoch (slot 4) - non-zero to indicate closed
+        vm.store(address(staking), bytes32(uint256(allocationBaseSlot) + 4), bytes32(uint256(10)));
+
+        // Verify the allocation is now visible via isAllocation
+        assertTrue(staking.isAllocation(_allocationId));
+    }
+
     /*
      * HELPERS
      */
@@ -540,12 +567,12 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
     }
 
     function _buildStakeClaimId(address _indexer, uint256 _nonce) private view returns (bytes32) {
-        return keccak256(abi.encodePacked(address(subgraphService), _indexer, _nonce));
+        return StakeClaims.buildStakeClaimId(address(subgraphService), _indexer, _nonce);
     }
 
-    function _getStakeClaim(bytes32 _claimId) private view returns (IDataServiceFees.StakeClaim memory) {
+    function _getStakeClaim(bytes32 _claimId) private view returns (StakeClaims.StakeClaim memory) {
         (uint256 tokens, uint256 createdAt, uint256 releasableAt, bytes32 nextClaim) = subgraphService.claims(_claimId);
-        return IDataServiceFees.StakeClaim(tokens, createdAt, releasableAt, nextClaim);
+        return StakeClaims.StakeClaim(tokens, createdAt, releasableAt, nextClaim);
     }
 
     // This doesn't matter for testing because the metadata is not decoded onchain but it's expected to be of the form:
diff --git a/packages/subgraph-service/test/unit/subgraphService/allocation/resize.t.sol b/packages/subgraph-service/test/unit/subgraphService/allocation/resize.t.sol
index 40635570e..7b33537d2 100644
--- a/packages/subgraph-service/test/unit/subgraphService/allocation/resize.t.sol
+++ b/packages/subgraph-service/test/unit/subgraphService/allocation/resize.t.sol
@@ -3,7 +3,7 @@ pragma solidity ^0.8.27;
 
 import { SubgraphServiceTest } from "../SubgraphService.t.sol";
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
-import { IAllocationManager } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol";
+import { AllocationHandler } from "../../../../contracts/libraries/AllocationHandler.sol";
 import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 
@@ -85,11 +85,7 @@ contract SubgraphServiceAllocationResizeTest is SubgraphServiceTest {
         uint256 tokens
     ) public useIndexer useAllocation(tokens) {
         vm.expectRevert(
-            abi.encodeWithSelector(
-                IAllocationManager.AllocationManagerAllocationSameSize.selector,
-                allocationId,
-                tokens
-            )
+            abi.encodeWithSelector(AllocationHandler.AllocationHandlerAllocationSameSize.selector, allocationId, tokens)
         );
         subgraphService.resizeAllocation(users.indexer, allocationId, tokens);
     }
@@ -102,7 +98,7 @@ contract SubgraphServiceAllocationResizeTest is SubgraphServiceTest {
         bytes memory data = abi.encode(allocationId);
         _stopService(users.indexer, data);
         vm.expectRevert(
-            abi.encodeWithSelector(IAllocationManager.AllocationManagerAllocationClosed.selector, allocationId)
+            abi.encodeWithSelector(AllocationHandler.AllocationHandlerAllocationClosed.selector, allocationId)
         );
         subgraphService.resizeAllocation(users.indexer, allocationId, resizeTokens);
     }
diff --git a/packages/subgraph-service/test/unit/subgraphService/allocation/start.t.sol b/packages/subgraph-service/test/unit/subgraphService/allocation/start.t.sol
index 0896e9473..68c3c6674 100644
--- a/packages/subgraph-service/test/unit/subgraphService/allocation/start.t.sol
+++ b/packages/subgraph-service/test/unit/subgraphService/allocation/start.t.sol
@@ -5,7 +5,7 @@ import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { ProvisionManager } from "@graphprotocol/horizon/contracts/data-service/utilities/ProvisionManager.sol";
 import { ProvisionTracker } from "@graphprotocol/horizon/contracts/data-service/libraries/ProvisionTracker.sol";
 import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
-import { IAllocationManager } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol";
+import { AllocationHandler } from "../../../../contracts/libraries/AllocationHandler.sol";
 import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
 import { SubgraphServiceTest } from "../SubgraphService.t.sol";
@@ -94,7 +94,7 @@ contract SubgraphServiceAllocationStartTest is SubgraphServiceTest {
         bytes32 digest = subgraphService.encodeAllocationProof(users.indexer, address(0));
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(allocationIdPrivateKey, digest);
         bytes memory data = abi.encode(subgraphDeployment, tokens, address(0), abi.encodePacked(r, s, v));
-        vm.expectRevert(abi.encodeWithSelector(IAllocationManager.AllocationManagerInvalidZeroAllocationId.selector));
+        vm.expectRevert(abi.encodeWithSelector(AllocationHandler.AllocationHandlerInvalidZeroAllocationId.selector));
         subgraphService.startService(users.indexer, data);
     }
 
@@ -110,7 +110,7 @@ contract SubgraphServiceAllocationStartTest is SubgraphServiceTest {
         bytes memory data = abi.encode(subgraphDeployment, tokens, allocationId, abi.encodePacked(r, s, v));
         vm.expectRevert(
             abi.encodeWithSelector(
-                IAllocationManager.AllocationManagerInvalidAllocationProof.selector,
+                AllocationHandler.AllocationHandlerInvalidAllocationProof.selector,
                 signer,
                 allocationId
             )
@@ -165,8 +165,9 @@ contract SubgraphServiceAllocationStartTest is SubgraphServiceTest {
         _createProvision(users.indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
         _register(users.indexer, abi.encode("url", "geoHash", address(0)));
 
-        // create dummy allo in staking contract
-        _setStorageAllocationHardcoded(users.indexer, allocationId, tokens);
+        // Set a legacy allocation directly in HorizonStaking storage
+        // This simulates an allocation that was created before Horizon and exists in the staking contract
+        _setLegacyAllocationInStaking(allocationId, users.indexer, subgraphDeployment);
 
         bytes memory data = _generateData(tokens);
         vm.expectRevert(abi.encodeWithSelector(ILegacyAllocation.LegacyAllocationAlreadyExists.selector, allocationId));
diff --git a/packages/subgraph-service/test/unit/subgraphService/collect/collect.t.sol b/packages/subgraph-service/test/unit/subgraphService/collect/collect.t.sol
index e77942714..982d7fe83 100644
--- a/packages/subgraph-service/test/unit/subgraphService/collect/collect.t.sol
+++ b/packages/subgraph-service/test/unit/subgraphService/collect/collect.t.sol
@@ -3,7 +3,7 @@ pragma solidity ^0.8.27;
 
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 
-import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
+import { IndexingAgreementDecoder } from "../../../../contracts/libraries/IndexingAgreementDecoder.sol";
 import { SubgraphServiceTest } from "../SubgraphService.t.sol";
 
 contract SubgraphServiceCollectTest is SubgraphServiceTest {
@@ -14,10 +14,14 @@ contract SubgraphServiceCollectTest is SubgraphServiceTest {
     function test_SubgraphService_Collect_RevertWhen_InvalidPayment(
         uint256 tokens
     ) public useIndexer useAllocation(tokens) {
-        IGraphPayments.PaymentTypes invalidPaymentType = IGraphPayments.PaymentTypes.IndexingFee;
+        IGraphPayments.PaymentTypes paymentType = IGraphPayments.PaymentTypes.IndexingFee;
         vm.expectRevert(
-            abi.encodeWithSelector(ISubgraphService.SubgraphServiceInvalidPaymentType.selector, invalidPaymentType)
+            abi.encodeWithSelector(
+                IndexingAgreementDecoder.IndexingAgreementDecoderInvalidData.selector,
+                "decodeCollectData",
+                ""
+            )
         );
-        subgraphService.collect(users.indexer, invalidPaymentType, "");
+        subgraphService.collect(users.indexer, paymentType, "");
     }
 }
diff --git a/packages/subgraph-service/test/unit/subgraphService/collect/indexing/indexing.t.sol b/packages/subgraph-service/test/unit/subgraphService/collect/indexing/indexing.t.sol
index 94f11e0e5..49c034e52 100644
--- a/packages/subgraph-service/test/unit/subgraphService/collect/indexing/indexing.t.sol
+++ b/packages/subgraph-service/test/unit/subgraphService/collect/indexing/indexing.t.sol
@@ -2,7 +2,7 @@
 pragma solidity ^0.8.27;
 
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
-import { IAllocationManager } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol";
+import { AllocationHandler } from "../../../../../contracts/libraries/AllocationHandler.sol";
 import { IRewardsManager } from "@graphprotocol/interfaces/contracts/contracts/rewards/IRewardsManager.sol";
 
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
@@ -270,7 +270,7 @@ contract SubgraphServiceCollectIndexingTest is SubgraphServiceTest {
 
         // Attempt to collect on closed allocation should revert
         vm.expectRevert(
-            abi.encodeWithSelector(IAllocationManager.AllocationManagerAllocationClosed.selector, allocationId)
+            abi.encodeWithSelector(AllocationHandler.AllocationHandlerAllocationClosed.selector, allocationId)
         );
         subgraphService.collect(users.indexer, paymentType, data);
     }
diff --git a/packages/subgraph-service/test/unit/subgraphService/collect/query/query.t.sol b/packages/subgraph-service/test/unit/subgraphService/collect/query/query.t.sol
index 4915ac17f..76fae1307 100644
--- a/packages/subgraph-service/test/unit/subgraphService/collect/query/query.t.sol
+++ b/packages/subgraph-service/test/unit/subgraphService/collect/query/query.t.sol
@@ -21,7 +21,7 @@ contract SubgraphServiceRegisterTest is SubgraphServiceTest {
      * HELPERS
      */
 
-    function _getSignerProof(uint256 _proofDeadline, uint256 _signer) private view returns (bytes memory) {
+    function _getSignerProof(uint256 _proofDeadline, uint256 _signer) private returns (bytes memory) {
         (, address msgSender, ) = vm.readCallers();
         bytes32 messageHash = keccak256(
             abi.encodePacked(
diff --git a/packages/subgraph-service/test/unit/subgraphService/governance/legacy.t.sol b/packages/subgraph-service/test/unit/subgraphService/governance/legacy.t.sol
deleted file mode 100644
index 65aadf2a5..000000000
--- a/packages/subgraph-service/test/unit/subgraphService/governance/legacy.t.sol
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.27;
-
-import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import { ILegacyAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/ILegacyAllocation.sol";
-
-import { SubgraphServiceTest } from "../SubgraphService.t.sol";
-
-contract SubgraphServiceLegacyAllocation is SubgraphServiceTest {
-    /*
-     * TESTS
-     */
-
-    function test_MigrateAllocation() public useGovernor {
-        _migrateLegacyAllocation(users.indexer, allocationId, subgraphDeployment);
-    }
-
-    function test_MigrateAllocation_WhenNotGovernor() public useIndexer {
-        vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, users.indexer));
-        subgraphService.migrateLegacyAllocation(users.indexer, allocationId, subgraphDeployment);
-    }
-
-    function test_MigrateAllocation_RevertWhen_AlreadyMigrated() public useGovernor {
-        _migrateLegacyAllocation(users.indexer, allocationId, subgraphDeployment);
-
-        vm.expectRevert(abi.encodeWithSelector(ILegacyAllocation.LegacyAllocationAlreadyExists.selector, allocationId));
-        subgraphService.migrateLegacyAllocation(users.indexer, allocationId, subgraphDeployment);
-    }
-}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/accept.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/accept.t.sol
new file mode 100644
index 000000000..fe4b8b805
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/accept.t.sol
@@ -0,0 +1,318 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
+import { ProvisionManager } from "@graphprotocol/horizon/contracts/data-service/utilities/ProvisionManager.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
+
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+import { IndexingAgreementDecoder } from "../../../../contracts/libraries/IndexingAgreementDecoder.sol";
+import { AllocationHandler } from "../../../../contracts/libraries/AllocationHandler.sol";
+import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
+
+import { SubgraphServiceIndexingAgreementSharedTest } from "./shared.t.sol";
+
+contract SubgraphServiceIndexingAgreementAcceptTest is SubgraphServiceIndexingAgreementSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenPaused(
+        address allocationId,
+        address operator,
+        IRecurringCollector.SignedRCA calldata signedRCA
+    ) public withSafeIndexerOrOperator(operator) {
+        resetPrank(users.pauseGuardian);
+        subgraphService.pause();
+
+        resetPrank(operator);
+        vm.expectRevert(PausableUpgradeable.EnforcedPause.selector);
+        subgraphService.acceptIndexingAgreement(allocationId, signedRCA);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenNotAuthorized(
+        address allocationId,
+        address operator,
+        IRecurringCollector.SignedRCA calldata signedRCA
+    ) public withSafeIndexerOrOperator(operator) {
+        vm.assume(operator != signedRCA.rca.serviceProvider);
+        resetPrank(operator);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerNotAuthorized.selector,
+            signedRCA.rca.serviceProvider,
+            operator
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.acceptIndexingAgreement(allocationId, signedRCA);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenInvalidProvision(
+        address indexer,
+        uint256 unboundedTokens,
+        address allocationId,
+        IRecurringCollector.SignedRCA memory signedRCA
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, 1, MINIMUM_PROVISION_TOKENS - 1);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+
+        signedRCA.rca.serviceProvider = indexer;
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerInvalidValue.selector,
+            "tokens",
+            tokens,
+            MINIMUM_PROVISION_TOKENS,
+            MAXIMUM_PROVISION_TOKENS
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.acceptIndexingAgreement(allocationId, signedRCA);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenIndexerNotRegistered(
+        address indexer,
+        uint256 unboundedTokens,
+        address allocationId,
+        IRecurringCollector.SignedRCA memory signedRCA
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, MINIMUM_PROVISION_TOKENS, MAX_TOKENS);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+        signedRCA.rca.serviceProvider = indexer;
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ISubgraphService.SubgraphServiceIndexerNotRegistered.selector,
+            indexer
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.acceptIndexingAgreement(allocationId, signedRCA);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenNotDataService(
+        Seed memory seed,
+        address incorrectDataService
+    ) public {
+        vm.assume(incorrectDataService != address(subgraphService));
+
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+        acceptable.rca.dataService = incorrectDataService;
+        IRecurringCollector.SignedRCA memory unacceptable = _recurringCollectorHelper.generateSignedRCA(
+            acceptable.rca,
+            ctx.payer.signerPrivateKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementWrongDataService.selector,
+            address(subgraphService),
+            unacceptable.rca.dataService
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, unacceptable);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenInvalidMetadata(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+        acceptable.rca.metadata = bytes("invalid");
+        IRecurringCollector.SignedRCA memory unacceptable = _recurringCollectorHelper.generateSignedRCA(
+            acceptable.rca,
+            ctx.payer.signerPrivateKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreementDecoder.IndexingAgreementDecoderInvalidData.selector,
+            "decodeRCAMetadata",
+            unacceptable.rca.metadata
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, unacceptable);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenInvalidAllocation(
+        Seed memory seed,
+        address invalidAllocationId
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IAllocation.AllocationDoesNotExist.selector,
+            invalidAllocationId
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(invalidAllocationId, acceptable);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenAllocationNotAuthorized(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerStateA = _withIndexer(ctx);
+        IndexerState memory indexerStateB = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptableA = _generateAcceptableSignedRCA(ctx, indexerStateA.addr);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ISubgraphService.SubgraphServiceAllocationNotAuthorized.selector,
+            indexerStateA.addr,
+            indexerStateB.allocationId
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(indexerStateA.addr);
+        subgraphService.acceptIndexingAgreement(indexerStateB.allocationId, acceptableA);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenAllocationClosed(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+
+        resetPrank(indexerState.addr);
+        subgraphService.stopService(indexerState.addr, abi.encode(indexerState.allocationId));
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            AllocationHandler.AllocationHandlerAllocationClosed.selector,
+            indexerState.allocationId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, acceptable);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenDeploymentIdMismatch(
+        Seed memory seed,
+        bytes32 wrongSubgraphDeploymentId
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        vm.assume(indexerState.subgraphDeploymentId != wrongSubgraphDeploymentId);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+        acceptable.rca.metadata = abi.encode(_newAcceptIndexingAgreementMetadataV1(wrongSubgraphDeploymentId));
+        IRecurringCollector.SignedRCA memory unacceptable = _recurringCollectorHelper.generateSignedRCA(
+            acceptable.rca,
+            ctx.payer.signerPrivateKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementDeploymentIdMismatch.selector,
+            wrongSubgraphDeploymentId,
+            indexerState.allocationId,
+            indexerState.subgraphDeploymentId
+        );
+        vm.expectRevert(expectedErr);
+        vm.prank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, unacceptable);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenAgreementAlreadyAccepted(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 agreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            indexerState
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementAlreadyAccepted.selector,
+            agreementId
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(ctx.indexers[0].addr);
+        subgraphService.acceptIndexingAgreement(ctx.indexers[0].allocationId, accepted);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenAgreementAlreadyAllocated(
+        Seed memory seed,
+        uint256 alternativeNonce
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+
+        // First, accept an indexing agreement on the allocation
+        (IRecurringCollector.SignedRCA memory accepted, ) = _withAcceptedIndexingAgreement(ctx, indexerState);
+        vm.assume(accepted.rca.nonce != alternativeNonce);
+
+        // Now try to accept a different agreement on the same allocation
+        // Create a new agreement with different nonce to ensure different agreement ID
+        IRecurringCollector.RecurringCollectionAgreement
+            memory newRCA = _generateAcceptableRecurringCollectionAgreement(ctx, indexerState.addr);
+        newRCA.nonce = alternativeNonce; // Different nonce to ensure different agreement ID
+
+        // Sign the new agreement
+        IRecurringCollector.SignedRCA memory newSignedRCA = _recurringCollectorHelper.generateSignedRCA(
+            newRCA,
+            ctx.payer.signerPrivateKey
+        );
+
+        // Expect the error when trying to accept a second agreement on the same allocation
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.AllocationAlreadyHasIndexingAgreement.selector,
+            indexerState.allocationId
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, newSignedRCA);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement_Revert_WhenInvalidTermsData(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+        IRecurringCollector.RecurringCollectionAgreement memory notAcceptableRCA = acceptable.rca;
+        bytes memory invalidTermsData = bytes("invalid terms data");
+        notAcceptableRCA.metadata = abi.encode(
+            _newAcceptIndexingAgreementMetadataV1Terms(indexerState.subgraphDeploymentId, invalidTermsData)
+        );
+        IRecurringCollector.SignedRCA memory notAcceptable = _recurringCollectorHelper.generateSignedRCA(
+            notAcceptableRCA,
+            ctx.payer.signerPrivateKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreementDecoder.IndexingAgreementDecoderInvalidData.selector,
+            "decodeIndexingAgreementTermsV1",
+            invalidTermsData
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, notAcceptable);
+    }
+
+    function test_SubgraphService_AcceptIndexingAgreement(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory acceptable = _generateAcceptableSignedRCA(ctx, indexerState.addr);
+        IndexingAgreement.AcceptIndexingAgreementMetadata memory metadata = abi.decode(
+            acceptable.rca.metadata,
+            (IndexingAgreement.AcceptIndexingAgreementMetadata)
+        );
+        // Generate deterministic agreement ID for event expectation
+        bytes16 expectedAgreementId = recurringCollector.generateAgreementId(
+            acceptable.rca.payer,
+            acceptable.rca.dataService,
+            acceptable.rca.serviceProvider,
+            acceptable.rca.deadline,
+            acceptable.rca.nonce
+        );
+
+        vm.expectEmit(address(subgraphService));
+        emit IndexingAgreement.IndexingAgreementAccepted(
+            acceptable.rca.serviceProvider,
+            acceptable.rca.payer,
+            expectedAgreementId,
+            indexerState.allocationId,
+            metadata.subgraphDeploymentId,
+            metadata.version,
+            metadata.terms
+        );
+
+        resetPrank(indexerState.addr);
+        subgraphService.acceptIndexingAgreement(indexerState.allocationId, acceptable);
+    }
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/base.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/base.t.sol
new file mode 100644
index 000000000..2fb1e1bc8
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/base.t.sol
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
+
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+import { SubgraphServiceIndexingAgreementSharedTest } from "./shared.t.sol";
+
+contract SubgraphServiceIndexingAgreementBaseTest is SubgraphServiceIndexingAgreementSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+    function test_SubgraphService_GetIndexingAgreement(
+        Seed memory seed,
+        address operator,
+        bytes16 fuzzyAgreementId
+    ) public {
+        vm.assume(_isSafeSubgraphServiceCaller(operator));
+
+        resetPrank(address(operator));
+
+        // Get unkown indexing agreement
+        vm.expectRevert(
+            abi.encodeWithSelector(IndexingAgreement.IndexingAgreementNotActive.selector, fuzzyAgreementId)
+        );
+        subgraphService.getIndexingAgreement(fuzzyAgreementId);
+
+        // Accept an indexing agreement
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 agreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            indexerState
+        );
+        IIndexingAgreement.AgreementWrapper memory agreement = subgraphService.getIndexingAgreement(agreementId);
+        _assertEqualAgreement(accepted.rca, agreement);
+    }
+
+    function test_SubgraphService_Revert_WhenUnsafeAddress_WhenProxyAdmin(address indexer, bytes16 agreementId) public {
+        address operator = _transparentUpgradeableProxyAdmin();
+        assertFalse(_isSafeSubgraphServiceCaller(operator));
+
+        vm.expectRevert(TransparentUpgradeableProxy.ProxyDeniedAdminAccess.selector);
+        resetPrank(address(operator));
+        subgraphService.cancelIndexingAgreement(indexer, agreementId);
+    }
+
+    function test_SubgraphService_Revert_WhenUnsafeAddress_WhenGraphProxyAdmin(uint256 unboundedTokens) public {
+        address indexer = GRAPH_PROXY_ADMIN_ADDRESS;
+        assertFalse(_isSafeSubgraphServiceCaller(indexer));
+
+        uint256 tokens = bound(unboundedTokens, MINIMUM_PROVISION_TOKENS, MAX_TOKENS);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        vm.expectRevert("Cannot fallback to proxy target");
+        staking.provision(indexer, address(subgraphService), tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/cancel.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/cancel.t.sol
new file mode 100644
index 000000000..c11c5549d
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/cancel.t.sol
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
+import { ProvisionManager } from "@graphprotocol/horizon/contracts/data-service/utilities/ProvisionManager.sol";
+
+import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+
+import { SubgraphServiceIndexingAgreementSharedTest } from "./shared.t.sol";
+
+contract SubgraphServiceIndexingAgreementCancelTest is SubgraphServiceIndexingAgreementSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+    function test_SubgraphService_CancelIndexingAgreementByPayer_Revert_WhenPaused(
+        address rando,
+        bytes16 agreementId
+    ) public withSafeIndexerOrOperator(rando) {
+        resetPrank(users.pauseGuardian);
+        subgraphService.pause();
+
+        vm.expectRevert(PausableUpgradeable.EnforcedPause.selector);
+        resetPrank(rando);
+        subgraphService.cancelIndexingAgreementByPayer(agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreementByPayer_Revert_WhenNotAuthorized(
+        Seed memory seed,
+        address rando
+    ) public withSafeIndexerOrOperator(rando) {
+        Context storage ctx = _newCtx(seed);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 agreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            _withIndexer(ctx)
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNonCancelableBy.selector,
+            accepted.rca.payer,
+            rando
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(rando);
+        subgraphService.cancelIndexingAgreementByPayer(agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreementByPayer_Revert_WhenNotAccepted(
+        Seed memory seed,
+        bytes16 agreementId
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+
+        resetPrank(indexerState.addr);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotActive.selector,
+            agreementId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreementByPayer(agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreementByPayer_Revert_WhenCanceled(
+        Seed memory seed,
+        bool cancelSource
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            indexerState
+        );
+        IRecurringCollector.CancelAgreementBy by = cancelSource
+            ? IRecurringCollector.CancelAgreementBy.ServiceProvider
+            : IRecurringCollector.CancelAgreementBy.Payer;
+        _cancelAgreement(ctx, acceptedAgreementId, indexerState.addr, accepted.rca.payer, by);
+
+        resetPrank(indexerState.addr);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotActive.selector,
+            acceptedAgreementId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreementByPayer(acceptedAgreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreementByPayer(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            _withIndexer(ctx)
+        );
+
+        _cancelAgreement(
+            ctx,
+            acceptedAgreementId,
+            accepted.rca.serviceProvider,
+            accepted.rca.payer,
+            IRecurringCollector.CancelAgreementBy.Payer
+        );
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_Revert_WhenPaused(
+        address operator,
+        address indexer,
+        bytes16 agreementId
+    ) public withSafeIndexerOrOperator(operator) {
+        resetPrank(users.pauseGuardian);
+        subgraphService.pause();
+
+        vm.expectRevert(PausableUpgradeable.EnforcedPause.selector);
+        resetPrank(operator);
+        subgraphService.cancelIndexingAgreement(indexer, agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_Revert_WhenNotAuthorized(
+        address operator,
+        address indexer,
+        bytes16 agreementId
+    ) public withSafeIndexerOrOperator(operator) {
+        vm.assume(operator != indexer);
+        resetPrank(operator);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerNotAuthorized.selector,
+            indexer,
+            operator
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreement(indexer, agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_Revert_WhenInvalidProvision(
+        address indexer,
+        bytes16 agreementId,
+        uint256 unboundedTokens
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, 1, MINIMUM_PROVISION_TOKENS - 1);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerInvalidValue.selector,
+            "tokens",
+            tokens,
+            MINIMUM_PROVISION_TOKENS,
+            MAXIMUM_PROVISION_TOKENS
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreement(indexer, agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_Revert_WhenIndexerNotRegistered(
+        address indexer,
+        bytes16 agreementId,
+        uint256 unboundedTokens
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, MINIMUM_PROVISION_TOKENS, MAX_TOKENS);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ISubgraphService.SubgraphServiceIndexerNotRegistered.selector,
+            indexer
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreement(indexer, agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_Revert_WhenNotAccepted(
+        Seed memory seed,
+        bytes16 agreementId
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+
+        resetPrank(indexerState.addr);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotActive.selector,
+            agreementId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreement(indexerState.addr, agreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_Revert_WhenCanceled(
+        Seed memory seed,
+        bool cancelSource
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            indexerState
+        );
+        IRecurringCollector.CancelAgreementBy by = cancelSource
+            ? IRecurringCollector.CancelAgreementBy.ServiceProvider
+            : IRecurringCollector.CancelAgreementBy.Payer;
+        _cancelAgreement(ctx, acceptedAgreementId, accepted.rca.serviceProvider, accepted.rca.payer, by);
+
+        resetPrank(indexerState.addr);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotActive.selector,
+            acceptedAgreementId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.cancelIndexingAgreement(indexerState.addr, acceptedAgreementId);
+    }
+
+    function test_SubgraphService_CancelIndexingAgreement_OK(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            _withIndexer(ctx)
+        );
+
+        _cancelAgreement(
+            ctx,
+            acceptedAgreementId,
+            accepted.rca.serviceProvider,
+            accepted.rca.payer,
+            IRecurringCollector.CancelAgreementBy.ServiceProvider
+        );
+    }
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/collect.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/collect.t.sol
new file mode 100644
index 000000000..1c514e2f7
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/collect.t.sol
@@ -0,0 +1,341 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IPaymentsCollector } from "@graphprotocol/interfaces/contracts/horizon/IPaymentsCollector.sol";
+import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
+import { ProvisionManager } from "@graphprotocol/horizon/contracts/data-service/utilities/ProvisionManager.sol";
+
+import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
+import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
+import { AllocationHandler } from "../../../../contracts/libraries/AllocationHandler.sol";
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+import { IndexingAgreementDecoder } from "../../../../contracts/libraries/IndexingAgreementDecoder.sol";
+
+import { SubgraphServiceIndexingAgreementSharedTest } from "./shared.t.sol";
+
+contract SubgraphServiceIndexingAgreementCollectTest is SubgraphServiceIndexingAgreementSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+    function test_SubgraphService_CollectIndexingFees_OK(
+        Seed memory seed,
+        uint256 entities,
+        bytes32 poi,
+        uint256 unboundedTokensCollected
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(
+            ctx,
+            indexerState
+        );
+
+        assertEq(subgraphService.feesProvisionTracker(indexerState.addr), 0, "Should be 0 before collect");
+
+        resetPrank(indexerState.addr);
+        subgraphService.setPaymentsDestination(indexerState.addr);
+
+        bytes memory data = abi.encode(
+            IRecurringCollector.CollectParams({
+                agreementId: acceptedAgreementId,
+                collectionId: bytes32(uint256(uint160(indexerState.allocationId))),
+                tokens: 0,
+                dataServiceCut: 0,
+                receiverDestination: indexerState.addr,
+                maxSlippage: type(uint256).max
+            })
+        );
+        uint256 tokensCollected = bound(unboundedTokensCollected, 1, indexerState.tokens / STAKE_TO_FEES_RATIO);
+
+        vm.mockCall(
+            address(recurringCollector),
+            abi.encodeWithSelector(IPaymentsCollector.collect.selector, IGraphPayments.PaymentTypes.IndexingFee, data),
+            abi.encode(tokensCollected)
+        );
+        _expectCollectCallAndEmit(data, indexerState, accepted, acceptedAgreementId, tokensCollected, entities, poi);
+
+        skip(1); // To make agreement collectable
+
+        subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(acceptedAgreementId, entities, poi, epochManager.currentEpochBlock(), bytes(""))
+        );
+
+        assertEq(
+            subgraphService.feesProvisionTracker(indexerState.addr),
+            tokensCollected * STAKE_TO_FEES_RATIO,
+            "Should be exactly locked tokens"
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Revert_WhenPaused(
+        address indexer,
+        bytes16 agreementId,
+        uint256 entities,
+        bytes32 poi
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+        resetPrank(users.pauseGuardian);
+        subgraphService.pause();
+
+        vm.expectRevert(PausableUpgradeable.EnforcedPause.selector);
+        resetPrank(indexer);
+        subgraphService.collect(
+            indexer,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(agreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Revert_WhenNotAuthorized(
+        address operator,
+        address indexer,
+        bytes16 agreementId,
+        uint256 entities,
+        bytes32 poi
+    ) public withSafeIndexerOrOperator(operator) {
+        vm.assume(operator != indexer);
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+        resetPrank(operator);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerNotAuthorized.selector,
+            indexer,
+            operator
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            indexer,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(agreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Revert_WhenInvalidProvision(
+        uint256 unboundedTokens,
+        address indexer,
+        bytes16 agreementId,
+        uint256 entities,
+        bytes32 poi
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, 1, MINIMUM_PROVISION_TOKENS - 1);
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerInvalidValue.selector,
+            "tokens",
+            tokens,
+            MINIMUM_PROVISION_TOKENS,
+            MAXIMUM_PROVISION_TOKENS
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            indexer,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(agreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Revert_WhenIndexerNotRegistered(
+        uint256 unboundedTokens,
+        address indexer,
+        bytes16 agreementId,
+        uint256 entities,
+        bytes32 poi
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, MINIMUM_PROVISION_TOKENS, MAX_TOKENS);
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ISubgraphService.SubgraphServiceIndexerNotRegistered.selector,
+            indexer
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            indexer,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(agreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Revert_WhenInvalidData(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+
+        bytes memory invalidData = bytes("invalid data");
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreementDecoder.IndexingAgreementDecoderInvalidData.selector,
+            "decodeCollectData",
+            invalidData
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerState.addr);
+        subgraphService.collect(indexerState.addr, IGraphPayments.PaymentTypes.IndexingFee, invalidData);
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Revert_WhenInvalidAgreement(
+        Seed memory seed,
+        bytes16 agreementId,
+        uint256 entities,
+        bytes32 poi
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+
+        bytes memory expectedErr = abi.encodeWithSelector(IAllocation.AllocationDoesNotExist.selector, address(0));
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerState.addr);
+        subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(agreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Reverts_WhenInvalidNestedData(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(ctx, indexerState);
+
+        resetPrank(indexerState.addr);
+
+        bytes memory invalidNestedData = bytes("invalid nested data");
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreementDecoder.IndexingAgreementDecoderInvalidData.selector,
+            "decodeCollectIndexingFeeDataV1",
+            invalidNestedData
+        );
+        vm.expectRevert(expectedErr);
+
+        skip(1); // To make agreement collectable
+
+        subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectData(acceptedAgreementId, invalidNestedData)
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Reverts_WhenIndexingAgreementNotAuthorized(
+        Seed memory seed,
+        uint256 entities,
+        bytes32 poi
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IndexerState memory otherIndexerState = _withIndexer(ctx);
+        (, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(ctx, indexerState);
+
+        vm.assume(otherIndexerState.addr != indexerState.addr);
+
+        resetPrank(otherIndexerState.addr);
+
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotAuthorized.selector,
+            acceptedAgreementId,
+            otherIndexerState.addr
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            otherIndexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(acceptedAgreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Reverts_WhenStopService(
+        Seed memory seed,
+        uint256 entities,
+        bytes32 poi
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(ctx, indexerState);
+
+        resetPrank(indexerState.addr);
+        subgraphService.stopService(indexerState.addr, abi.encode(indexerState.allocationId));
+
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            AllocationHandler.AllocationHandlerAllocationClosed.selector,
+            indexerState.allocationId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(acceptedAgreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    function test_SubgraphService_CollectIndexingFees_Reverts_WhenCloseStaleAllocation(
+        Seed memory seed,
+        uint256 entities,
+        bytes32 poi
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (, bytes16 acceptedAgreementId) = _withAcceptedIndexingAgreement(ctx, indexerState);
+
+        skip(MAX_POI_STALENESS + 1);
+        resetPrank(indexerState.addr);
+        subgraphService.closeStaleAllocation(indexerState.allocationId);
+
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            AllocationHandler.AllocationHandlerAllocationClosed.selector,
+            indexerState.allocationId
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(acceptedAgreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+
+    function _expectCollectCallAndEmit(
+        bytes memory _data,
+        IndexerState memory _indexerState,
+        IRecurringCollector.SignedRCA memory _accepted,
+        bytes16 _acceptedAgreementId,
+        uint256 _tokensCollected,
+        uint256 _entities,
+        bytes32 _poi
+    ) private {
+        vm.expectCall(
+            address(recurringCollector),
+            abi.encodeCall(IPaymentsCollector.collect, (IGraphPayments.PaymentTypes.IndexingFee, _data))
+        );
+        vm.expectEmit(address(subgraphService));
+        emit IndexingAgreement.IndexingFeesCollectedV1(
+            _indexerState.addr,
+            _accepted.rca.payer,
+            _acceptedAgreementId,
+            _indexerState.allocationId,
+            _indexerState.subgraphDeploymentId,
+            epochManager.currentEpoch(),
+            _tokensCollected,
+            _entities,
+            _poi,
+            epochManager.currentEpochBlock(),
+            bytes("")
+        );
+    }
+}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/integration.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/integration.t.sol
new file mode 100644
index 000000000..7aeea3b76
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/integration.t.sol
@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
+import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
+
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+
+import { SubgraphServiceIndexingAgreementSharedTest } from "./shared.t.sol";
+
+contract SubgraphServiceIndexingAgreementIntegrationTest is SubgraphServiceIndexingAgreementSharedTest {
+    using PPMMath for uint256;
+
+    struct TestState {
+        uint256 escrowBalance;
+        uint256 indexerBalance;
+        uint256 indexerTokensLocked;
+    }
+
+    struct ExpectedTokens {
+        uint256 expectedTotalTokensCollected;
+        uint256 expectedTokensLocked;
+        uint256 expectedProtocolTokensBurnt;
+        uint256 expectedIndexerTokensCollected;
+    }
+
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+    function test_SubgraphService_CollectIndexingFee_Integration(
+        Seed memory seed,
+        uint256 fuzzyTokensCollected
+    ) public {
+        // Setup
+        ExpectedTokens memory expectedTokens = _newExpectedTokens(fuzzyTokensCollected);
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        _addTokensToProvision(indexerState, expectedTokens.expectedTokensLocked);
+        IRecurringCollector.RecurringCollectionAgreement memory rca = _recurringCollectorHelper.sensibleRCA(
+            ctx.ctxInternal.seed.rca
+        );
+        bytes16 acceptedAgreementId = _sharedSetup(ctx, rca, indexerState, expectedTokens);
+
+        TestState memory beforeCollect = _getState(rca.payer, indexerState.addr);
+
+        // Collect
+        resetPrank(indexerState.addr);
+        uint256 tokensCollected = subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(
+                acceptedAgreementId,
+                1,
+                keccak256(abi.encodePacked("poi")),
+                epochManager.currentEpochBlock(),
+                bytes("")
+            )
+        );
+
+        TestState memory afterCollect = _getState(rca.payer, indexerState.addr);
+        _sharedAssert(beforeCollect, afterCollect, expectedTokens, tokensCollected);
+    }
+
+    function test_SubgraphService_CollectIndexingFee_WhenCanceledByPayer_Integration(
+        Seed memory seed,
+        uint256 fuzzyTokensCollected
+    ) public {
+        // Setup
+        ExpectedTokens memory expectedTokens = _newExpectedTokens(fuzzyTokensCollected);
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.RecurringCollectionAgreement memory rca = _recurringCollectorHelper.sensibleRCA(
+            ctx.ctxInternal.seed.rca
+        );
+        bytes16 acceptedAgreementId = _sharedSetup(ctx, rca, indexerState, expectedTokens);
+
+        // Cancel the indexing agreement by the payer
+        resetPrank(ctx.payer.signer);
+        subgraphService.cancelIndexingAgreementByPayer(acceptedAgreementId);
+
+        TestState memory beforeCollect = _getState(rca.payer, indexerState.addr);
+
+        // Collect
+        resetPrank(indexerState.addr);
+        uint256 tokensCollected = subgraphService.collect(
+            indexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(
+                acceptedAgreementId,
+                1,
+                keccak256(abi.encodePacked("poi")),
+                epochManager.currentEpochBlock(),
+                bytes("")
+            )
+        );
+
+        TestState memory afterCollect = _getState(rca.payer, indexerState.addr);
+        _sharedAssert(beforeCollect, afterCollect, expectedTokens, tokensCollected);
+    }
+
+    function test_SubgraphService_CollectIndexingRewards_CancelsAgreementWhenOverAllocated_Integration(
+        Seed memory seed
+    ) public {
+        // Setup context and indexer with active agreement
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (, bytes16 agreementId) = _withAcceptedIndexingAgreement(ctx, indexerState);
+
+        // Ensure enough gap so that reward distribution (1% of tokens) doesn't undo the over-allocation
+        vm.assume(indexerState.tokens > MINIMUM_PROVISION_TOKENS * 2);
+
+        // Reduce indexer's provision to force over-allocation after collecting rewards
+        uint256 extraTokens = indexerState.tokens - MINIMUM_PROVISION_TOKENS;
+        _removeTokensFromProvision(indexerState, extraTokens);
+
+        // Verify indexer will be over-allocated after presenting POI
+        assertTrue(subgraphService.isOverAllocated(indexerState.addr));
+
+        // Advance past allocation creation epoch so POI is not considered "too young"
+        vm.roll(block.number + EPOCH_LENGTH);
+
+        // Collect indexing rewards - this should trigger allocation closure and agreement cancellation
+        bytes memory collectData = abi.encode(indexerState.allocationId, keccak256("poi"), bytes("metadata"));
+        resetPrank(indexerState.addr);
+        subgraphService.collect(indexerState.addr, IGraphPayments.PaymentTypes.IndexingRewards, collectData);
+
+        // Verify the indexing agreement was properly cancelled
+        IIndexingAgreement.AgreementWrapper memory agreement = subgraphService.getIndexingAgreement(agreementId);
+        assertEq(
+            uint8(agreement.collectorAgreement.state),
+            uint8(IRecurringCollector.AgreementState.CanceledByServiceProvider)
+        );
+    }
+
+    /* solhint-enable graph/func-name-mixedcase */
+
+    function _sharedSetup(
+        Context storage _ctx,
+        IRecurringCollector.RecurringCollectionAgreement memory _rca,
+        IndexerState memory _indexerState,
+        ExpectedTokens memory _expectedTokens
+    ) internal returns (bytes16) {
+        _addTokensToProvision(_indexerState, _expectedTokens.expectedTokensLocked);
+
+        IndexingAgreement.IndexingAgreementTermsV1 memory terms = IndexingAgreement.IndexingAgreementTermsV1({
+            tokensPerSecond: 1,
+            tokensPerEntityPerSecond: 0 // no payment for entities
+        });
+        _rca.deadline = uint64(block.timestamp); // accept now
+        _rca.endsAt = type(uint64).max; // no expiration
+        _rca.maxInitialTokens = 0; // no initial payment
+        _rca.maxOngoingTokensPerSecond = type(uint32).max; // unlimited tokens per second
+        _rca.minSecondsPerCollection = 1; // 1 second between collections
+        _rca.maxSecondsPerCollection = type(uint32).max; // no maximum time between collections
+        _rca.serviceProvider = _indexerState.addr; // service provider is the indexer
+        _rca.dataService = address(subgraphService); // data service is the subgraph service
+        _rca.metadata = _encodeAcceptIndexingAgreementMetadataV1(_indexerState.subgraphDeploymentId, terms);
+
+        _setupPayerWithEscrow(
+            _rca.payer,
+            _ctx.payer.signerPrivateKey,
+            _indexerState.addr,
+            _expectedTokens.expectedTotalTokensCollected
+        );
+
+        resetPrank(_indexerState.addr);
+        // Set the payments destination to the indexer address
+        subgraphService.setPaymentsDestination(_indexerState.addr);
+
+        // Accept the Indexing Agreement
+        bytes16 agreementId = subgraphService.acceptIndexingAgreement(
+            _indexerState.allocationId,
+            _recurringCollectorHelper.generateSignedRCA(_rca, _ctx.payer.signerPrivateKey)
+        );
+
+        // Skip ahead to collection point
+        skip(_expectedTokens.expectedTotalTokensCollected / terms.tokensPerSecond);
+
+        return agreementId;
+    }
+
+    function _newExpectedTokens(uint256 _fuzzyTokensCollected) internal view returns (ExpectedTokens memory) {
+        uint256 expectedTotalTokensCollected = bound(_fuzzyTokensCollected, 1000, 1_000_000);
+        uint256 expectedTokensLocked = STAKE_TO_FEES_RATIO * expectedTotalTokensCollected;
+        uint256 expectedProtocolTokensBurnt = expectedTotalTokensCollected.mulPPMRoundUp(
+            graphPayments.PROTOCOL_PAYMENT_CUT()
+        );
+        uint256 expectedIndexerTokensCollected = expectedTotalTokensCollected - expectedProtocolTokensBurnt;
+        return
+            ExpectedTokens({
+                expectedTotalTokensCollected: expectedTotalTokensCollected,
+                expectedTokensLocked: expectedTokensLocked,
+                expectedProtocolTokensBurnt: expectedProtocolTokensBurnt,
+                expectedIndexerTokensCollected: expectedIndexerTokensCollected
+            });
+    }
+
+    function _sharedAssert(
+        TestState memory _beforeCollect,
+        TestState memory _afterCollect,
+        ExpectedTokens memory _expectedTokens,
+        uint256 _tokensCollected
+    ) internal pure {
+        uint256 indexerTokensCollected = _afterCollect.indexerBalance - _beforeCollect.indexerBalance;
+        assertEq(_expectedTokens.expectedTotalTokensCollected, _tokensCollected, "Total tokens collected should match");
+        assertEq(
+            _expectedTokens.expectedProtocolTokensBurnt,
+            _tokensCollected - indexerTokensCollected,
+            "Protocol tokens burnt should match"
+        );
+        assertEq(
+            _expectedTokens.expectedIndexerTokensCollected,
+            indexerTokensCollected,
+            "Indexer tokens collected should match"
+        );
+        assertEq(
+            _afterCollect.escrowBalance,
+            _beforeCollect.escrowBalance - _expectedTokens.expectedTotalTokensCollected,
+            "_Escrow balance should be reduced by the amount collected"
+        );
+
+        assertEq(
+            _afterCollect.indexerTokensLocked,
+            _beforeCollect.indexerTokensLocked + _expectedTokens.expectedTokensLocked,
+            "_Locked tokens should match"
+        );
+    }
+
+    function _addTokensToProvision(IndexerState memory _indexerState, uint256 _tokens) private {
+        deal({ token: address(token), to: _indexerState.addr, give: _tokens });
+        vm.startPrank(_indexerState.addr);
+        _addToProvision(_indexerState.addr, _tokens);
+        vm.stopPrank();
+    }
+
+    function _removeTokensFromProvision(IndexerState memory _indexerState, uint256 _tokens) private {
+        deal({ token: address(token), to: _indexerState.addr, give: _tokens });
+        vm.startPrank(_indexerState.addr);
+        _removeFromProvision(_indexerState.addr, _tokens);
+        vm.stopPrank();
+    }
+
+    function _setupPayerWithEscrow(
+        address _payer,
+        uint256 _signerPrivateKey,
+        address _indexer,
+        uint256 _escrowTokens
+    ) private {
+        _recurringCollectorHelper.authorizeSignerWithChecks(_payer, _signerPrivateKey);
+
+        deal({ token: address(token), to: _payer, give: _escrowTokens });
+        vm.startPrank(_payer);
+        _escrow(_escrowTokens, _indexer);
+        vm.stopPrank();
+    }
+
+    function _escrow(uint256 _tokens, address _indexer) private {
+        token.approve(address(escrow), _tokens);
+        escrow.deposit(address(recurringCollector), _indexer, _tokens);
+    }
+
+    function _getState(address _payer, address _indexer) private view returns (TestState memory) {
+        CollectPaymentData memory collect = _collectPaymentData(_indexer);
+
+        return
+            TestState({
+                escrowBalance: escrow.getBalance(_payer, address(recurringCollector), _indexer),
+                indexerBalance: collect.indexerBalance,
+                indexerTokensLocked: collect.lockedTokens
+            });
+    }
+}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/shared.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/shared.t.sol
new file mode 100644
index 000000000..ba39cb8b6
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/shared.t.sol
@@ -0,0 +1,435 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { IIndexingAgreement } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IIndexingAgreement.sol";
+import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
+
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+
+import { Bounder } from "@graphprotocol/horizon/test/unit/utils/Bounder.t.sol";
+import { RecurringCollectorHelper } from "@graphprotocol/horizon/test/unit/payments/recurring-collector/RecurringCollectorHelper.t.sol";
+import { SubgraphServiceTest } from "../SubgraphService.t.sol";
+
+contract SubgraphServiceIndexingAgreementSharedTest is SubgraphServiceTest, Bounder {
+    struct Context {
+        PayerState payer;
+        IndexerState[] indexers;
+        mapping(address allocationId => address indexer) allocations;
+        ContextInternal ctxInternal;
+    }
+
+    struct IndexerState {
+        address addr;
+        address allocationId;
+        bytes32 subgraphDeploymentId;
+        uint256 tokens;
+    }
+
+    struct PayerState {
+        address signer;
+        uint256 signerPrivateKey;
+    }
+
+    struct ContextInternal {
+        IndexerSeed[] indexers;
+        Seed seed;
+        bool initialized;
+    }
+
+    struct Seed {
+        IndexerSeed indexer0;
+        IndexerSeed indexer1;
+        IRecurringCollector.RecurringCollectionAgreement rca;
+        IRecurringCollector.RecurringCollectionAgreementUpdate rcau;
+        IndexingAgreement.IndexingAgreementTermsV1 termsV1;
+        PayerSeed payer;
+    }
+
+    struct IndexerSeed {
+        address addr;
+        string label;
+        uint256 unboundedProvisionTokens;
+        uint256 unboundedAllocationPrivateKey;
+        bytes32 subgraphDeploymentId;
+    }
+
+    struct PayerSeed {
+        uint256 unboundedSignerPrivateKey;
+    }
+
+    Context internal _context;
+
+    bytes32 internal constant TRANSPARENT_UPGRADEABLE_PROXY_ADMIN_ADDRESS_SLOT =
+        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
+    address internal constant GRAPH_PROXY_ADMIN_ADDRESS = 0x15c603B7eaA8eE1a272a69C4af3462F926de777F;
+
+    RecurringCollectorHelper internal _recurringCollectorHelper;
+
+    modifier withSafeIndexerOrOperator(address operator) {
+        vm.assume(_isSafeSubgraphServiceCaller(operator));
+        _;
+    }
+
+    function setUp() public override {
+        super.setUp();
+
+        _recurringCollectorHelper = new RecurringCollectorHelper(recurringCollector);
+    }
+
+    /*
+     * HELPERS
+     */
+
+    function _subgraphServiceSafePrank(address _addr) internal returns (address) {
+        address originalPrankAddress = msg.sender;
+        vm.assume(_isSafeSubgraphServiceCaller(_addr));
+        resetPrank(_addr);
+
+        return originalPrankAddress;
+    }
+
+    function _stopOrResetPrank(address _originalSender) internal {
+        if (_originalSender == 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38) {
+            vm.stopPrank();
+        } else {
+            resetPrank(_originalSender);
+        }
+    }
+
+    function _cancelAgreement(
+        Context storage _ctx,
+        bytes16 _agreementId,
+        address _indexer,
+        address _payer,
+        IRecurringCollector.CancelAgreementBy _by
+    ) internal {
+        bool byIndexer = _by == IRecurringCollector.CancelAgreementBy.ServiceProvider;
+        vm.expectEmit(address(subgraphService));
+        emit IndexingAgreement.IndexingAgreementCanceled(_indexer, _payer, _agreementId, byIndexer ? _indexer : _payer);
+
+        if (byIndexer) {
+            _subgraphServiceSafePrank(_indexer);
+            subgraphService.cancelIndexingAgreement(_indexer, _agreementId);
+        } else {
+            _subgraphServiceSafePrank(_ctx.payer.signer);
+            subgraphService.cancelIndexingAgreementByPayer(_agreementId);
+        }
+    }
+
+    function _withIndexer(Context storage _ctx) internal returns (IndexerState memory) {
+        require(_ctx.ctxInternal.indexers.length > 0, "No indexer seeds available");
+
+        IndexerSeed memory indexerSeed = _ctx.ctxInternal.indexers[_ctx.ctxInternal.indexers.length - 1];
+        _ctx.ctxInternal.indexers.pop();
+
+        indexerSeed.label = string.concat("_withIndexer-", Strings.toString(_ctx.ctxInternal.indexers.length));
+
+        return _setupIndexer(_ctx, indexerSeed);
+    }
+
+    function _setupIndexer(Context storage _ctx, IndexerSeed memory _seed) internal returns (IndexerState memory) {
+        vm.assume(_getIndexer(_ctx, _seed.addr).addr == address(0));
+
+        (uint256 allocationKey, address allocationId) = boundKeyAndAddr(_seed.unboundedAllocationPrivateKey);
+        vm.assume(_ctx.allocations[allocationId] == address(0));
+        _ctx.allocations[allocationId] = _seed.addr;
+
+        uint256 tokens = bound(_seed.unboundedProvisionTokens, MINIMUM_PROVISION_TOKENS, MAX_TOKENS);
+
+        IndexerState memory indexer = IndexerState({
+            addr: _seed.addr,
+            allocationId: allocationId,
+            subgraphDeploymentId: _seed.subgraphDeploymentId,
+            tokens: tokens
+        });
+        vm.label(indexer.addr, string.concat("_setupIndexer-", _seed.label));
+
+        // Mint tokens to the indexer
+        mint(_seed.addr, tokens);
+
+        // Create the indexer
+        address originalPrank = _subgraphServiceSafePrank(indexer.addr);
+        _createProvision(indexer.addr, indexer.tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+        _register(indexer.addr, abi.encode("url", "geoHash", address(0)));
+        bytes memory data = _createSubgraphAllocationData(
+            indexer.addr,
+            indexer.subgraphDeploymentId,
+            allocationKey,
+            indexer.tokens
+        );
+        _startService(indexer.addr, data);
+
+        _ctx.indexers.push(indexer);
+
+        _stopOrResetPrank(originalPrank);
+
+        return indexer;
+    }
+
+    function _withAcceptedIndexingAgreement(
+        Context storage _ctx,
+        IndexerState memory _indexerState
+    ) internal returns (IRecurringCollector.SignedRCA memory, bytes16 agreementId) {
+        IRecurringCollector.RecurringCollectionAgreement memory rca = _ctx.ctxInternal.seed.rca;
+
+        IndexingAgreement.AcceptIndexingAgreementMetadata memory metadata = _newAcceptIndexingAgreementMetadataV1(
+            _indexerState.subgraphDeploymentId
+        );
+        rca.serviceProvider = _indexerState.addr;
+        rca.dataService = address(subgraphService);
+        rca.metadata = abi.encode(metadata);
+
+        rca = _recurringCollectorHelper.sensibleRCA(rca);
+
+        IRecurringCollector.SignedRCA memory signedRCA = _recurringCollectorHelper.generateSignedRCA(
+            rca,
+            _ctx.payer.signerPrivateKey
+        );
+        _recurringCollectorHelper.authorizeSignerWithChecks(rca.payer, _ctx.payer.signerPrivateKey);
+
+        // Generate deterministic agreement ID for event expectation
+        agreementId = recurringCollector.generateAgreementId(
+            rca.payer,
+            rca.dataService,
+            rca.serviceProvider,
+            rca.deadline,
+            rca.nonce
+        );
+
+        vm.expectEmit(address(subgraphService));
+        emit IndexingAgreement.IndexingAgreementAccepted(
+            rca.serviceProvider,
+            rca.payer,
+            agreementId,
+            _indexerState.allocationId,
+            metadata.subgraphDeploymentId,
+            metadata.version,
+            metadata.terms
+        );
+        _subgraphServiceSafePrank(_indexerState.addr);
+        bytes16 actualAgreementId = subgraphService.acceptIndexingAgreement(_indexerState.allocationId, signedRCA);
+
+        // Verify the agreement ID matches expectation
+        assertEq(actualAgreementId, agreementId);
+        return (signedRCA, agreementId);
+    }
+
+    function _newCtx(Seed memory _seed) internal returns (Context storage) {
+        require(_context.ctxInternal.initialized == false, "Context already initialized");
+        Context storage ctx = _context;
+
+        // Initialize
+        ctx.ctxInternal.initialized = true;
+
+        // Setup seeds
+        ctx.ctxInternal.seed = _seed;
+        ctx.ctxInternal.indexers.push(_seed.indexer0);
+        ctx.ctxInternal.indexers.push(_seed.indexer1);
+
+        // Setup payer
+        ctx.payer.signerPrivateKey = boundKey(ctx.ctxInternal.seed.payer.unboundedSignerPrivateKey);
+        ctx.payer.signer = vm.addr(ctx.payer.signerPrivateKey);
+
+        return ctx;
+    }
+
+    function _generateAcceptableSignedRCA(
+        Context storage _ctx,
+        address _indexerAddress
+    ) internal returns (IRecurringCollector.SignedRCA memory) {
+        IRecurringCollector.RecurringCollectionAgreement memory rca = _generateAcceptableRecurringCollectionAgreement(
+            _ctx,
+            _indexerAddress
+        );
+        _recurringCollectorHelper.authorizeSignerWithChecks(rca.payer, _ctx.payer.signerPrivateKey);
+
+        return _recurringCollectorHelper.generateSignedRCA(rca, _ctx.payer.signerPrivateKey);
+    }
+
+    function _generateAcceptableRecurringCollectionAgreement(
+        Context storage _ctx,
+        address _indexerAddress
+    ) internal view returns (IRecurringCollector.RecurringCollectionAgreement memory) {
+        IndexerState memory indexer = _requireIndexer(_ctx, _indexerAddress);
+        IndexingAgreement.AcceptIndexingAgreementMetadata memory metadata = _newAcceptIndexingAgreementMetadataV1(
+            indexer.subgraphDeploymentId
+        );
+        IRecurringCollector.RecurringCollectionAgreement memory rca = _ctx.ctxInternal.seed.rca;
+        rca.serviceProvider = indexer.addr;
+        rca.dataService = address(subgraphService);
+        rca.metadata = abi.encode(metadata);
+
+        return _recurringCollectorHelper.sensibleRCA(rca);
+    }
+
+    function _generateAcceptableSignedRCAU(
+        Context storage _ctx,
+        IRecurringCollector.RecurringCollectionAgreement memory _rca
+    ) internal view returns (IRecurringCollector.SignedRCAU memory) {
+        IRecurringCollector.RecurringCollectionAgreementUpdate
+            memory rcau = _generateAcceptableRecurringCollectionAgreementUpdate(_ctx, _rca);
+        // Set correct nonce for first update (should be 1)
+        rcau.nonce = 1;
+        return _recurringCollectorHelper.generateSignedRCAU(rcau, _ctx.payer.signerPrivateKey);
+    }
+
+    function _generateAcceptableRecurringCollectionAgreementUpdate(
+        Context storage _ctx,
+        IRecurringCollector.RecurringCollectionAgreement memory _rca
+    ) internal view returns (IRecurringCollector.RecurringCollectionAgreementUpdate memory) {
+        IRecurringCollector.RecurringCollectionAgreementUpdate memory rcau = _ctx.ctxInternal.seed.rcau;
+        // Generate deterministic agreement ID for the update
+        rcau.agreementId = recurringCollector.generateAgreementId(
+            _rca.payer,
+            _rca.dataService,
+            _rca.serviceProvider,
+            _rca.deadline,
+            _rca.nonce
+        );
+        rcau.metadata = _encodeUpdateIndexingAgreementMetadataV1(
+            _newUpdateIndexingAgreementMetadataV1(
+                bound(_ctx.ctxInternal.seed.termsV1.tokensPerSecond, 0, _rca.maxOngoingTokensPerSecond),
+                _ctx.ctxInternal.seed.termsV1.tokensPerEntityPerSecond
+            )
+        );
+        return _recurringCollectorHelper.sensibleRCAU(rcau);
+    }
+
+    function _requireIndexer(Context storage _ctx, address _indexer) internal view returns (IndexerState memory) {
+        IndexerState memory indexerState = _getIndexer(_ctx, _indexer);
+        require(indexerState.addr != address(0), "Indexer not found in context");
+
+        return indexerState;
+    }
+
+    function _getIndexer(Context storage _ctx, address _indexer) internal view returns (IndexerState memory zero) {
+        for (uint256 i = 0; i < _ctx.indexers.length; i++) {
+            if (_ctx.indexers[i].addr == _indexer) {
+                return _ctx.indexers[i];
+            }
+        }
+
+        return zero;
+    }
+
+    function _isSafeSubgraphServiceCaller(address _candidate) internal view returns (bool) {
+        return
+            _candidate != address(0) &&
+            _candidate != address(_transparentUpgradeableProxyAdmin()) &&
+            _candidate != address(proxyAdmin);
+    }
+
+    function _transparentUpgradeableProxyAdmin() internal view returns (address) {
+        return
+            address(
+                uint160(uint256(vm.load(address(subgraphService), TRANSPARENT_UPGRADEABLE_PROXY_ADMIN_ADDRESS_SLOT)))
+            );
+    }
+
+    function _newAcceptIndexingAgreementMetadataV1(
+        bytes32 _subgraphDeploymentId
+    ) internal pure returns (IndexingAgreement.AcceptIndexingAgreementMetadata memory) {
+        return
+            _newAcceptIndexingAgreementMetadataV1Terms(
+                _subgraphDeploymentId,
+                abi.encode(
+                    IndexingAgreement.IndexingAgreementTermsV1({ tokensPerSecond: 0, tokensPerEntityPerSecond: 0 })
+                )
+            );
+    }
+
+    function _newAcceptIndexingAgreementMetadataV1Terms(
+        bytes32 _subgraphDeploymentId,
+        bytes memory _terms
+    ) internal pure returns (IndexingAgreement.AcceptIndexingAgreementMetadata memory) {
+        return
+            IndexingAgreement.AcceptIndexingAgreementMetadata({
+                subgraphDeploymentId: _subgraphDeploymentId,
+                version: IIndexingAgreement.IndexingAgreementVersion.V1,
+                terms: _terms
+            });
+    }
+
+    function _newUpdateIndexingAgreementMetadataV1(
+        uint256 _tokensPerSecond,
+        uint256 _tokensPerEntityPerSecond
+    ) internal pure returns (IndexingAgreement.UpdateIndexingAgreementMetadata memory) {
+        return
+            IndexingAgreement.UpdateIndexingAgreementMetadata({
+                version: IIndexingAgreement.IndexingAgreementVersion.V1,
+                terms: abi.encode(
+                    IndexingAgreement.IndexingAgreementTermsV1({
+                        tokensPerSecond: _tokensPerSecond,
+                        tokensPerEntityPerSecond: _tokensPerEntityPerSecond
+                    })
+                )
+            });
+    }
+
+    function _encodeCollectDataV1(
+        bytes16 _agreementId,
+        uint256 _entities,
+        bytes32 _poi,
+        uint256 _poiBlock,
+        bytes memory _metadata
+    ) internal pure returns (bytes memory) {
+        return _encodeCollectData(_agreementId, _encodeV1Data(_entities, _poi, _poiBlock, _metadata));
+    }
+
+    function _encodeCollectData(bytes16 _agreementId, bytes memory _nestedData) internal pure returns (bytes memory) {
+        return abi.encode(_agreementId, _nestedData);
+    }
+
+    function _encodeV1Data(
+        uint256 _entities,
+        bytes32 _poi,
+        uint256 _poiBlock,
+        bytes memory _metadata
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encode(
+                IndexingAgreement.CollectIndexingFeeDataV1({
+                    entities: _entities,
+                    poi: _poi,
+                    poiBlockNumber: _poiBlock,
+                    metadata: _metadata,
+                    maxSlippage: type(uint256).max
+                })
+            );
+    }
+
+    function _encodeAcceptIndexingAgreementMetadataV1(
+        bytes32 _subgraphDeploymentId,
+        IndexingAgreement.IndexingAgreementTermsV1 memory _terms
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encode(
+                IndexingAgreement.AcceptIndexingAgreementMetadata({
+                    subgraphDeploymentId: _subgraphDeploymentId,
+                    version: IIndexingAgreement.IndexingAgreementVersion.V1,
+                    terms: abi.encode(_terms)
+                })
+            );
+    }
+
+    function _encodeUpdateIndexingAgreementMetadataV1(
+        IndexingAgreement.UpdateIndexingAgreementMetadata memory _t
+    ) internal pure returns (bytes memory) {
+        return abi.encode(_t);
+    }
+
+    function _assertEqualAgreement(
+        IRecurringCollector.RecurringCollectionAgreement memory _expected,
+        IIndexingAgreement.AgreementWrapper memory _actual
+    ) internal pure {
+        assertEq(_expected.dataService, _actual.collectorAgreement.dataService);
+        assertEq(_expected.payer, _actual.collectorAgreement.payer);
+        assertEq(_expected.serviceProvider, _actual.collectorAgreement.serviceProvider);
+        assertEq(_expected.endsAt, _actual.collectorAgreement.endsAt);
+        assertEq(_expected.maxInitialTokens, _actual.collectorAgreement.maxInitialTokens);
+        assertEq(_expected.maxOngoingTokensPerSecond, _actual.collectorAgreement.maxOngoingTokensPerSecond);
+        assertEq(_expected.minSecondsPerCollection, _actual.collectorAgreement.minSecondsPerCollection);
+        assertEq(_expected.maxSecondsPerCollection, _actual.collectorAgreement.maxSecondsPerCollection);
+    }
+}
diff --git a/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/update.t.sol b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/update.t.sol
new file mode 100644
index 000000000..dd5af140c
--- /dev/null
+++ b/packages/subgraph-service/test/unit/subgraphService/indexing-agreement/update.t.sol
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.33;
+
+import { IRecurringCollector } from "@graphprotocol/interfaces/contracts/horizon/IRecurringCollector.sol";
+import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
+import { ProvisionManager } from "@graphprotocol/horizon/contracts/data-service/utilities/ProvisionManager.sol";
+
+import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
+import { IndexingAgreement } from "../../../../contracts/libraries/IndexingAgreement.sol";
+import { IndexingAgreementDecoder } from "../../../../contracts/libraries/IndexingAgreementDecoder.sol";
+
+import { SubgraphServiceIndexingAgreementSharedTest } from "./shared.t.sol";
+
+contract SubgraphServiceIndexingAgreementUpgradeTest is SubgraphServiceIndexingAgreementSharedTest {
+    /*
+     * TESTS
+     */
+
+    /* solhint-disable graph/func-name-mixedcase */
+    function test_SubgraphService_UpdateIndexingAgreementIndexingAgreement_Revert_WhenPaused(
+        address operator,
+        IRecurringCollector.SignedRCAU calldata signedRCAU
+    ) public withSafeIndexerOrOperator(operator) {
+        resetPrank(users.pauseGuardian);
+        subgraphService.pause();
+
+        resetPrank(operator);
+        vm.expectRevert(PausableUpgradeable.EnforcedPause.selector);
+        subgraphService.updateIndexingAgreement(operator, signedRCAU);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_Revert_WhenNotAuthorized(
+        address indexer,
+        address notAuthorized,
+        IRecurringCollector.SignedRCAU calldata signedRCAU
+    ) public withSafeIndexerOrOperator(notAuthorized) {
+        vm.assume(notAuthorized != indexer);
+        resetPrank(notAuthorized);
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerNotAuthorized.selector,
+            indexer,
+            notAuthorized
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.updateIndexingAgreement(indexer, signedRCAU);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_Revert_WhenInvalidProvision(
+        address indexer,
+        uint256 unboundedTokens,
+        IRecurringCollector.SignedRCAU memory signedRCAU
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, 1, MINIMUM_PROVISION_TOKENS - 1);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ProvisionManager.ProvisionManagerInvalidValue.selector,
+            "tokens",
+            tokens,
+            MINIMUM_PROVISION_TOKENS,
+            MAXIMUM_PROVISION_TOKENS
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.updateIndexingAgreement(indexer, signedRCAU);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_Revert_WhenIndexerNotRegistered(
+        address indexer,
+        uint256 unboundedTokens,
+        IRecurringCollector.SignedRCAU memory signedRCAU
+    ) public withSafeIndexerOrOperator(indexer) {
+        uint256 tokens = bound(unboundedTokens, MINIMUM_PROVISION_TOKENS, MAX_TOKENS);
+        mint(indexer, tokens);
+        resetPrank(indexer);
+        _createProvision(indexer, tokens, FISHERMAN_REWARD_PERCENTAGE, DISPUTE_PERIOD);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            ISubgraphService.SubgraphServiceIndexerNotRegistered.selector,
+            indexer
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.updateIndexingAgreement(indexer, signedRCAU);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_Revert_WhenNotAccepted(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCAU memory acceptableUpdate = _generateAcceptableSignedRCAU(
+            ctx,
+            _generateAcceptableRecurringCollectionAgreement(ctx, indexerState.addr)
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotActive.selector,
+            acceptableUpdate.rcau.agreementId
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerState.addr);
+        subgraphService.updateIndexingAgreement(indexerState.addr, acceptableUpdate);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_Revert_WhenNotAuthorizedForAgreement(
+        Seed memory seed
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerStateA = _withIndexer(ctx);
+        IndexerState memory indexerStateB = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, ) = _withAcceptedIndexingAgreement(ctx, indexerStateA);
+        IRecurringCollector.SignedRCAU memory acceptableUpdate = _generateAcceptableSignedRCAU(ctx, accepted.rca);
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotAuthorized.selector,
+            acceptableUpdate.rcau.agreementId,
+            indexerStateB.addr
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerStateB.addr);
+        subgraphService.updateIndexingAgreement(indexerStateB.addr, acceptableUpdate);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_Revert_WhenInvalidMetadata(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, ) = _withAcceptedIndexingAgreement(ctx, indexerState);
+        IRecurringCollector.RecurringCollectionAgreementUpdate
+            memory acceptableUpdate = _generateAcceptableRecurringCollectionAgreementUpdate(ctx, accepted.rca);
+        acceptableUpdate.metadata = bytes("invalid");
+        // Set correct nonce for first update (should be 1)
+        acceptableUpdate.nonce = 1;
+        IRecurringCollector.SignedRCAU memory unacceptableUpdate = _recurringCollectorHelper.generateSignedRCAU(
+            acceptableUpdate,
+            ctx.payer.signerPrivateKey
+        );
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreementDecoder.IndexingAgreementDecoderInvalidData.selector,
+            "decodeRCAUMetadata",
+            unacceptableUpdate.rcau.metadata
+        );
+        vm.expectRevert(expectedErr);
+        resetPrank(indexerState.addr);
+        subgraphService.updateIndexingAgreement(indexerState.addr, unacceptableUpdate);
+    }
+
+    function test_SubgraphService_UpdateIndexingAgreement_OK(Seed memory seed) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        (IRecurringCollector.SignedRCA memory accepted, ) = _withAcceptedIndexingAgreement(ctx, indexerState);
+        IRecurringCollector.SignedRCAU memory acceptableUpdate = _generateAcceptableSignedRCAU(ctx, accepted.rca);
+
+        IndexingAgreement.UpdateIndexingAgreementMetadata memory metadata = abi.decode(
+            acceptableUpdate.rcau.metadata,
+            (IndexingAgreement.UpdateIndexingAgreementMetadata)
+        );
+
+        vm.expectEmit(address(subgraphService));
+        emit IndexingAgreement.IndexingAgreementUpdated(
+            accepted.rca.serviceProvider,
+            accepted.rca.payer,
+            acceptableUpdate.rcau.agreementId,
+            indexerState.allocationId,
+            metadata.version,
+            metadata.terms
+        );
+
+        resetPrank(indexerState.addr);
+        subgraphService.updateIndexingAgreement(indexerState.addr, acceptableUpdate);
+    }
+    /* solhint-enable graph/func-name-mixedcase */
+}
diff --git a/packages/toolshed/src/deployments/horizon/actions.ts b/packages/toolshed/src/deployments/horizon/actions.ts
index 8fc9bd4df..144342a82 100644
--- a/packages/toolshed/src/deployments/horizon/actions.ts
+++ b/packages/toolshed/src/deployments/horizon/actions.ts
@@ -62,15 +62,6 @@ export function loadActions(contracts: GraphHorizonContracts) {
      */
     provision: (signer: HardhatEthersSigner, args: Parameters<GraphHorizonContracts['HorizonStaking']['provision']>) =>
       provision(contracts, signer, args),
-    /**
-     * [Legacy] Collects query fees from the Horizon staking contract
-     * Note that it will approve HorizonStaking to spend the tokens
-     * @param signer - The signer that will execute the collect transaction
-     * @param args Parameters:
-     *   - `[tokens, allocationID]` - The collect parameters
-     */
-    collect: (signer: HardhatEthersSigner, args: Parameters<GraphHorizonContracts['HorizonStaking']['collect']>) =>
-      collect(contracts, signer, args),
     /**
      * Delegates tokens in the Horizon staking contract
      * Note that it will approve HorizonStaking to spend the tokens
@@ -157,18 +148,6 @@ async function provision(
   await HorizonStaking.connect(signer).provision(serviceProvider, verifier, tokens, maxVerifierCut, thawingPeriod)
 }
 
-async function collect(
-  contracts: GraphHorizonContracts,
-  signer: HardhatEthersSigner,
-  args: Parameters<GraphHorizonContracts['HorizonStaking']['collect']>,
-) {
-  const { GraphToken, HorizonStaking } = contracts
-  const [tokens, allocationID] = args
-
-  await GraphToken.connect(signer).approve(HorizonStaking.target, tokens)
-  await HorizonStaking.connect(signer).collect(tokens, allocationID)
-}
-
 async function delegate(
   contracts: GraphHorizonContracts,
   signer: HardhatEthersSigner,
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9d87a91b1..52438ce5e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1311,6 +1311,8 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  packages/issuance/types: {}
+
   packages/subgraph-service:
     devDependencies:
       '@graphprotocol/contracts':