feat(deploy): allow sequenced tx batching

Signed-off-by: Tomás Migone <tomas@edgeandnode.com>

Author: tmigone

packages/deployment/config/arbitrumOne.json5

@@ -5,6 +5,13 @@
     eligibilityOracle: 'RewardsEligibilityOracleA',
   },
 
+  RecurringAgreementManager: {
+    // Wired to the same REO as RewardsManager. RAM stays dormant at launch
+    // (0 issuance + RecurringCollector paused) — this only pre-configures its
+    // eligibility oracle so it matches RM.
+    eligibilityOracle: 'RewardsEligibilityOracleA',
+  },
+
   IssuanceAllocator: {
     // Explicit issuance allocation table, by target contract name. The rates must
     // sum to issuancePerBlock, which must equal RM's on-chain issuance rate — the

packages/deployment/deploy/gip/0088/eligibility_integrate.ts

@@ -10,9 +10,15 @@ import {
 import { canSignAsGovernor } from '@graphprotocol/deployment/lib/controller-utils.js'
 import { getResolvedSettingsForEnv } from '@graphprotocol/deployment/lib/deployment-config.js'
 import { assumeUpgraded, ComponentTags, GoalTags } from '@graphprotocol/deployment/lib/deployment-tags.js'
+import {
+  createGovernanceTxBuilder,
+  executeTxBatchDirect,
+  saveGovernanceTx,
+} from '@graphprotocol/deployment/lib/execute-governance.js'
 import { requireContracts } from '@graphprotocol/deployment/lib/issuance-deploy-utils.js'
 import { createActionModule } from '@graphprotocol/deployment/lib/script-factories.js'
 import { syncComponentsFromRegistry } from '@graphprotocol/deployment/lib/sync-utils.js'
+import type { TxBuilder } from '@graphprotocol/deployment/lib/tx-builder.js'
 import { graph } from '@graphprotocol/deployment/rocketh/deploy.js'
 import type { Environment } from '@rocketh/core/types'
 import type { PublicClient } from 'viem'
@@ -30,34 +36,41 @@ import type { PublicClient } from 'viem'
 async function integrateOracle(
   env: Environment,
   client: PublicClient,
+  builder: TxBuilder,
+  governor: string,
+  canSign: boolean,
   targetLabel: string,
   targetEntry: RegistryEntry,
   oracleName: EligibilityOracleContractName | undefined,
-): Promise<void> {
+): Promise<boolean> {
   if (!oracleName) {
     env.showMessage(`\n  ○ ${targetLabel}: no eligibility oracle configured — skipping\n`)
-    return
+    return false
   }
 
   const reoEntry = eligibilityOracleContract(oracleName)
   await syncComponentsFromRegistry(env, [reoEntry, targetEntry])
   const [reo, target] = requireContracts(env, [reoEntry, targetEntry])
 
-  const { governor, canSign } = await canSignAsGovernor(env)
+  const applyOpts = {
+    contractName: `${targetEntry.name}-REO`,
+    contractAddress: target.address,
+    canExecuteDirectly: canSign,
+    executor: governor,
+    // Append to the shared batch; the caller executes/saves once for all targets.
+    builder,
+  }
 
   // Sequenced-bundle generation: the target proxy isn't upgraded yet, so the
   // oracle getter would revert. Skip the probe/idempotency read and emit the
   // set-oracle TX unconditionally. The resulting bundle is sequenced-only —
   // execute it after the upgrade bundle (nonce order enforces this).
   if (assumeUpgraded()) {
-    await applyConfiguration(env, client, [createRMIntegrationCondition(reo.address)], {
-      contractName: `${target.name}-REO`,
-      contractAddress: target.address,
-      canExecuteDirectly: canSign,
-      executor: governor,
+    const result = await applyConfiguration(env, client, [createRMIntegrationCondition(reo.address)], {
+      ...applyOpts,
       assumeUndone: true,
     })
-    return
+    return result.changesNeeded
   }
 
   // Skip only if the target isn't upgraded yet (no oracle getter). Once it
@@ -73,15 +86,11 @@ async function integrateOracle(
   } catch {
     // Function not available — target not upgraded, skip
     env.showMessage(`\n  ○ ${targetLabel} does not support getProviderEligibilityOracle — skipping\n`)
-    return
+    return false
   }
 
-  await applyConfiguration(env, client, [createRMIntegrationCondition(reo.address)], {
-    contractName: `${target.name}-REO`,
-    contractAddress: target.address,
-    canExecuteDirectly: canSign,
-    executor: governor,
-  })
+  const result = await applyConfiguration(env, client, [createRMIntegrationCondition(reo.address)], applyOpts)
+  return result.changesNeeded
 }
 
 /**
@@ -103,21 +112,48 @@ export default createActionModule(
   async (env) => {
     const settings = await getResolvedSettingsForEnv(env)
     const client = graph.getPublicClient(env) as PublicClient
+    const { governor, canSign } = await canSignAsGovernor(env)
+
+    // One shared batch for every configured target (RM and/or RAM), so both
+    // setProviderEligibilityOracle TXs land in a single governance bundle.
+    const builder = await createGovernanceTxBuilder(env, 'gip-0088-eligibility-integrate', {
+      name: 'GIP-0088 Eligibility Integration',
+      description: 'Set the provider eligibility oracle on RewardsManager and RecurringAgreementManager',
+    })
 
-    await integrateOracle(
+    const rmChanged = await integrateOracle(
       env,
       client,
+      builder,
+      governor,
+      canSign,
       'RM',
       Contracts.horizon.RewardsManager,
       settings.rewardsManager.eligibilityOracle,
     )
-    await integrateOracle(
+    const ramChanged = await integrateOracle(
       env,
       client,
+      builder,
+      governor,
+      canSign,
       'RAM',
       Contracts.issuance.RecurringAgreementManager,
       settings.recurringAgreementManager.eligibilityOracle,
     )
+
+    if (!rmChanged && !ramChanged) {
+      env.showMessage('\n✅ Eligibility oracles already match config — nothing to do\n')
+      return
+    }
+
+    if (canSign) {
+      env.showMessage('\n🔨 Executing eligibility integration batch...\n')
+      await executeTxBatchDirect(env, builder, governor)
+      env.showMessage('\n✅ Eligibility integration complete\n')
+    } else {
+      saveGovernanceTx(env, builder, 'GIP-0088 Eligibility Integration')
+    }
   },
   {
     // Ordering anchor for a combined `--tags GIP-0088` run: REO-A always deploys

packages/deployment/lib/apply-configuration.ts

@@ -18,6 +18,7 @@ import {
   type RoleCondition,
 } from './contract-checks.js'
 import { createGovernanceTxBuilder, executeTxBatchDirect, saveGovernanceTx } from './execute-governance.js'
+import type { TxBuilder } from './tx-builder.js'
 
 /**
  * Options for applyConfiguration
@@ -44,6 +45,14 @@ export interface ApplyConfigurationOptions {
    * valid only after the upgrade bundle executes.
    */
   assumeUndone?: boolean
+
+  /**
+   * Optional shared TX builder. When provided, configuration TXs are appended to
+   * it and NOT executed or saved here — the caller owns executing/saving the
+   * combined batch once. Lets multiple applyConfiguration calls (e.g. across
+   * several contracts) contribute to a single governance bundle.
+   */
+  builder?: TxBuilder
 }
 
 /**
@@ -87,7 +96,14 @@ export async function applyConfiguration<T>(
   conditions: ConfigCondition<T>[],
   options: ApplyConfigurationOptions,
 ): Promise<ApplyConfigurationResult<T>> {
-  const { contractName, contractAddress, canExecuteDirectly, executor, assumeUndone } = options
+  const {
+    contractName,
+    contractAddress,
+    canExecuteDirectly,
+    executor,
+    assumeUndone,
+    builder: externalBuilder,
+  } = options
 
   // 1. Check all conditions — or, in sequenced-generation mode, skip the read and
   // treat every condition as un-applied (the target proxy isn't upgraded yet, so
@@ -126,7 +142,7 @@ export async function applyConfiguration<T>(
   // 3. Build TX batch for failing conditions
   env.showMessage('\n🔨 Building configuration TX batch...\n')
 
-  const builder = await createGovernanceTxBuilder(env, `configure-${contractName}`)
+  const builder = externalBuilder ?? (await createGovernanceTxBuilder(env, `configure-${contractName}`))
 
   const failingConditions = conditions.filter((_, i) => !status.conditions[i].ok)
 
@@ -166,7 +182,13 @@ export async function applyConfiguration<T>(
     }
   }
 
-  // 4/5. Execute or save based on access
+  // 4/5. When a shared builder was supplied, the caller owns executing/saving the
+  // combined batch — return with the TXs appended.
+  if (externalBuilder) {
+    return { status, changesNeeded: true, executedDirectly: false }
+  }
+
+  // Otherwise execute or save based on access.
   if (canExecuteDirectly && executor) {
     env.showMessage('\n🔨 Executing configuration TX batch...\n')
     await executeTxBatchDirect(env, builder, executor)