tapimo 0.14.0 → 0.15.0

package/src/internal/rewards/Runner.ts

@@ -0,0 +1,2229 @@
+import {
+  erc20Abi,
+  getAddress,
+  isAddress,
+  isAddressEqual,
+  parseAbi,
+  parseEventLogs,
+  type Address,
+  type Hex,
+} from 'viem'
+
+import * as RewardAccounts from '../../db/tables/rewardAccounts.js'
+import * as RewardCampaigns from '../../db/tables/rewardCampaigns.js'
+import * as RewardEligibilityAssociations from '../../db/tables/rewardEligibilityAssociations.js'
+import * as RewardRuns from '../../db/tables/rewardRuns.js'
+import * as RewardTransactionAttempts from '../../db/tables/rewardTransactionAttempts.js'
+import * as EarnVaultRecords from '../../db/tables/earnVaults.js'
+import type * as Db from '../../db/Db.js'
+import * as Campaigns from './Campaigns.js'
+import * as Events from './Events.js'
+import * as Projection from './Projection.js'
+import * as Rates from './Rates.js'
+import * as Signer from './Signer.js'
+import type * as Tidx from '../Tidx.js'
+import * as Viem from '../Viem.js'
+
+const claimDeadline = Number((1n << 40n) - 1n)
+const maximumIntervalsPerRun = 12
+// Each wave produces at most 64 historical multicalls per RPC round.
+const capitalStateBatchSize = 64
+// Keep enough headroom below the Worker's 128 MiB memory limit for account projection,
+// the cumulative Merkle tree, and payout construction to coexist in one invocation.
+const maximumRecipients = 10_000
+// The Earn operator's Tempo gas model budgets 200k per transfer and 250k per
+// push call. Two 60-recipient calls stay below 90% of the signer's 28M cap.
+const payoutBatchSize = 60
+const payoutCallsPerTransaction = 2
+const payoutTransactionConcurrency = 16
+const runLeaseMilliseconds = 2 * 60 * 1_000
+const factoryAbi = parseAbi([
+  'function predictContributionController(address earnVault,address owner) view returns (address)',
+  'function predictMerkleDistributor(address earnVault,address owner,address treasury,uint40 claimDeadline) view returns (address)',
+])
+const vaultAbi = parseAbi([
+  'function earnFees() view returns (address)',
+  'function engine() view returns (address)',
+  'function previewRedeem(uint256 earnShares) view returns (uint256)',
+  'function totalAssets() view returns (uint256)',
+  'function totalEarnShares() view returns (uint256)',
+])
+const feesAbi = parseAbi([
+  'function previewAccruedFees() view returns ((uint256 activeAssets,uint256 positiveAccrualAssets,uint256 fixedFeeAssets,uint256 excessFeeAssets,uint256 totalFeeAssets,uint256 totalFeeEarnShares,uint256 preFeeValuePerEarnShare,uint256 postFeeValuePerEarnShare,uint256 targetValuePerEarnShare,uint8 allocationCount,(address account,uint256 feeAssets,uint256 feeEarnShares)[5] allocations) result)',
+])
+const controllerAbi = parseAbi([
+  'event Funded(address indexed funder,uint256 requestedAssets,uint256 fundedAssets)',
+])
+const distributorAbi = parseAbi([
+  'function cumulativePaid(address recipient) view returns (uint256)',
+  'function merkleRoot() view returns (bytes32)',
+  'function rootTotalEntitlement() view returns (uint256)',
+  'function rootVersion() view returns (uint64)',
+  'function statementHash() view returns (bytes32)',
+  'function totalPaid() view returns (uint256)',
+])
+
+/** Compact queue reference for one Earn reward campaign. */
+export type Message = {
+  /** Tempo chain containing the campaign. */
+  chainId: number
+  /** Queue message discriminator. */
+  type: 'earn:reward:run'
+  /** Verified EarnVault address. */
+  vaultAddress: Address
+}
+
+/** Lists due campaigns as compact queue references. */
+export async function due(db: Db.Db, now = Date.now()): Promise<Message[]> {
+  const campaigns: RewardCampaigns.Record[] = []
+  const pageSize = 100
+  for (let offset = 0; ; offset += pageSize) {
+    const page = await RewardCampaigns.listDue(db, {
+      limit: pageSize,
+      offset,
+      through: Math.floor(now / 1_000),
+    })
+    campaigns.push(...page)
+    if (page.length < pageSize) break
+  }
+  for (let offset = 0; ; offset += pageSize) {
+    const page = await RewardCampaigns.listUnprovisioned(db, { limit: pageSize, offset })
+    campaigns.push(...page)
+    if (page.length < pageSize) break
+  }
+  return [
+    ...new Map(
+      campaigns.map((campaign) => [`${campaign.chainId}:${campaign.vaultAddress}`, campaign]),
+    ).values(),
+  ]
+    .filter(
+      (campaign) =>
+        Number(campaign.deliveredThrough) < Campaigns.finalBoundary(campaign.config) ||
+        [campaign.config, campaign.pendingConfig].some(
+          (config) =>
+            Boolean(config?.targetYield && !campaign.controllerAddress) ||
+            Boolean(config?.boostRewards && !campaign.distributorAddress),
+        ),
+    )
+    .map((campaign) => ({
+      chainId: campaign.chainId,
+      type: 'earn:reward:run',
+      vaultAddress: getAddress(campaign.vaultAddress),
+    }))
+}
+
+/** Selects resumable state only when its eligibility snapshot is unchanged. */
+export function resumeCheckpoint(
+  checkpoint: Campaigns.RunCheckpointEvidence | undefined,
+  options: resumeCheckpoint.Options,
+): Campaigns.RunCheckpointEvidence | undefined {
+  return checkpoint?.progress.eligibilityVersion === options.eligibilityVersion &&
+    checkpoint.progress.exclusionVersion === options.exclusionVersion
+    ? checkpoint
+    : undefined
+}
+
+export declare namespace resumeCheckpoint {
+  /** Current calculation identity. */
+  type Options = {
+    /** Exact current eligibility snapshot identity. */
+    eligibilityVersion: Hex
+    /** Exact current effective exclusion set identity. */
+    exclusionVersion: Hex
+  }
+}
+
+/** Keeps the committed campaign cursor ahead of replay-only history. */
+export function reconciledCursor(options: reconciledCursor.Options): Campaigns.EventCursor | null {
+  return options.committed ?? options.replayed ?? null
+}
+
+export declare namespace reconciledCursor {
+  /** Historical and committed cursor candidates. */
+  type Options = {
+    /** Cursor already committed by the campaign. */
+    committed?: Campaigns.EventCursor | null | undefined
+    /** Last event observed while replaying a new registration. */
+    replayed?: Campaigns.EventCursor | undefined
+  }
+}
+
+/** Restores the target rate selected before a calculation checkpoint. */
+export function checkpointTargetRate(
+  checkpoint: Campaigns.RunCheckpointEvidence | undefined,
+  config: NonNullable<Campaigns.Config['targetYield']>,
+) {
+  const progress = checkpoint?.progress
+  if (progress?.targetRateBps === undefined || !progress.targetRateObservedAt) return undefined
+  return {
+    annualRateBps: progress.targetRateBps,
+    config,
+    observedAt: progress.targetRateObservedAt,
+    ...(progress.staleRates?.includes('target') ? { stale: true } : {}),
+  }
+}
+
+/** Advances one campaign through its durable, fenced execution phases. */
+export async function run(options: run.Options): Promise<run.Result> {
+  const campaign = await RewardCampaigns.get(options.db, options.message)
+  if (!campaign || campaign.paused) return { status: 'idle' }
+  if (campaign.chainId !== Viem.chainId.mainnet)
+    throw new Error('Reward execution is currently supported only on Tempo mainnet.')
+  const { bindings, signer } = await (async () => {
+    try {
+      const signer = await Signer.health(options.signerFetch)
+      const bindings = await provision(options, campaign, signer.signer)
+      return { bindings, signer }
+    } catch (cause) {
+      await RewardCampaigns.setProvisioningError(options.db, {
+        chainId: campaign.chainId,
+        config: provisioningPlan(campaign).configMatch,
+        error: cause instanceof Error ? cause.message : 'Reward provisioning failed.',
+        vaultAddress: getAddress(campaign.vaultAddress),
+      })
+      throw cause
+    }
+  })()
+  const start = Number(campaign.deliveredThrough)
+  const scheduleEnd = Campaigns.finalBoundary(campaign.config)
+  const intervalSeconds = Campaigns.intervalSeconds(campaign.config)
+  const clock = Math.floor(options.now() / 1_000)
+  const completeIntervals = Math.max(
+    0,
+    Math.floor((Math.min(clock, scheduleEnd) - start) / intervalSeconds),
+  )
+  let end = start + Math.min(completeIntervals, maximumIntervalsPerRun) * intervalSeconds
+  const nextScheduleStart = [
+    campaign.config.targetYield?.startTimestamp,
+    campaign.config.boostRewards?.startTimestamp,
+  ]
+    .filter((timestamp): timestamp is number => timestamp !== undefined && timestamp > start)
+    .sort((left, right) => left - right)[0]
+  if (nextScheduleStart !== undefined) end = Math.min(end, nextScheduleStart)
+  if (campaign.pendingEffectiveAt !== null) end = Math.min(end, Number(campaign.pendingEffectiveAt))
+  if (end <= start) return { status: 'idle' }
+
+  const ensured = await RewardRuns.ensure(options.db, {
+    chainId: campaign.chainId,
+    config: campaign.config,
+    endsAt: end,
+    startsAfter: start,
+    vaultAddress: getAddress(campaign.vaultAddress),
+  })
+  const leased = await RewardRuns.acquire(options.db, {
+    id: ensured.id,
+    leaseMilliseconds: runLeaseMilliseconds,
+  })
+  if (!leased) return { runId: ensured.id, status: 'busy' }
+  const heartbeat = maintainLease(options.db, leased, options.now)
+  const executionOptions = { ...options, assertLease: () => heartbeat.assert() }
+
+  try {
+    await heartbeat.ready()
+    if (leased.phase === 'paying' && leased.statement && leased.evidence) {
+      await deliver(
+        executionOptions,
+        campaign,
+        leased,
+        bindings,
+        leased.statement,
+        restoreCalculation(leased.evidence),
+        signer.signer,
+      )
+      const result = {
+        notification: await notificationSummary(options.db, campaign, leased.id),
+        runId: leased.id,
+        staleRates: leased.evidence.staleRates ?? [],
+        status: 'delivered' as const,
+      }
+      const leaseFailure = await heartbeat.stop()
+      if (leaseFailure !== undefined) throw leaseFailure
+      return result
+    }
+    if (!['indexing', 'calculating', 'targetYield', 'statement'].includes(leased.phase))
+      throw new Error(`Unsupported reward recovery phase ${leased.phase}.`)
+    const checkpoint = await RewardRuns.getCheckpoint(options.db, { id: leased.id })
+    const calculated =
+      leased.evidence && !checkpoint
+        ? restoreCalculation(leased.evidence)
+        : await calculate(executionOptions, campaign, leased, bindings)
+    const targetAttempt =
+      leased.phase === 'statement'
+        ? undefined
+        : await settleTargetYield(
+            executionOptions,
+            campaign,
+            leased,
+            bindings,
+            calculated,
+            signer.signer,
+          )
+    const settlement = await settleBoost(
+      executionOptions,
+      campaign,
+      leased,
+      bindings,
+      calculated,
+      signer.signer,
+    )
+    // The leased record and initial calculation predate settlement, so delivery consumes the evidence returned by settlement.
+    await deliver(
+      executionOptions,
+      campaign,
+      leased,
+      bindings,
+      settlement?.statement,
+      settlement ? { ...calculated, evidence: settlement.evidence } : calculated,
+      signer.signer,
+    )
+    const result = {
+      notification: await notificationSummary(options.db, campaign, leased.id),
+      runId: leased.id,
+      staleRates: calculated.evidence.staleRates ?? [],
+      status: 'delivered' as const,
+      targetAttempt,
+    }
+    const leaseFailure = await heartbeat.stop()
+    if (leaseFailure !== undefined) throw leaseFailure
+    return result
+  } catch (cause) {
+    await heartbeat.stop()
+    await RewardRuns.releaseWithError(options.db, {
+      error: cause instanceof Error ? cause.message : 'Reward run failed.',
+      fence: leased.fence,
+      id: leased.id,
+    })
+    throw cause
+  }
+}
+
+export declare namespace run {
+  /** Runtime dependencies injected by the API Worker. */
+  type Options = {
+    /** Authoritative Postgres connection. */
+    db: Db.Db
+    /** Reviewed rewards factory. */
+    factory: Address
+    /** Chain-aware RPC client factory. */
+    getClient: Viem.GetClient
+    /** Chain-aware TIDX client factory. */
+    getTidx: Tidx.GetClient
+    /** HTTP implementation for external rate sources. */
+    fetch: typeof globalThis.fetch
+    /** Compact queue reference. */
+    message: Message
+    /** Clock used to determine closed interval boundaries. */
+    now: () => number
+    /** Isolated signer service transport. */
+    signerFetch: typeof globalThis.fetch
+    /** Internal lease assertion installed after a run is acquired. */
+    assertLease?: (() => Promise<void>) | undefined
+    /** Hosted Zone metadata used to exclude infrastructure custody. */
+    zones: readonly {
+      contracts?: Record<string, unknown> | undefined
+      sourceId?: number | undefined
+    }[]
+  }
+
+  /** Observable queue outcome. */
+  type Result = {
+    /** Confirmed run details used by operational notifications. */
+    notification?: Notification | undefined
+    /** Durable run identity when work existed. */
+    runId?: string | undefined
+    /** Whether another worker owns the lease, no work was due, or delivery completed. */
+    status: 'busy' | 'delivered' | 'idle'
+    /** Rate sources that reused a bounded prior observation. */
+    staleRates?: readonly ('organic' | 'target')[] | undefined
+    /** Confirmed target-yield transaction, when one was needed. */
+    targetAttempt?: Hex | undefined
+  }
+
+  /** Concise confirmed run details used by operational notifications. */
+  type Notification = {
+    /** Base-asset decimals. */
+    assetDecimals: number
+    /** Higher of the organic and active target-yield rates at the closing boundary. */
+    baseRateBps: number
+    /** Incremental boost annual rate applied at the closing boundary. */
+    boostRateBps?: number | undefined
+    /** Number of accounting intervals covered by the run. */
+    intervalCount: number
+    /** Confirmed depositor payout, when this run pushed rewards. */
+    payout?: {
+      /** Recipients retaining an unpaid cumulative entitlement. */
+      deferredRecipients: number
+      /** Recipients receiving an EarnShare transfer during this run. */
+      paidRecipients: number
+      /** Confirmed payout transaction hashes. */
+      transactionHashes: readonly Hex[]
+    }
+    /** Confirmed boost settlement, when this run published a root. */
+    settlement?: {
+      /** Base-asset units represented by this root increment. */
+      assetAmount: string
+      /** Recipients receiving a positive allocation. */
+      creditedRecipients: number
+      /** Newly credited recipients retaining an unpaid entitlement after delivery. */
+      deferredRecipients: number
+      /** Confirmed root publication transaction hash. */
+      transactionHash: Hex
+    }
+    /** Target-yield evaluation for the run, including a confirmed funding transaction when needed. */
+    targetYield?: {
+      /** Base-asset units funded across configured funding legs. */
+      assetAmount: string
+      /** Confirmed funding transaction hash, omitted when no top-up was needed. */
+      transactionHash?: Hex | undefined
+    }
+    /** Curated vault label configured by an administrator. */
+    vaultLabel: string
+  }
+}
+
+type Bindings = {
+  controller?: Address | undefined
+  distributor?: Address | undefined
+}
+
+type Calculation = {
+  accounts: Projection.Account[]
+  closingCursor?: Campaigns.EventCursor | undefined
+  evidence: Campaigns.RunEvidence
+}
+
+function provisioningPlan(campaign: RewardCampaigns.Record): {
+  boostRewards: Campaigns.Config['boostRewards']
+  configMatch: Campaigns.Config
+  targetYield: Campaigns.Config['targetYield']
+} {
+  const pending = campaign.pendingConfig
+  const needsPendingController = Boolean(pending?.targetYield && !campaign.controllerAddress)
+  const needsPendingDistributor = Boolean(pending?.boostRewards && !campaign.distributorAddress)
+  return {
+    boostRewards: campaign.config.boostRewards ?? pending?.boostRewards,
+    configMatch:
+      pending && (needsPendingController || needsPendingDistributor) ? pending : campaign.config,
+    targetYield: campaign.config.targetYield ?? pending?.targetYield,
+  }
+}
+
+async function provision(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  signer: Address,
+): Promise<Bindings> {
+  const plan = provisioningPlan(campaign)
+  if (campaign.signerAddress && !isAddressEqual(campaign.signerAddress, signer))
+    throw new Error('Reward signer does not match the campaign signer.')
+  const client = options.getClient(campaign.chainId)
+  const vault = getAddress(campaign.vaultAddress)
+  const treasury = plan.boostRewards?.treasury
+  const [predictedController, predictedDistributor] = await Promise.all([
+    plan.targetYield
+      ? client.readContract({
+          abi: factoryAbi,
+          address: options.factory,
+          args: [vault, signer],
+          functionName: 'predictContributionController',
+        })
+      : undefined,
+    plan.boostRewards && treasury
+      ? client.readContract({
+          abi: factoryAbi,
+          address: options.factory,
+          args: [vault, signer, treasury, claimDeadline],
+          functionName: 'predictMerkleDistributor',
+        })
+      : undefined,
+  ])
+  if (
+    campaign.controllerAddress &&
+    predictedController &&
+    !isAddressEqual(campaign.controllerAddress, predictedController)
+  )
+    throw new Error('Stored contribution controller does not match the campaign signer.')
+  if (
+    campaign.distributorAddress &&
+    predictedDistributor &&
+    !isAddressEqual(campaign.distributorAddress, predictedDistributor)
+  )
+    throw new Error('Stored Merkle distributor does not match the campaign signer.')
+  const controller = plan.targetYield
+    ? getAddress(campaign.controllerAddress ?? predictedController!)
+    : undefined
+  const distributor = plan.boostRewards
+    ? getAddress(campaign.distributorAddress ?? predictedDistributor!)
+    : undefined
+  const code = await Promise.all(
+    [controller, distributor]
+      .filter((address): address is Address => Boolean(address))
+      .map((address) => client.getCode({ address })),
+  )
+  if (code.some((runtime) => !runtime)) {
+    const intent = {
+      boostRewards: Boolean(plan.boostRewards),
+      domain: domain(options, campaign, {
+        ...(plan.boostRewards ? { boostRewards: plan.boostRewards } : {}),
+        ...(plan.targetYield ? { targetYield: plan.targetYield } : {}),
+      }),
+      operation: 'deploy' as const,
+      targetYield: Boolean(plan.targetYield),
+      treasury: treasury ?? '0x0000000000000000000000000000000000000000',
+    }
+    await execute(options, campaign, undefined, signer, intent)
+  }
+  for (const address of [controller, distributor])
+    if (address && !(await client.getCode({ address })))
+      throw new Error(`Reward periphery was not deployed at ${address}.`)
+  // A failed first deployment must not permanently bind a misconfigured signer.
+  const bound = await RewardCampaigns.bindSigner(options.db, {
+    chainId: campaign.chainId,
+    signerAddress: signer,
+    vaultAddress: vault,
+  })
+  if (!bound) throw new Error('Reward signer does not match the campaign signer.')
+  const stored = await RewardCampaigns.setBindings(options.db, {
+    chainId: campaign.chainId,
+    config: plan.configMatch,
+    ...(controller ? { controllerAddress: controller } : {}),
+    ...(distributor ? { distributorAddress: distributor } : {}),
+    error: null,
+    signerAddress: signer,
+    vaultAddress: vault,
+  })
+  if (!stored) throw new Error('Reward campaign changed during periphery provisioning.')
+  return {
+    ...(controller ? { controller } : {}),
+    ...(distributor ? { distributor } : {}),
+  }
+}
+
+async function calculate(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  bindings: Bindings,
+): Promise<Calculation> {
+  await requireTransition(options.db, runRecord, 'calculating', {})
+  const client = options.getClient(campaign.chainId)
+  const tidx = options.getTidx(campaign.chainId)
+  const startsAfter = Number(runRecord.startsAfter)
+  const endsAt = Number(runRecord.endsAt)
+  const intervalSeconds = Campaigns.intervalSeconds(campaign.config)
+  const openingBoundary = await Events.boundary(tidx, startsAfter)
+  const closingBoundary = await Events.boundary(tidx, endsAt)
+  const boost = campaign.config.boostRewards
+  const boostTracks = Boolean(
+    boost && Campaigns.overlapsCompleteIntervals(boost, { endsAt, startsAfter }),
+  )
+  const storedCheckpoint = await RewardRuns.getCheckpoint(options.db, { id: runRecord.id })
+  const eligible = boostTracks ? await allEligible(options.db, campaign) : []
+  const eligibilityCheckpoint = eligible.at(-1)?.registrationOrder ?? '0'
+  const eligibilityVersion = Campaigns.eligibilityVersion(eligible)
+  const excluded = boostTracks ? await exclusions(options, campaign, bindings) : []
+  const exclusionVersion = Campaigns.exclusionVersion(excluded)
+  const saved = resumeCheckpoint(storedCheckpoint, { eligibilityVersion, exclusionVersion })
+  const stored = await RewardAccounts.list(options.db, campaign)
+  let accounts = stored.map(Projection.fromRecord)
+  let startingCursor = campaign.eventCursor
+  if (boost && boostTracks) {
+    const excludedSet = new Set(excluded.map((address) => address.toLowerCase()))
+    const registrations = eligible
+      .filter((entry) => {
+        const address = entry.walletAddress.toLowerCase()
+        return !excludedSet.has(address)
+      })
+      .map((entry) => ({
+        recipient: entry.walletAddress,
+        registeredAt: entry.latestRegisteredAt,
+        registrationOrder: BigInt(entry.registrationOrder),
+      }))
+    const accountsByRecipient = new Map(
+      accounts.map((account) => [account.recipient.toLowerCase(), account]),
+    )
+    const reconcile = registrations.some((entry) => {
+      const account = accountsByRecipient.get(entry.recipient.toLowerCase())
+      return account?.eligibilityRegisteredAt !== entry.registeredAt
+    })
+    const replayRegistrations = registrations.filter((entry) => {
+      const account = accountsByRecipient.get(entry.recipient.toLowerCase())
+      return (
+        account?.eligibilityRegisteredAt !== entry.registeredAt &&
+        (!account ||
+          (account.allocatedPrincipalAssets === 0n &&
+            account.lots.length === 0 &&
+            account.qualifiedEarnShares === 0n))
+      )
+    })
+    if (reconcile && saved?.stage !== 'calculate') {
+      const resume = saved?.stage === 'reconcile' && saved.projection.pass ? saved : undefined
+      let cursor = resume?.projection.replayedThrough
+      const principalAllocationOrder =
+        stored.length === 0 && Number(campaign.deliveredThrough) === boost.startTimestamp
+          ? 'deposit'
+          : 'registration'
+      accounts = [
+        ...(
+          await Projection.reconcilePages({
+            accounts,
+            ...(resume
+              ? {
+                  checkpoint: {
+                    accounts: resume.projection.accounts,
+                    ...(resume.projection.allocationRecipient
+                      ? { allocationRecipient: resume.projection.allocationRecipient }
+                      : {}),
+                    ...(resume.projection.consumedEarnShares
+                      ? { consumedEarnShares: resume.projection.consumedEarnShares }
+                      : {}),
+                    depositedEarnShares: resume.projection.depositedEarnShares ?? {},
+                    ...(resume.cursor ? { cursor: resume.cursor } : {}),
+                    pass: resume.projection.pass!,
+                    ...(resume.projection.replayedThrough
+                      ? { replayedThrough: resume.projection.replayedThrough }
+                      : {}),
+                  },
+                }
+              : {}),
+            checkpointState: async (projection) => {
+              cursor = projection.replayedThrough
+              const persisted = await RewardRuns.writeCheckpoint(options.db, {
+                evidence: {
+                  ...(projection.cursor ? { cursor: projection.cursor } : {}),
+                  kind: 'checkpoint',
+                  progress: { eligibilityCheckpoint, eligibilityVersion, exclusionVersion },
+                  projection,
+                  stage: 'reconcile',
+                },
+                fence: runRecord.fence,
+                id: runRecord.id,
+              })
+              if (!persisted) throw new Error('Reward run lease was lost.')
+            },
+            eligible: registrations,
+            excluded,
+            pages: (pass, after) =>
+              pass === 'survival' || principalAllocationOrder === 'deposit'
+                ? reconciliationEventPages(
+                    Events.accountEventPages(tidx, {
+                      ...(after ? { after } : {}),
+                      accounts: replayRegistrations.map((entry) => entry.recipient),
+                      earnShare: campaign.earnShareAddress,
+                      earnVault: campaign.vaultAddress,
+                      throughBlock: openingBoundary.blockNumber,
+                    }),
+                  )
+                : registrationDepositPages(tidx, {
+                    ...(after ? { after } : {}),
+                    ...(resume?.projection.allocationRecipient
+                      ? { afterRecipient: resume.projection.allocationRecipient }
+                      : {}),
+                    accounts: replayRegistrations,
+                    earnVault: campaign.vaultAddress,
+                    throughBlock: openingBoundary.blockNumber,
+                  }),
+            perUserPrincipalCapAssets: BigInt(boost.perUserPrincipalCapAssets),
+            // Initial allocation follows deposits; later registrations share the remaining cap by registration order.
+            principalAllocationOrder,
+            totalPrincipalCapAssets: BigInt(boost.totalPrincipalCapAssets),
+          })
+        ).accounts,
+      ]
+      startingCursor = reconciledCursor({ committed: startingCursor, replayed: cursor })
+    }
+  }
+  const targetConfig = campaign.config.targetYield
+  const targetActive = Boolean(
+    targetConfig && Campaigns.overlapsCompleteIntervals(targetConfig, { endsAt, startsAfter }),
+  )
+  if (saved?.stage === 'calculate') {
+    accounts = saved.projection.accounts.map(Projection.fromSnapshot)
+    startingCursor = saved.cursor ?? startingCursor
+  }
+  let eventCursor =
+    boost && accounts.length > 0
+      ? startingCursor
+      : {
+          blockNumber: openingBoundary.blockNumber,
+          logIndex: Number.MAX_SAFE_INTEGER,
+          transactionIndex: Number.MAX_SAFE_INTEGER,
+        }
+  const capitalChanges = targetActive
+    ? await Events.capitalChanges(tidx, {
+        afterBlock: openingBoundary.blockNumber,
+        earnShare: campaign.earnShareAddress,
+        throughBlock: closingBoundary.blockNumber,
+      })
+    : []
+  const boostAccrues = Boolean(
+    boost &&
+    boost.enabled !== false &&
+    Campaigns.overlapsCompleteIntervals(boost, { endsAt, startsAfter }),
+  )
+  // Carry external target observations and exact funding remainders through inactive intervals
+  // so a later schedule resumption reads the latest durable evidence.
+  const previous = await RewardRuns.latestDelivered(options.db, campaign)
+  const target = targetActive
+    ? (checkpointTargetRate(saved, targetConfig!) ??
+      (await targetRate(options, campaign, runRecord)))
+    : undefined
+  const targetRateProgress = target
+    ? {
+        ...(target.stale ? { staleRates: ['target' as const] } : {}),
+        targetRateBps: target.annualRateBps,
+        targetRateObservedAt: target.observedAt,
+      }
+    : {}
+  const contributions =
+    target || boostAccrues
+      ? await Events.contributions(tidx, {
+          afterBlock: openingBoundary.blockNumber,
+          earnVault: campaign.vaultAddress,
+          throughBlock: closingBoundary.blockNumber,
+        })
+      : []
+  let latestBoostRate = saved?.progress.boostRateBps ?? 0
+  type RateObservation = { observedAt: string; rate: number }
+  let latestOrganicRate: RateObservation | undefined =
+    saved?.progress.organicRateBps !== undefined && saved.progress.organicRateObservedAt
+      ? {
+          observedAt: saved.progress.organicRateObservedAt,
+          rate: saved.progress.organicRateBps,
+        }
+      : undefined
+  const intervals: Campaigns.RunEvidence['intervals'][number][] = [
+    ...(saved?.progress.intervals ?? []),
+  ]
+  const targetAssets = target
+    ? (saved?.progress.targetFundingAssets?.map(BigInt) ?? target.config.funding.map(() => 0n))
+    : []
+  const carryTargetRemainders = Boolean(
+    targetConfig && sameTargetFunding(previous?.config.targetYield?.funding, targetConfig.funding),
+  )
+  const targetRemainders = targetConfig
+    ? (saved?.progress.targetFundingRemainders?.map(BigInt) ??
+      targetConfig.funding.map((_, index) =>
+        BigInt(
+          carryTargetRemainders ? (previous?.evidence?.targetFundingRemainders?.[index] ?? 0) : 0,
+        ),
+      ))
+    : []
+  let projectionCheckpoint = saved?.stage === 'calculate' ? saved : undefined
+  for (
+    let end = startsAfter + (intervals.length + 1) * intervalSeconds;
+    end <= endsAt;
+    end += intervalSeconds
+  ) {
+    const start = end - intervalSeconds
+    const intervalOpening =
+      start === startsAfter ? openingBoundary : await Events.boundary(tidx, start)
+    const boundary = end === endsAt ? closingBoundary : await Events.boundary(tidx, end)
+    const sharePrice = await client.readContract({
+      abi: vaultAbi,
+      address: campaign.vaultAddress,
+      args: [10n ** 18n],
+      blockNumber: BigInt(intervalOpening.blockNumber),
+      functionName: 'previewRedeem',
+    })
+    const closingSharePrice = await client.readContract({
+      abi: vaultAbi,
+      address: campaign.vaultAddress,
+      args: [10n ** 18n],
+      blockNumber: BigInt(boundary.blockNumber),
+      functionName: 'previewRedeem',
+    })
+    const targetIntervalActive = Boolean(
+      target && end > target.config.startTimestamp && end <= target.config.endTimestamp,
+    )
+    const boostActive = Boolean(
+      boost && boost.enabled !== false && end > boost.startTimestamp && end <= boost.endTimestamp,
+    )
+    const intervalContributions = contributions
+      .filter((entry) => entry.timestamp >= start && entry.timestamp < end)
+      .map((entry) => ({ assets: entry.assets, earnShareSupply: entry.earnShareSupply }))
+    const growth =
+      targetIntervalActive || boostActive
+        ? await (async () => {
+            const [totalAssets, openingEarnShareSupply] = await Promise.all([
+              client.readContract({
+                abi: vaultAbi,
+                address: campaign.vaultAddress,
+                blockNumber: BigInt(intervalOpening.blockNumber),
+                functionName: 'totalAssets',
+              }),
+              feeInclusiveEarnShareSupply(
+                client,
+                campaign.vaultAddress,
+                BigInt(intervalOpening.blockNumber),
+              ),
+            ])
+            const assets = Campaigns.organicGrowth({
+              closingValuePerEarnShare: closingSharePrice,
+              contributions: intervalContributions,
+              openingAssets: totalAssets,
+              openingEarnShareSupply,
+              openingValuePerEarnShare: sharePrice,
+            })
+            return {
+              annualRateBps: Campaigns.annualRateBps({
+                elapsedSeconds: intervalSeconds,
+                growthAssets: assets,
+                principalAssets: totalAssets,
+              }),
+              opening: {
+                openingAssets: totalAssets,
+                openingEarnShareSupply,
+                openingValuePerEarnShare: sharePrice,
+              },
+            }
+          })()
+        : undefined
+    if (boostActive && growth)
+      latestOrganicRate = {
+        observedAt: new Date(end * 1_000).toISOString(),
+        rate: growth.annualRateBps,
+      }
+    const intervalBoostRate =
+      boost && boostActive
+        ? Campaigns.rewardRates({
+            boostTargetRateBps: boost.targetAnnualRateBps,
+            organicRateBps: growth?.annualRateBps ?? 0,
+            ...(targetIntervalActive ? { targetRateBps: target!.annualRateBps } : {}),
+          }).boostRateBps
+        : 0
+    if (boostActive) latestBoostRate = intervalBoostRate
+    const resume = projectionCheckpoint
+    const pages =
+      boost && accounts.length > 0
+        ? Events.accountEventPages(tidx, {
+            ...(eventCursor ? { after: eventCursor } : {}),
+            accounts: accounts.map((account) => account.recipient),
+            earnShare: campaign.earnShareAddress,
+            earnVault: campaign.vaultAddress,
+            throughBlock: boundary.blockNumber,
+          })
+        : emptyEventPages()
+    const result = boost
+      ? await Projection.calculatePages({
+          accounts,
+          annualRateBps: intervalBoostRate,
+          assetPerEarnShareWad: sharePrice,
+          ...(resume
+            ? {
+                checkpoint: {
+                  accounts: resume.projection.accounts,
+                  accruedThrough: resume.projection.accruedThrough ?? {},
+                  weightedEarnShareSeconds: resume.projection.weightedEarnShareSeconds ?? {},
+                },
+              }
+            : {}),
+          checkpointState: async (projection, cursor) => {
+            eventCursor = cursor
+            const persisted = await RewardRuns.writeCheckpoint(options.db, {
+              evidence: {
+                cursor,
+                kind: 'checkpoint',
+                progress: {
+                  boostRateBps: latestBoostRate,
+                  eligibilityCheckpoint,
+                  eligibilityVersion,
+                  exclusionVersion,
+                  intervals,
+                  ...(latestOrganicRate
+                    ? {
+                        organicRateBps: latestOrganicRate.rate,
+                        organicRateObservedAt: latestOrganicRate.observedAt,
+                      }
+                    : {}),
+                  ...targetRateProgress,
+                  targetFundingAssets: targetAssets.map(String),
+                  targetFundingRemainders: targetRemainders.map(String),
+                },
+                projection,
+                stage: 'calculate',
+              },
+              fence: runRecord.fence,
+              id: runRecord.id,
+            })
+            if (!persisted) throw new Error('Reward run lease was lost.')
+          },
+          endsAt: end,
+          excluded,
+          pages,
+          perUserPrincipalCapAssets: BigInt(boost.perUserPrincipalCapAssets),
+          startsAt: start,
+          totalPrincipalCapAssets: BigInt(boost.totalPrincipalCapAssets),
+        })
+      : { accounts, rewards: new Map<Address, bigint>() }
+    projectionCheckpoint = undefined
+    accounts = [...result.accounts]
+    intervals.push({
+      assetPerEarnShareWad: sharePrice.toString(),
+      assetRewards: Object.fromEntries(
+        [...result.rewards].map(([recipient, amount]) => [
+          recipient.toLowerCase(),
+          amount.toString(),
+        ]),
+      ),
+      blockNumber: boundary.blockNumber,
+      ...(boost ? { boostRateBps: intervalBoostRate } : {}),
+      endsAt: end,
+      ...(growth ? { organicRateBps: growth.annualRateBps } : {}),
+      startsAt: start,
+    })
+    if (target && targetIntervalActive) {
+      if (!growth) throw new Error('Target-yield interval lacks organic growth evidence.')
+      const periods: Campaigns.targetFunding.Period[] = []
+      let opening = {
+        ...growth.opening,
+        blockNumber: intervalOpening.blockNumber,
+        timestamp: start,
+      }
+      // Read post-change principal so a boundary deposit earns only until its redemption block.
+      const states = await capitalStates(client, {
+        boundaries: capitalChanges.filter(
+          (entry) => entry.timestamp >= start && entry.timestamp < end,
+        ),
+        vaultAddress: campaign.vaultAddress,
+      })
+      for (const closing of [
+        ...states,
+        {
+          ...growth.opening,
+          blockNumber: boundary.blockNumber,
+          openingValuePerEarnShare: closingSharePrice,
+          timestamp: end,
+        },
+      ]) {
+        periods.push({
+          closingValuePerEarnShare: closing.openingValuePerEarnShare,
+          contributions: contributions.filter(
+            (entry) =>
+              entry.cursor.blockNumber > opening.blockNumber &&
+              entry.cursor.blockNumber <= closing.blockNumber,
+          ),
+          elapsedSeconds: closing.timestamp - opening.timestamp,
+          openingAssets: opening.openingAssets,
+          openingEarnShareSupply: opening.openingEarnShareSupply,
+          openingValuePerEarnShare: opening.openingValuePerEarnShare,
+        })
+        opening = closing
+      }
+      const funding = Campaigns.targetFunding({
+        annualRateBps: target.annualRateBps,
+        funding: target.config.funding,
+        periods,
+        remainders: targetRemainders,
+      })
+      funding.assets.forEach((amount, index) => {
+        targetAssets[index] = (targetAssets[index] ?? 0n) + amount
+        targetRemainders[index] = funding.remainders[index]!
+      })
+    }
+    const persisted = await RewardRuns.writeCheckpoint(options.db, {
+      evidence: {
+        ...(eventCursor ? { cursor: eventCursor } : {}),
+        kind: 'checkpoint',
+        progress: {
+          boostRateBps: latestBoostRate,
+          eligibilityCheckpoint,
+          eligibilityVersion,
+          exclusionVersion,
+          intervals,
+          ...(latestOrganicRate
+            ? {
+                organicRateBps: latestOrganicRate.rate,
+                organicRateObservedAt: latestOrganicRate.observedAt,
+              }
+            : {}),
+          ...targetRateProgress,
+          targetFundingAssets: targetAssets.map(String),
+          targetFundingRemainders: targetRemainders.map(String),
+        },
+        projection: { accounts: accounts.map(Projection.snapshot) },
+        stage: 'calculate',
+      },
+      fence: runRecord.fence,
+      id: runRecord.id,
+    })
+    if (!persisted) throw new Error('Reward run lease was lost.')
+  }
+  const priorTarget = (() => {
+    if (
+      !targetConfig ||
+      target ||
+      previous?.evidence?.targetRateBps === undefined ||
+      !previous.evidence.targetRateObservedAt ||
+      !sameRateSource(previous.config.targetYield?.annualRate, targetConfig.annualRate)
+    )
+      return undefined
+    return {
+      observedAt: previous.evidence.targetRateObservedAt,
+      rate: previous.evidence.targetRateBps,
+    }
+  })()
+  const targetEvidence = (() => {
+    if (target)
+      return {
+        appliedTargetRateBps: target.annualRateBps,
+        targetFundingAssets: targetAssets.map(String),
+        targetFundingRemainders: targetRemainders.map(String),
+        targetPrincipalMethod: 'time-weighted:v1' as const,
+        targetRateBps: target.annualRateBps,
+        targetRateObservedAt: target.observedAt,
+      }
+    if (!targetConfig) return {}
+    return {
+      targetFundingRemainders: targetRemainders.map(String),
+      ...(priorTarget
+        ? {
+            targetRateBps: priorTarget.rate,
+            targetRateObservedAt: priorTarget.observedAt,
+          }
+        : {}),
+    }
+  })()
+  const evidence: Campaigns.RunEvidence = {
+    ...(boost ? { boostRateBps: latestBoostRate } : {}),
+    closingAccounts: accounts.map(Projection.snapshot),
+    eligibilityCheckpoint,
+    eligibilityVersion,
+    exclusionVersion,
+    ...(eventCursor ? { eventCursor } : {}),
+    intervals,
+    ...(target?.stale
+      ? {
+          staleRates: ['target' as const],
+        }
+      : {}),
+    ...(latestOrganicRate
+      ? {
+          organicRateBps: latestOrganicRate.rate,
+          organicRateObservedAt: latestOrganicRate.observedAt,
+        }
+      : {}),
+    stateChecksum: Projection.checksum(accounts),
+    ...targetEvidence,
+  }
+  await requireTransition(options.db, runRecord, 'targetYield', { evidence })
+  return { accounts, ...(eventCursor ? { closingCursor: eventCursor } : {}), evidence }
+}
+
+async function settleTargetYield(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  bindings: Bindings,
+  calculation: Calculation,
+  signer: Address,
+): Promise<Hex | undefined> {
+  const target = campaign.config.targetYield
+  if (!target || !bindings.controller) return undefined
+  const requestedAssets = Campaigns.targetFundingAssets(calculation.evidence)
+  if (requestedAssets.every((amount) => amount === 0n)) return undefined
+  const active = target.funding.flatMap((leg, index) => {
+    const amount = requestedAssets[index] ?? 0n
+    return amount > 0n ? [{ amount, wallet: leg.wallet }] : []
+  })
+  const previous = await RewardTransactionAttempts.latestRecoverable(options.db, {
+    operation: 'targetYield',
+    runId: runRecord.id,
+  })
+  const intent = previous?.signedBytes
+    ? Signer.schema.Request.parse({
+        attemptId: previous.id,
+        id: previous.intentId,
+        intent: previous.intent.payload,
+      }).intent
+    : {
+        controller: bindings.controller,
+        domain: domain(options, campaign),
+        funders: active.map((leg) => leg.wallet),
+        maxEarnShareSupply: (
+          await feeInclusiveEarnShareSupply(
+            options.getClient(campaign.chainId),
+            campaign.vaultAddress,
+          )
+        ).toString(),
+        operation: 'targetYield' as const,
+        requestedAssets: active.map((leg) => leg.amount.toString()),
+      }
+  if (intent.operation !== 'targetYield')
+    throw new Error('Stored target-yield attempt contains another operation.')
+  const attempt = await execute(options, campaign, runRecord.id, signer, intent)
+  if (!attempt.transactionHash) throw new Error('Target-yield transaction lacks a hash.')
+  const receipt = await options
+    .getClient(campaign.chainId)
+    .getTransactionReceipt({ hash: attempt.transactionHash })
+  const funded = parseEventLogs({
+    abi: controllerAbi,
+    eventName: 'Funded',
+    logs: receipt.logs,
+    strict: true,
+  }).filter((event) => isAddressEqual(event.address, bindings.controller!))
+  const exact =
+    funded.length === active.length &&
+    funded.every((event, index) => {
+      const expected = active[index]!
+      return (
+        isAddressEqual(event.args.funder, expected.wallet) &&
+        event.args.requestedAssets === expected.amount &&
+        event.args.fundedAssets === expected.amount
+      )
+    })
+  if (!exact) {
+    const retryableZeroFunding =
+      active.length === 1 &&
+      funded.length === 1 &&
+      isAddressEqual(funded[0]!.args.funder, active[0]!.wallet) &&
+      funded[0]!.args.requestedAssets === active[0]!.amount &&
+      funded[0]!.args.fundedAssets === 0n
+    if (retryableZeroFunding) {
+      const ineffective = await RewardTransactionAttempts.markIneffective(options.db, attempt.id)
+      if (!ineffective)
+        throw new Error('Confirmed zero target-yield funding could not be marked for retry.')
+      throw new Error('Target-yield funding settled zero assets and will be retried.')
+    }
+    throw new Error('Target-yield funding did not settle every requested asset exactly.')
+  }
+  return attempt.transactionHash ?? undefined
+}
+
+/** Reads historical capital states in bounded waves, preserving order and rejecting incomplete evidence. */
+export async function capitalStates(
+  client: Pick<Viem.getClient.ReturnType, 'readContract'>,
+  options: capitalStates.Options,
+): Promise<capitalStates.State[]> {
+  const states: capitalStates.State[] = []
+  for (let offset = 0; offset < options.boundaries.length; offset += capitalStateBatchSize) {
+    const results = await Promise.allSettled(
+      options.boundaries.slice(offset, offset + capitalStateBatchSize).map(async (boundary) => {
+        const blockNumber = BigInt(boundary.blockNumber)
+        const reads = await Promise.allSettled([
+          client.readContract({
+            abi: vaultAbi,
+            address: options.vaultAddress,
+            blockNumber,
+            functionName: 'totalAssets',
+          }),
+          feeInclusiveEarnShareSupply(client, options.vaultAddress, blockNumber),
+          client.readContract({
+            abi: vaultAbi,
+            address: options.vaultAddress,
+            args: [10n ** 18n],
+            blockNumber,
+            functionName: 'previewRedeem',
+          }),
+        ])
+        const [openingAssets, openingEarnShareSupply, openingValuePerEarnShare] = reads.map(
+          (result) => {
+            if (result.status === 'rejected') throw result.reason
+            return result.value
+          },
+        )
+        return {
+          ...boundary,
+          openingAssets: openingAssets!,
+          openingEarnShareSupply: openingEarnShareSupply!,
+          openingValuePerEarnShare: openingValuePerEarnShare!,
+        }
+      }),
+    )
+    for (const result of results) {
+      if (result.status === 'rejected') throw result.reason
+      states.push(result.value)
+    }
+  }
+  return states
+}
+
+export declare namespace capitalStates {
+  /** Historical blocks required for one accounting interval. */
+  type Options = {
+    /** Ordered supply-change boundaries. */
+    boundaries: readonly Events.boundary.Result[]
+    /** Vault whose principal and fee-inclusive conversion are sampled. */
+    vaultAddress: Address
+  }
+
+  /** Historical principal and conversion at a supply-change boundary. */
+  type State = Events.boundary.Result &
+    Omit<Campaigns.organicGrowth.Options, 'closingValuePerEarnShare' | 'contributions'>
+}
+
+async function feeInclusiveEarnShareSupply(
+  client: Pick<Viem.getClient.ReturnType, 'readContract'>,
+  vault: Address,
+  blockNumber?: bigint,
+): Promise<bigint> {
+  const [earnFees, supply] = await Promise.all([
+    client.readContract({ abi: vaultAbi, address: vault, blockNumber, functionName: 'earnFees' }),
+    client.readContract({
+      abi: vaultAbi,
+      address: vault,
+      blockNumber,
+      functionName: 'totalEarnShares',
+    }),
+  ])
+  const preview = await client.readContract({
+    abi: feesAbi,
+    address: earnFees,
+    blockNumber,
+    functionName: 'previewAccruedFees',
+  })
+  return supply + preview.totalFeeEarnShares
+}
+
+async function settleBoost(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  bindings: Bindings,
+  calculation: Calculation,
+  signer: Address,
+): Promise<{ evidence: Campaigns.RunEvidence; statement: Campaigns.Statement } | undefined> {
+  const boost = campaign.config.boostRewards
+  if (!boost || !bindings.distributor) {
+    await commit(options.db, campaign, runRecord, calculation.accounts, calculation.closingCursor)
+    return undefined
+  }
+  if (runRecord.phase === 'statement')
+    return publishPreparedStatement(options, campaign, runRecord, bindings.distributor, signer)
+  const rewardAssets = calculation.accounts.reduce(
+    (sum, account) => sum + account.pendingRewardAssets,
+    0n,
+  )
+  if (rewardAssets <= 1n) {
+    const hasDeferred = calculation.accounts.some(
+      (account) => account.cumulativePaid < account.cumulativeEntitlement,
+    )
+    const previous = hasDeferred
+      ? await RewardRuns.latestStatement(options.db, campaign)
+      : undefined
+    if (
+      previous?.statement &&
+      previous.root &&
+      previous.rootVersion &&
+      previous.statementHash &&
+      previous.liability
+    ) {
+      const evidence = {
+        ...calculation.evidence,
+        closingAccounts: calculation.accounts.map(Projection.snapshot),
+      }
+      await requireTransition(options.db, runRecord, 'paying', {
+        evidence,
+        fundedAssets: '0',
+        liability: previous.liability,
+        mintedEarnShares: '0',
+        root: previous.root,
+        rootVersion: previous.rootVersion,
+        statement: previous.statement,
+        statementHash: previous.statementHash,
+      })
+      return { evidence, statement: previous.statement }
+    }
+    await commit(options.db, campaign, runRecord, calculation.accounts, calculation.closingCursor)
+    return undefined
+  }
+  const client = options.getClient(campaign.chainId)
+  const quote = await vaultQuote(client, campaign.vaultAddress)
+  const desiredShares = Campaigns.assetsToEarnShares({ assets: rewardAssets, ...quote })
+  // Preserve sub-share rewards until enough assets accrue to mint at least one EarnShare.
+  if (desiredShares === 0n) {
+    await commit(options.db, campaign, runRecord, calculation.accounts, calculation.closingCursor)
+    return undefined
+  }
+  const allocation = Campaigns.allocate({
+    earnShares: desiredShares,
+    rewards: calculation.accounts.map((account) => ({
+      assets: account.pendingRewardAssets,
+      recipient: account.recipient,
+    })),
+  })
+  const settlementRecipientAddresses = [...allocation.entries()]
+    .filter(([, amount]) => amount > 0n)
+    .map(([recipient]) => recipient)
+  for (const account of calculation.accounts) {
+    account.cumulativeEntitlement += allocation.get(account.recipient) ?? 0n
+    account.pendingRewardAssets = 0n
+  }
+  const statement = Campaigns.buildStatement({
+    campaignId: campaignId(campaign.vaultAddress),
+    chainId: campaign.chainId,
+    distributor: bindings.distributor,
+    entitlements: calculation.accounts
+      .filter((account) => account.cumulativeEntitlement > 0n)
+      .map((account) => ({
+        cumulativeAmount: account.cumulativeEntitlement.toString(),
+        recipient: account.recipient,
+      })),
+  })
+  const [version, entitlement, paid, inventory] = await Promise.all([
+    client.readContract({
+      abi: distributorAbi,
+      address: bindings.distributor,
+      functionName: 'rootVersion',
+    }),
+    client.readContract({
+      abi: distributorAbi,
+      address: bindings.distributor,
+      functionName: 'rootTotalEntitlement',
+    }),
+    client.readContract({
+      abi: distributorAbi,
+      address: bindings.distributor,
+      functionName: 'totalPaid',
+    }),
+    client.readContract({
+      abi: erc20Abi,
+      address: campaign.earnShareAddress,
+      args: [bindings.distributor],
+      functionName: 'balanceOf',
+    }),
+  ])
+  if (paid > entitlement)
+    throw new Error('Reward distributor paid total exceeds its published entitlement.')
+  const outstanding = entitlement - paid
+  if (inventory < outstanding)
+    throw new Error('Reward distributor inventory is below its current unpaid liability.')
+  const unreserved = inventory - outstanding
+  const missingEarnShares = desiredShares > unreserved ? desiredShares - unreserved : 0n
+  const fundingEarnShares = Campaigns.settlementFundingEarnShares(missingEarnShares)
+  const fundedAssets =
+    fundingEarnShares > 0n
+      ? Campaigns.earnSharesToAssets({ earnShares: fundingEarnShares, ...quote })
+      : 0n
+  const prepared = await requireTransition(options.db, runRecord, 'statement', {
+    evidence: {
+      ...calculation.evidence,
+      closingAccounts: calculation.accounts.map(Projection.snapshot),
+      publishedRoot: true,
+      settledRewardAssets: rewardAssets.toString(),
+      settlementRecipientAddresses,
+      settlementRecipients: settlementRecipientAddresses.length,
+    },
+    fundedAssets: fundedAssets.toString(),
+    liability: statement.totalEntitlement,
+    mintedEarnShares: missingEarnShares.toString(),
+    root: statement.root,
+    rootVersion: version.toString(),
+    statement,
+    statementHash: statement.statementHash,
+  })
+  return publishPreparedStatement(options, campaign, prepared, bindings.distributor, signer)
+}
+
+async function publishPreparedStatement(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  distributor: Address,
+  signer: Address,
+): Promise<{ evidence: Campaigns.RunEvidence; statement: Campaigns.Statement }> {
+  runRecord = await refreshPreparedStatement(options, campaign, runRecord, distributor)
+  const { evidence, fundedAssets, mintedEarnShares, rootVersion, statement } = runRecord
+  if (
+    !evidence ||
+    !statement ||
+    fundedAssets === null ||
+    mintedEarnShares === null ||
+    rootVersion === null
+  )
+    throw new Error('Prepared reward statement is incomplete.')
+  const publish = {
+    distributor,
+    domain: domain(options, campaign),
+    expectedRootVersion: rootVersion,
+    operation: 'publish' as const,
+    statement,
+  }
+  const intent: Signer.Request['intent'] =
+    BigInt(fundedAssets) === 0n
+      ? publish
+      : {
+          assets: fundedAssets,
+          distributor,
+          domain: publish.domain,
+          expectedRootVersion: rootVersion,
+          funder: campaign.config.boostRewards!.funding.wallet,
+          minEarnShares: mintedEarnShares,
+          operation: 'settle',
+          settlementId: Signer.id(publish),
+          statement,
+        }
+  const attempt = await execute(options, campaign, runRecord.id, signer, intent)
+  if (!attempt.transactionHash) throw new Error('Reward root transaction lacks a hash.')
+  const client = options.getClient(campaign.chainId)
+  const [confirmedVersion, confirmedRoot, confirmedStatementHash, confirmedEntitlement] =
+    await Promise.all([
+      client.readContract({
+        abi: distributorAbi,
+        address: distributor,
+        functionName: 'rootVersion',
+      }),
+      client.readContract({
+        abi: distributorAbi,
+        address: distributor,
+        functionName: 'merkleRoot',
+      }),
+      client.readContract({
+        abi: distributorAbi,
+        address: distributor,
+        functionName: 'statementHash',
+      }),
+      client.readContract({
+        abi: distributorAbi,
+        address: distributor,
+        functionName: 'rootTotalEntitlement',
+      }),
+    ])
+  if (
+    confirmedVersion !== BigInt(rootVersion) + 1n ||
+    confirmedRoot !== statement.root ||
+    confirmedStatementHash !== statement.statementHash ||
+    confirmedEntitlement !== BigInt(statement.totalEntitlement)
+  )
+    throw new Error('Confirmed reward statement does not match the prepared root.')
+  await requireTransition(options.db, runRecord, 'paying', {
+    error: null,
+    rootVersion: confirmedVersion.toString(),
+  })
+  return { evidence, statement }
+}
+
+async function refreshPreparedStatement(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  distributor: Address,
+): Promise<RewardRuns.Record> {
+  const attempts = await RewardTransactionAttempts.listForRun(options.db, runRecord.id)
+  if (
+    attempts.some(
+      (attempt) =>
+        (attempt.intent.operation === 'publish' || attempt.intent.operation === 'settle') &&
+        ['signed', 'broadcast', 'confirmed'].includes(attempt.state),
+    )
+  )
+    return runRecord
+  if (!runRecord.statement || runRecord.rootVersion === null)
+    throw new Error('Prepared reward statement is incomplete.')
+  const client = options.getClient(campaign.chainId)
+  const [version, paid, inventory] = await Promise.all([
+    client.readContract({
+      abi: distributorAbi,
+      address: distributor,
+      functionName: 'rootVersion',
+    }),
+    client.readContract({
+      abi: distributorAbi,
+      address: distributor,
+      functionName: 'totalPaid',
+    }),
+    client.readContract({
+      abi: erc20Abi,
+      address: campaign.earnShareAddress,
+      args: [distributor],
+      functionName: 'balanceOf',
+    }),
+  ])
+  if (version !== BigInt(runRecord.rootVersion))
+    throw new Error('Reward root changed after statement preparation.')
+  const entitlement = BigInt(runRecord.statement.totalEntitlement)
+  if (paid > entitlement) throw new Error('Reward paid total exceeds the prepared entitlement.')
+  const available = paid + inventory
+  const missingEarnShares = entitlement > available ? entitlement - available : 0n
+  const fundingEarnShares = Campaigns.settlementFundingEarnShares(missingEarnShares)
+  const fundedAssets =
+    fundingEarnShares > 0n
+      ? Campaigns.earnSharesToAssets({
+          earnShares: fundingEarnShares,
+          ...(await vaultQuote(client, campaign.vaultAddress)),
+        })
+      : 0n
+  if (
+    runRecord.fundedAssets === fundedAssets.toString() &&
+    runRecord.mintedEarnShares === missingEarnShares.toString()
+  )
+    return runRecord
+  return requireTransition(options.db, runRecord, 'statement', {
+    fundedAssets: fundedAssets.toString(),
+    mintedEarnShares: missingEarnShares.toString(),
+  })
+}
+
+async function vaultQuote(
+  client: ReturnType<run.Options['getClient']>,
+  vault: Address,
+): Promise<{ totalAssets: bigint; totalEarnShares: bigint }> {
+  const [totalAssets, totalEarnShares] = await Promise.all([
+    client.readContract({ abi: vaultAbi, address: vault, functionName: 'totalAssets' }),
+    feeInclusiveEarnShareSupply(client, vault),
+  ])
+  return { totalAssets, totalEarnShares }
+}
+
+async function deliver(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  bindings: Bindings,
+  statement: Campaigns.Statement | undefined,
+  calculation: Calculation,
+  signer: Address,
+) {
+  if (!statement || !bindings.distributor) return
+  const { accounts, closingCursor, evidence } = calculation
+  const working = accounts.map((account) => ({
+    ...account,
+    lots: account.lots.map((lot) => ({ ...lot })),
+  }))
+  const client = options.getClient(campaign.chainId)
+  const paidBefore = new Map(
+    working.map((account) => [account.recipient.toLowerCase(), account.cumulativePaid]),
+  )
+  await reconcilePaid(client, { accounts: working, distributor: bindings.distributor })
+  const payoutRecipients = await (async () => {
+    if (evidence.payoutRecipients !== undefined) return evidence.payoutRecipients
+    const endsAt = Number(runRecord.endsAt)
+    // Payout decisions use the immutable schedule that accrued this run's rewards. A pending
+    // schedule applies only after promotion creates a run with its own configuration snapshot.
+    const closingBoost = runRecord.config.boostRewards!
+    const push = Campaigns.shouldPushPayout(closingBoost, {
+      endsAt,
+      startsAfter: Number(runRecord.startsAfter),
+    })
+    const flush = endsAt >= Campaigns.finalBoundary({ boostRewards: closingBoost })
+    const quote = push && !flush ? await vaultQuote(client, campaign.vaultAddress) : undefined
+    // Preserve visible small balance increases while avoiding automatic pushes worth less than gas.
+    const minimumAssets = 10n ** BigInt(Math.max(campaign.assetDecimals - 4, 0))
+    const selected = working
+      .filter(
+        (account) =>
+          push &&
+          account.cumulativePaid < account.cumulativeEntitlement &&
+          (flush ||
+            (quote &&
+              Campaigns.meetsPayoutMinimum({
+                cumulativeEntitlement: account.cumulativeEntitlement,
+                cumulativePaid: account.cumulativePaid,
+                minimumAssets,
+                ...quote,
+              }))),
+      )
+      .map((account) => account.recipient)
+    await requireTransition(options.db, runRecord, 'paying', {
+      evidence: {
+        ...evidence,
+        closingAccounts: working.map(Projection.snapshot),
+        payoutRecipients: selected,
+      },
+    })
+    return selected
+  })()
+  const unpaidRecipients = new Set(payoutRecipients.map((recipient) => recipient.toLowerCase()))
+  const batches = Campaigns.buildPayoutBatches(statement, {
+    maximumSize: payoutBatchSize,
+    recipients: unpaidRecipients,
+  })
+  const bundles = chunks(batches, payoutCallsPerTransaction)
+  const version = await client.readContract({
+    abi: distributorAbi,
+    address: bindings.distributor,
+    functionName: 'rootVersion',
+  })
+  // Recipient-disjoint cumulative pushes commute. Tempo expiring nonces let each packed transaction
+  // confirm independently, while bounded waves avoid overwhelming the signer and RPC.
+  for (const wave of chunks(bundles, payoutTransactionConcurrency)) {
+    const results = await Promise.allSettled(
+      wave.map((bundle) =>
+        execute(options, campaign, runRecord.id, signer, {
+          batches: bundle,
+          distributor: bindings.distributor!,
+          domain: domain(options, campaign),
+          operation: 'push',
+          rootVersion: version.toString(),
+          statementHash: statement.statementHash,
+        }),
+      ),
+    )
+    const failure = results.find((result) => result.status === 'rejected')
+    if (failure?.status === 'rejected') throw failure.reason
+  }
+  await reconcilePaid(client, { accounts: working, distributor: bindings.distributor })
+  for (const account of working)
+    account.deferral = (() => {
+      if (account.cumulativePaid >= account.cumulativeEntitlement) return undefined
+      if (unpaidRecipients.has(account.recipient.toLowerCase())) return 'transfer_unavailable'
+      return account.deferral
+    })()
+  const settlementRecipients = new Set(
+    (evidence.settlementRecipientAddresses ?? []).map((recipient) => recipient.toLowerCase()),
+  )
+  const paidRecipients =
+    evidence.paidRecipients ??
+    (settlementRecipients.size > 0
+      ? working.filter(
+          (account) =>
+            settlementRecipients.has(account.recipient.toLowerCase()) &&
+            account.cumulativePaid >= account.cumulativeEntitlement,
+        ).length
+      : working.filter(
+          (account) =>
+            unpaidRecipients.has(account.recipient.toLowerCase()) &&
+            account.cumulativePaid > (paidBefore.get(account.recipient.toLowerCase()) ?? 0n),
+        ).length)
+  const payoutPaidRecipients =
+    evidence.payoutPaidRecipients ??
+    working.filter(
+      (account) => account.cumulativePaid > (paidBefore.get(account.recipient.toLowerCase()) ?? 0n),
+    ).length
+  const deferredRecipients =
+    evidence.deferredRecipients ??
+    Math.max(
+      (settlementRecipients.size > 0
+        ? settlementRecipients.size
+        : (evidence.settlementRecipients ?? 0)) - paidRecipients,
+      0,
+    )
+  const pendingRecipients =
+    evidence.pendingRecipients ??
+    working.filter((account) => account.cumulativePaid < account.cumulativeEntitlement).length
+  await requireTransition(options.db, runRecord, 'paying', {
+    evidence: {
+      ...evidence,
+      closingAccounts: working.map(Projection.snapshot),
+      deferredRecipients,
+      paidRecipients,
+      payoutPaidRecipients,
+      payoutRecipients,
+      pendingRecipients,
+    },
+  })
+  await commit(options.db, campaign, runRecord, working, closingCursor, statement)
+}
+
+async function reconcilePaid(
+  client: ReturnType<run.Options['getClient']>,
+  options: reconcilePaid.Options,
+) {
+  for (const group of chunks(options.accounts, 500)) {
+    const paid = await client.multicall({
+      allowFailure: true,
+      contracts: group.map((account) => ({
+        abi: distributorAbi,
+        address: options.distributor,
+        args: [account.recipient],
+        functionName: 'cumulativePaid' as const,
+      })),
+    })
+    paid.forEach((result, index) => {
+      if (result.status !== 'success') throw new Error('Reward payment reconciliation failed.')
+      group[index]!.cumulativePaid = result.result
+    })
+  }
+}
+
+declare namespace reconcilePaid {
+  /** Onchain cumulative-payment reconciliation input. */
+  type Options = {
+    /** Mutable recipient projections updated with onchain paid amounts. */
+    accounts: readonly Projection.Account[]
+    /** Merkle distributor holding cumulative payment state. */
+    distributor: Address
+  }
+}
+
+async function execute(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runId: string | undefined,
+  signer: Address,
+  signerIntent: Signer.Request['intent'],
+): Promise<RewardTransactionAttempts.Record> {
+  const intentId = Signer.id(signerIntent)
+  let attempt = await RewardTransactionAttempts.latestForIntent(options.db, {
+    intentId,
+    ...(runId ? { runId } : {}),
+  })
+  if (attempt?.state === 'confirmed') return attempt
+  const replacementOf =
+    attempt?.state === 'expired' ||
+    attempt?.state === 'ineffective' ||
+    attempt?.state === 'reverted'
+      ? attempt.id
+      : undefined
+  if (replacementOf) attempt = undefined
+  if (!attempt) {
+    try {
+      attempt = await RewardTransactionAttempts.create(options.db, {
+        chainId: campaign.chainId,
+        intent: { id: intentId, operation: signerIntent.operation, payload: signerIntent },
+        ...(replacementOf ? { replacementOf } : {}),
+        ...(runId ? { runId } : {}),
+        signer,
+        vaultAddress: campaign.vaultAddress,
+      })
+    } catch (cause) {
+      // Queue redelivery can race before either invocation observes the other's journal row.
+      // The unique live-intent constraint elects one attempt; the loser resumes that evidence.
+      if (!isUniqueViolation(cause)) throw cause
+      attempt = await RewardTransactionAttempts.latestForIntent(options.db, {
+        intentId,
+        ...(runId ? { runId } : {}),
+      })
+      if (!attempt) throw cause
+    }
+  }
+  if (attempt.state === 'created') {
+    const signed = await Signer.sign({
+      fetch: options.signerFetch,
+      request: { attemptId: attempt.id, id: intentId, intent: signerIntent },
+    })
+    if (!isAddressEqual(signed.signer, signer)) throw new Error('Reward signer account changed.')
+    attempt =
+      (await RewardTransactionAttempts.recordSignature(options.db, {
+        expiresAt: signed.expiresAt,
+        id: attempt.id,
+        nonce: signed.nonce,
+        signedBytes: signed.signedBytes,
+        transactionHash: signed.transactionHash,
+      })) ?? attempt
+  }
+  if (!attempt.signedBytes || !attempt.transactionHash)
+    throw new Error('Reward transaction was not durably signed.')
+  const client = options.getClient(campaign.chainId)
+  let receipt = await client
+    .getTransactionReceipt({ hash: attempt.transactionHash })
+    .catch(() => undefined)
+  const expiredBeforeBroadcast =
+    !receipt &&
+    attempt.expiresAt &&
+    Number((await client.getBlock()).timestamp) * 1_000 >= Date.parse(attempt.expiresAt)
+  if (expiredBeforeBroadcast) {
+    const expired = await RewardTransactionAttempts.expire(options.db, attempt.id)
+    if (!expired) throw new Error('Expired reward transaction could not be replaced.')
+    return execute(options, campaign, runId, signer, signerIntent)
+  }
+  if (!receipt && (attempt.state === 'signed' || attempt.state === 'broadcast')) {
+    await options.assertLease?.()
+    try {
+      await client.sendRawTransaction({ serializedTransaction: attempt.signedBytes })
+    } catch (cause) {
+      receipt = await client
+        .getTransactionReceipt({ hash: attempt.transactionHash })
+        .catch(() => undefined)
+      if (
+        !receipt &&
+        (!(cause instanceof Error) ||
+          !/already known|already imported|known transaction/i.test(cause.message))
+      )
+        throw cause
+    }
+    await RewardTransactionAttempts.recordBroadcast(options.db, attempt.id)
+  }
+  if (!receipt)
+    receipt = await client
+      .waitForTransactionReceipt({
+        confirmations: 1,
+        hash: attempt.transactionHash,
+        timeout: 60_000,
+      })
+      .catch(async (cause) => {
+        const recovered = await client
+          .getTransactionReceipt({ hash: attempt.transactionHash! })
+          .catch(() => undefined)
+        if (recovered) return recovered
+        const expiredOnchain =
+          attempt.expiresAt &&
+          Number((await client.getBlock()).timestamp) * 1_000 >= Date.parse(attempt.expiresAt)
+        if (!expiredOnchain) throw cause
+        const expiredAttempt = await RewardTransactionAttempts.expire(options.db, attempt.id)
+        if (!expiredAttempt) throw cause
+        return undefined
+      })
+  if (!receipt) return execute(options, campaign, runId, signer, signerIntent)
+  if (receipt.status === 'pending')
+    throw new Error(`Reward transaction ${attempt.transactionHash} is still pending.`)
+  const canonical = await client.getBlock({ blockNumber: receipt.blockNumber })
+  if (canonical.hash !== receipt.blockHash)
+    throw new Error('Reward receipt block is not canonical.')
+  const confirmed = await RewardTransactionAttempts.confirm(options.db, {
+    id: attempt.id,
+    intent: compactIntent(intentId, signerIntent),
+    receipt: {
+      blockHash: receipt.blockHash,
+      blockNumber: receipt.blockNumber.toString(),
+      gasUsed: receipt.gasUsed.toString(),
+      status: receipt.status,
+      transactionHash: receipt.transactionHash,
+    },
+  })
+  if (!confirmed || confirmed.receipt?.status !== 'success')
+    throw new Error(`Reward transaction ${attempt.transactionHash} reverted.`)
+  return confirmed
+}
+
+function isUniqueViolation(cause: unknown): cause is { code: '23505' } {
+  return typeof cause === 'object' && cause !== null && 'code' in cause && cause.code === '23505'
+}
+
+function compactIntent(id: Hex, intent: Signer.Request['intent']): Campaigns.TransactionIntent {
+  if (intent.operation === 'push')
+    return {
+      id,
+      operation: intent.operation,
+      payload: {
+        batchCount: intent.batches.length,
+        distributor: intent.distributor,
+        domain: intent.domain,
+        recipientCount: intent.batches.reduce((sum, batch) => sum + batch.recipients.length, 0),
+        rootVersion: intent.rootVersion,
+        statementHash: intent.statementHash,
+      },
+    }
+  if (intent.operation === 'publish' || intent.operation === 'settle') {
+    const { statement, ...payload } = intent
+    return {
+      id,
+      operation: intent.operation,
+      payload: {
+        ...payload,
+        statement: {
+          campaignId: statement.campaignId,
+          chainId: statement.chainId,
+          distributor: statement.distributor,
+          entryCount: statement.entries.length,
+          root: statement.root,
+          schemaVersion: statement.schemaVersion,
+          statementHash: statement.statementHash,
+          totalEntitlement: statement.totalEntitlement,
+        },
+      },
+    }
+  }
+  return { id, operation: intent.operation, payload: intent }
+}
+
+function maintainLease(db: Db.Db, runRecord: RewardRuns.Record, now: () => number) {
+  let failure: unknown
+  let stopped = false
+  const extend = async () => {
+    if (stopped || failure !== undefined) return
+    const renewed = await RewardRuns.renew(db, {
+      fence: runRecord.fence,
+      id: runRecord.id,
+      leaseExpiresAt: new Date(now() + runLeaseMilliseconds).toISOString(),
+    })
+    if (!renewed) failure = new Error('Reward run lease was lost.')
+  }
+  const captureFailure = (cause: unknown) => {
+    failure = cause
+  }
+  let renewal = extend().catch(captureFailure)
+  const timer = setInterval(
+    () => {
+      renewal = renewal.then(extend).catch(captureFailure)
+    },
+    Math.floor(runLeaseMilliseconds / 2),
+  )
+  return {
+    async assert() {
+      await renewal
+      await extend()
+      if (failure !== undefined) throw failure
+    },
+    async ready() {
+      await renewal
+      if (failure !== undefined) throw failure
+    },
+    async stop() {
+      stopped = true
+      clearInterval(timer)
+      await renewal
+      return failure
+    },
+  }
+}
+
+async function commit(
+  db: Db.Db,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+  accounts: readonly Projection.Account[],
+  eventCursor: Campaigns.EventCursor | undefined,
+  statement?: Campaigns.Statement,
+) {
+  const now = new Date().toISOString()
+  await db.transaction(async (tx) => {
+    await RewardAccounts.replace(tx, {
+      accounts: accounts.map((account) => ({
+        accrualRemainder: account.accrualRemainder.toString(),
+        allocatedPrincipalAssets: account.allocatedPrincipalAssets.toString(),
+        cumulativeEntitlement: account.cumulativeEntitlement.toString(),
+        cumulativePaid: account.cumulativePaid.toString(),
+        deferral: account.deferral ?? null,
+        eligibilityRegisteredAt: account.eligibilityRegisteredAt ?? null,
+        lots: account.lots,
+        pendingRewardAssets: account.pendingRewardAssets.toString(),
+        publicEarnShares: account.publicEarnShares.toString(),
+        qualifiedEarnShares: account.qualifiedEarnShares.toString(),
+        recipient: account.recipient,
+        registrationOrder: account.registrationOrder.toString(),
+        updatedAt: now,
+      })),
+      chainId: campaign.chainId,
+      vaultAddress: campaign.vaultAddress,
+    })
+    const advanced = await RewardCampaigns.advance(tx, {
+      chainId: campaign.chainId,
+      deliveredThrough: Number(runRecord.endsAt),
+      ...(eventCursor ? { eventCursor } : {}),
+      expectedDeliveredThrough: Number(runRecord.startsAfter),
+      vaultAddress: campaign.vaultAddress,
+    })
+    if (!advanced) throw new Error('Reward campaign cursor changed before commit.')
+    const current = await RewardRuns.get(tx, runRecord.id)
+    const delivered = await RewardRuns.transition(tx, {
+      fence: runRecord.fence,
+      id: runRecord.id,
+      patch: {
+        error: null,
+        ...(current?.evidence ? { evidence: Campaigns.compactEvidence(current.evidence) } : {}),
+      },
+      phase: 'delivered',
+    })
+    if (!delivered) throw new Error('Reward run lease changed before commit.')
+    if (statement)
+      await RewardRuns.pruneStatements(tx, {
+        chainId: campaign.chainId,
+        keepRunId: runRecord.id,
+        vaultAddress: campaign.vaultAddress,
+      })
+  })
+}
+
+async function requireTransition(
+  db: Db.Db,
+  runRecord: RewardRuns.Record,
+  phase: RewardRuns.Record['phase'],
+  patch: RewardRuns.transition.Options['patch'],
+) {
+  const result = await RewardRuns.transition(db, {
+    fence: runRecord.fence,
+    id: runRecord.id,
+    patch,
+    phase,
+  })
+  if (!result) throw new Error('Reward run lease was lost.')
+  return result
+}
+
+function restoreCalculation(evidence: Campaigns.RunEvidence): Calculation {
+  return {
+    accounts: evidence.closingAccounts.map(Projection.fromSnapshot),
+    ...(evidence.eventCursor ? { closingCursor: evidence.eventCursor } : {}),
+    evidence,
+  }
+}
+
+async function* emptyEventPages(): AsyncGenerator<readonly Projection.Event[]> {}
+
+async function* reconciliationEventPages(
+  pages: AsyncIterable<readonly Projection.Event[]>,
+): AsyncGenerator<Projection.reconcilePages.Page> {
+  for await (const events of pages) yield { events }
+}
+
+async function* registrationDepositPages(
+  tidx: Tidx.Client,
+  options: registrationDepositPages.Options,
+): AsyncGenerator<Projection.reconcilePages.Page> {
+  const accounts = [...options.accounts].sort((left, right) =>
+    left.registrationOrder < right.registrationOrder
+      ? -1
+      : left.registrationOrder > right.registrationOrder
+        ? 1
+        : left.recipient.toLowerCase().localeCompare(right.recipient.toLowerCase()),
+  )
+  const afterOrder = options.afterRecipient
+    ? accounts.find((entry) => isAddressEqual(entry.recipient, options.afterRecipient!))
+        ?.registrationOrder
+    : undefined
+  if (options.afterRecipient && afterOrder === undefined)
+    throw new Error('Reward reconciliation recipient is no longer registered.')
+  for (const account of accounts) {
+    if (
+      afterOrder !== undefined &&
+      (account.registrationOrder < afterOrder ||
+        (account.registrationOrder === afterOrder && !options.after))
+    )
+      continue
+    const pages = Events.accountDepositPages(tidx, {
+      ...(afterOrder === account.registrationOrder && options.after
+        ? { after: options.after }
+        : {}),
+      account: account.recipient,
+      earnVault: options.earnVault,
+      throughBlock: options.throughBlock,
+    })
+    for await (const events of pages) yield { allocationRecipient: account.recipient, events }
+    yield { allocationRecipient: account.recipient, events: [] }
+  }
+}
+
+declare namespace registrationDepositPages {
+  type Options = {
+    after?: Campaigns.EventCursor | undefined
+    afterRecipient?: Address | undefined
+    accounts: readonly { recipient: Address; registrationOrder: bigint }[]
+    earnVault: Address
+    throughBlock: number
+  }
+}
+
+async function notificationSummary(
+  db: Db.Db,
+  campaign: RewardCampaigns.Record,
+  runId: string,
+): Promise<run.Notification | undefined> {
+  const record = await RewardRuns.get(db, runId)
+  const evidence = record?.evidence
+  if (!record || !evidence) return undefined
+  const [attempts, vault] = await Promise.all([
+    RewardTransactionAttempts.confirmedForRun(db, runId),
+    EarnVaultRecords.get(db, campaign),
+  ])
+  const root = attempts.find(
+    (attempt) => attempt.intent.operation === 'publish' || attempt.intent.operation === 'settle',
+  )
+  const targetAttempt = attempts.find((attempt) => attempt.intent.operation === 'targetYield')
+  const payoutTransactionHashes = attempts
+    .filter((attempt) => attempt.intent.operation === 'push' && attempt.transactionHash)
+    .map((attempt) => attempt.transactionHash!)
+  const closingInterval = evidence.intervals.at(-1)
+  const targetActive = Boolean(
+    record.config.targetYield &&
+    Campaigns.overlapsCompleteIntervals(record.config.targetYield, {
+      endsAt: Number(record.endsAt),
+      startsAfter: Number(record.startsAfter),
+    }),
+  )
+  const targetActiveAtClose = Boolean(
+    record.config.targetYield &&
+    closingInterval &&
+    closingInterval.endsAt > record.config.targetYield.startTimestamp &&
+    closingInterval.endsAt <= record.config.targetYield.endTimestamp,
+  )
+  const boostActiveAtClose = Boolean(
+    record.config.boostRewards &&
+    record.config.boostRewards.enabled !== false &&
+    closingInterval &&
+    closingInterval.endsAt > record.config.boostRewards.startTimestamp &&
+    closingInterval.endsAt <= record.config.boostRewards.endTimestamp,
+  )
+  const targetRateBps = targetActiveAtClose
+    ? (evidence.appliedTargetRateBps ?? evidence.targetRateBps)
+    : undefined
+  const settlement = (() => {
+    if (
+      !evidence.publishedRoot ||
+      evidence.settledRewardAssets === undefined ||
+      evidence.settlementRecipients === undefined ||
+      !root?.transactionHash
+    )
+      return undefined
+    return {
+      assetAmount: evidence.settledRewardAssets,
+      creditedRecipients: evidence.settlementRecipients,
+      deferredRecipients:
+        evidence.deferredRecipients ??
+        Math.max(evidence.settlementRecipients - (evidence.paidRecipients ?? 0), 0),
+      transactionHash: root.transactionHash,
+    }
+  })()
+  if (!targetActive && !settlement && payoutTransactionHashes.length === 0) return undefined
+  return {
+    assetDecimals: campaign.assetDecimals,
+    baseRateBps: Math.max(closingInterval?.organicRateBps ?? 0, targetRateBps ?? 0),
+    ...(boostActiveAtClose ? { boostRateBps: closingInterval?.boostRateBps ?? 0 } : {}),
+    intervalCount: evidence.intervals.length,
+    ...(payoutTransactionHashes.length > 0
+      ? {
+          payout: {
+            deferredRecipients: evidence.pendingRecipients ?? 0,
+            paidRecipients: evidence.payoutPaidRecipients ?? evidence.paidRecipients ?? 0,
+            transactionHashes: payoutTransactionHashes,
+          },
+        }
+      : {}),
+    ...(settlement ? { settlement } : {}),
+    ...(targetActive
+      ? {
+          targetYield: {
+            assetAmount: (evidence.targetFundingAssets ?? [])
+              .reduce((sum, amount) => sum + BigInt(amount), 0n)
+              .toString(),
+            ...(targetAttempt?.transactionHash
+              ? { transactionHash: targetAttempt.transactionHash }
+              : {}),
+          },
+        }
+      : {}),
+    vaultLabel: vault?.label ?? campaign.vaultAddress,
+  }
+}
+
+async function allEligible(db: Db.Db, campaign: RewardCampaigns.Record) {
+  const records: RewardEligibilityAssociations.Record[] = []
+  let cursor: string | undefined
+  do {
+    const page = await RewardEligibilityAssociations.list(db, {
+      chainId: campaign.chainId,
+      ...(cursor ? { cursor } : {}),
+      limit: 1_000,
+      vaultAddress: campaign.vaultAddress,
+    })
+    if (records.length + page.data.length > maximumRecipients)
+      throw new Error(`Reward campaign exceeds ${maximumRecipients} registered recipients.`)
+    records.push(...page.data)
+    cursor = page.nextCursor ?? undefined
+  } while (cursor)
+  return records
+}
+
+async function targetRate(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  runRecord: RewardRuns.Record,
+) {
+  const config = campaign.config.targetYield!
+  const previous = await RewardRuns.latestDelivered(options.db, campaign)
+  const fallback =
+    previous?.evidence?.targetRateBps !== undefined &&
+    previous.evidence.targetRateObservedAt &&
+    sameRateSource(previous.config.targetYield?.annualRate, config.annualRate)
+      ? {
+          annualRateBps: previous.evidence.targetRateBps,
+          observedAt: previous.evidence.targetRateObservedAt,
+        }
+      : undefined
+  const result = await Rates.target({
+    boundary: new Date(Number(runRecord.endsAt) * 1_000).toISOString(),
+    ...(fallback ? { fallback } : {}),
+    fetch: options.fetch,
+    now: () => new Date(options.now()),
+    source: config.annualRate,
+  })
+  return { config, ...result }
+}
+
+function sameRateSource(
+  left: NonNullable<Campaigns.Config['targetYield']>['annualRate'] | undefined,
+  right: NonNullable<Campaigns.Config['targetYield']>['annualRate'],
+): boolean {
+  if (!left) return false
+  if ('bps' in left || 'bps' in right)
+    return 'bps' in left && 'bps' in right && left.bps === right.bps
+  return (
+    left.morphoVault.toLowerCase() === right.morphoVault.toLowerCase() &&
+    left.minBps === right.minBps &&
+    left.maxBps === right.maxBps &&
+    left.staleAfterSeconds === right.staleAfterSeconds
+  )
+}
+
+function sameTargetFunding(
+  left: NonNullable<Campaigns.Config['targetYield']>['funding'] | undefined,
+  right: NonNullable<Campaigns.Config['targetYield']>['funding'],
+): boolean {
+  return Boolean(
+    left &&
+    left.length === right.length &&
+    left.every((leg, index) => {
+      const compared = right[index]!
+      if (leg.wallet.toLowerCase() !== compared.wallet.toLowerCase()) return false
+      if ('remainder' in leg || 'remainder' in compared)
+        return 'remainder' in leg && 'remainder' in compared
+      return leg.upToAnnualRate.bps === compared.upToAnnualRate.bps
+    }),
+  )
+}
+
+async function exclusions(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  bindings: Bindings,
+): Promise<Address[]> {
+  const boost = campaign.config.boostRewards
+  if (!boost) return []
+  const client = options.getClient(campaign.chainId)
+  const [earnFees, engine, vault] = await Promise.all([
+    client.readContract({
+      abi: vaultAbi,
+      address: campaign.vaultAddress,
+      functionName: 'earnFees',
+    }),
+    client.readContract({
+      abi: vaultAbi,
+      address: campaign.vaultAddress,
+      functionName: 'engine',
+    }),
+    EarnVaultRecords.get(options.db, campaign),
+  ])
+  const zoneContracts = options.zones
+    .filter((zone) => zone.sourceId === campaign.chainId)
+    .flatMap((zone) => Object.values(zone.contracts ?? {}))
+    .flatMap(contractAddresses)
+  return [
+    ...new Set(
+      [
+        campaign.vaultAddress,
+        campaign.earnShareAddress,
+        earnFees,
+        engine,
+        boost.treasury,
+        ...(bindings.controller ? [bindings.controller] : []),
+        ...(bindings.distributor ? [bindings.distributor] : []),
+        ...(vault?.zones.map((zone) => zone.earnRouter) ?? []),
+        ...zoneContracts,
+        ...boost.excludedAddresses,
+      ].map((address) => getAddress(address).toLowerCase()),
+    ),
+  ].map(getAddress)
+}
+
+function contractAddresses(contract: unknown): Address[] {
+  if (!contract || typeof contract !== 'object') return []
+  const value = contract as Record<string, unknown>
+  const address = value['address']
+  if (typeof address === 'string' && isAddress(address)) return [address]
+  return Object.values(value).flatMap(contractAddresses)
+}
+
+function domain(
+  options: run.Options,
+  campaign: RewardCampaigns.Record,
+  config = campaign.config,
+): Signer.Domain {
+  return {
+    chainId: campaign.chainId,
+    earnShare: getAddress(campaign.earnShareAddress),
+    earnVault: getAddress(campaign.vaultAddress),
+    factory: options.factory,
+    treasury: config.boostRewards?.treasury ?? '0x0000000000000000000000000000000000000000',
+  }
+}
+
+function campaignId(vault: Address): Hex {
+  return `0x${'0'.repeat(24)}${vault.slice(2).toLowerCase()}`
+}
+
+function chunks<item>(items: readonly item[], size: number): item[][] {
+  const result: item[][] = []
+  for (let index = 0; index < items.length; index += size)
+    result.push(items.slice(index, index + size))
+  return result
+}