tapimo 0.15.1 → 0.18.1

package/src/db/Db.ts

@@ -3,7 +3,10 @@ import {
   type Compilable,
   CompiledQuery,
   type Dialect,
+  type DatabaseConnection,
+  type Driver,
   Kysely,
+  type KyselyPlugin,
   PostgresDialect,
   type RawBuilder,
   sql,
@@ -42,6 +45,7 @@ import type * as RoutesDepositAddresses from './tables/routesDepositAddresses.js
 import type * as RoutesDepositRequestObservations from './tables/routesDepositRequestObservations.js'
 import type * as RoutesDeposits from './tables/routesDeposits.js'
 import type * as RoutesIdempotency from './tables/routesIdempotency.js'
+import type * as RoutesPolicies from './tables/routesPolicies.js'
 import type * as RoutesSubsidies from './tables/routesSubsidies.js'
 import type * as RoutesTransferEvents from './tables/routesTransferEvents.js'
 import type * as RoutesTransfers from './tables/routesTransfers.js'
@@ -107,10 +111,12 @@ export type Database = {
   routes_deposit_request_observations: RoutesDepositRequestObservations.Table
   routes_deposits: RoutesDeposits.Table
   routes_idempotency_requests: RoutesIdempotency.Table
+  routes_policies: RoutesPolicies.Table
   routes_routes: RoutesCatalog.RouteTable
   routes_subsidies: RoutesSubsidies.Table
   routes_tokens: RoutesCatalog.TokenTable
   routes_transfer_events: RoutesTransferEvents.Table
+  routes_transfer_subsidy_expired_attempts: RoutesTransferSubsidies.ExpiredAttemptTable
   routes_transfer_subsidies: RoutesTransferSubsidies.Table
   routes_transfer_subsidy_nonces: RoutesTransferSubsidyNonces.Table
   routes_transfer_transactions: RoutesTransferTransactions.Table
@@ -150,6 +156,45 @@ export type Db = {
   transaction<value>(fn: (tx: Db) => Promise<value>): Promise<value>
 }
 
+/** Per-execution observers, keyed by Kysely's query id so the driver can find them. */
+const queryObservers = new WeakMap<object, observe.Options['onQuery']>()
+
+/**
+ * Wraps a database so every query reports its wall-clock duration at the
+ * driver: acquisition of its connection plus execution, whether it succeeds or
+ * rejects. A rejected acquisition has no query to charge and goes unreported.
+ */
+export function observe(db: Db, options: observe.Options): Db {
+  // The plugin only tags executions; the driver wrapper installed by
+  // `fromDialect` does the timing, so rejected queries report too.
+  const plugin: KyselyPlugin = {
+    transformQuery(args) {
+      queryObservers.set(args.queryId, options.onQuery)
+      return args.node
+    },
+    async transformResult(args) {
+      return args.result
+    },
+  }
+  return { ...db, kysely: db.kysely.withPlugin(plugin) }
+}
+
+export declare namespace observe {
+  /** Query observation hooks. */
+  type Options = {
+    /** Receives each completed query's total and component durations in milliseconds. */
+    onQuery: (durationMs: number, timing: Timing) => void
+  }
+
+  /** Connection acquisition and query execution durations, in milliseconds. */
+  type Timing = {
+    /** Time spent waiting for or connecting a database connection. */
+    acquire: number
+    /** Time spent executing the query, including network round trips. */
+    query: number
+  }
+}
+
 /**
  * A {@link Db}, or a factory for per-request Workers/Hyperdrive connections.
  * Node can pass a long-lived singleton. Resolve at the leaf with {@link get}.
@@ -2980,6 +3025,389 @@ export const migrations: readonly Migration[] = [
         sql`UPDATE routes_deposits SET subsidy_meter_reported_at = coalesce(status_updated_at, updated_at) WHERE environment = 'production' AND subsidy_meter_reported_at IS NULL AND (provider_subsidy->'amount'->>'baseUnits')::numeric > 0 AND (status = 'completed' OR (status IN ('action-required', 'settling') AND tempo_gas_paid IS NOT NULL)) AND coalesce(status_updated_at, updated_at) < '2026-09-03T06:10:21.000Z'`,
       ),
   },
+  {
+    name: '0280_routes_policies',
+    up: (db) =>
+      raw(
+        db,
+        sql`DO $$ BEGIN
+          CREATE TABLE IF NOT EXISTS routes_policies (org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE, environment text NOT NULL CHECK (environment IN ('production', 'sandbox')), project_id text NOT NULL DEFAULT '', api_key_id text NOT NULL DEFAULT '', version integer NOT NULL CHECK (version > 0), policy jsonb NOT NULL, created_at text NOT NULL, updated_at text NOT NULL, PRIMARY KEY (org_id, environment, project_id, api_key_id));
+          ALTER TABLE api_key_admissions ADD COLUMN IF NOT EXISTS pending_scopes jsonb;
+        END $$`,
+      ),
+  },
+  {
+    name: '0270_earn_vault_earnings',
+    up: (db) => raw(db, sql`ALTER TABLE earn_vaults ADD COLUMN IF NOT EXISTS earnings jsonb`),
+  },
+  {
+    // All workers must understand pinned commitments before this index permits multiple terms for the same wallets.
+    name: '0281_routes_deposit_address_policy_identity',
+    up: (db) =>
+      raw(
+        db,
+        sql`DO $$ BEGIN
+          CREATE UNIQUE INDEX IF NOT EXISTS routes_deposit_addresses_policy_identity_idx ON routes_deposit_addresses (org_id, environment, project_id, source_chain_id, source_token_key, destination_token_key, recipient, refund_address, subsidize, (coalesce(provider_state->>'routePolicyKey', ''))) NULLS NOT DISTINCT;
+          DROP INDEX IF EXISTS routes_deposit_addresses_identity_idx;
+        END $$`,
+      ),
+  },
+  {
+    // The funding-to-routes rename left existing subscriptions with event types rejected by response validation.
+    name: '0282_webhook_subscription_routes_event_types',
+    up: (db) =>
+      raw(
+        db,
+        sql`UPDATE webhook_subscriptions SET event_type = CASE event_type WHEN 'funding:deposit.updated' THEN 'routes:deposit.updated' WHEN 'funding:transfer.updated' THEN 'routes:transfer.updated' END WHERE event_type IN ('funding:deposit.updated', 'funding:transfer.updated')`,
+      ),
+  },
+  {
+    name: '0283_sponsored_transactions_drop_hashless_recovery_index',
+    up: (db) => raw(db, sql`DROP INDEX IF EXISTS sponsored_transactions_recovery_idx`),
+  },
+  {
+    name: '0284_sponsored_transactions_failed_recovery_index',
+    up: (db) =>
+      raw(
+        db,
+        sql`CREATE INDEX IF NOT EXISTS sponsored_transactions_recovery_idx ON sponsored_transactions (finalized_at, chain_id, created_at) WHERE status = 'failed'`,
+      ),
+  },
+  {
+    name: '0285_sponsored_transactions_reconciled_hash',
+    up: (db) =>
+      raw(
+        db,
+        sql`ALTER TABLE sponsored_transactions ADD COLUMN IF NOT EXISTS transaction_hash_reconciled boolean NOT NULL DEFAULT false`,
+      ),
+  },
+  {
+    name: '0286_request_usage_event_timestamp',
+    up: (db) =>
+      raw(
+        db,
+        sql`ALTER TABLE request_usage_meter_events ADD COLUMN IF NOT EXISTS event_timestamp text`,
+      ),
+  },
+  {
+    name: '0287_users_terms_shared_at',
+    up: (db) => raw(db, sql`ALTER TABLE users ADD COLUMN IF NOT EXISTS terms_shared_at text`),
+  },
+  {
+    name: '0288_sponsored_transactions_meter_attempt',
+    up: (db) => raw(db, sql`ALTER TABLE sponsored_transactions ADD COLUMN IF NOT EXISTS meter_report_attempted_at text`), // prettier-ignore
+  },
+  {
+    name: '0289_sponsored_transactions_meter_attempt_index',
+    up: (db) => raw(db, sql`CREATE INDEX IF NOT EXISTS sponsored_transactions_meter_attempt_idx ON sponsored_transactions (meter_report_attempted_at ASC NULLS FIRST, finalized_at, id) WHERE billable AND status = 'finalized' AND meter_reported_at IS NULL`), // prettier-ignore
+  },
+  {
+    name: '0290_sponsored_transactions_first_meter_event_attempt',
+    up: (db) => raw(db, sql`ALTER TABLE sponsored_transactions ADD COLUMN IF NOT EXISTS meter_event_first_attempted_at text`), // prettier-ignore
+  },
+  {
+    name: '0291_sponsored_transactions_meter_retry_index',
+    up: (db) => raw(db, sql`CREATE INDEX IF NOT EXISTS sponsored_transactions_meter_retry_idx ON sponsored_transactions (meter_report_attempted_at, finalized_at, id) WHERE billable AND status = 'finalized' AND meter_reported_at IS NULL AND meter_event_first_attempted_at IS NOT NULL`), // prettier-ignore
+  },
+  {
+    name: '0292_routes_transfer_subsidies_tron_addresses',
+    up: (db) =>
+      raw(
+        db,
+        sql`CREATE OR REPLACE FUNCTION capture_routes_transfer_subsidy() RETURNS trigger
+        LANGUAGE plpgsql SET search_path FROM CURRENT AS $capture$
+        DECLARE
+          settlement routes_transfer_subsidies%ROWTYPE;
+          source_chain text;
+          source_ref text;
+          recipient text;
+          token_address text;
+        BEGIN
+          IF NEW.subsidy_transaction_hash IS NULL OR NEW.provider_state->'transferSubsidy' IS NULL THEN
+            RETURN NEW;
+          END IF;
+          source_chain := NEW.snapshot->'sourceChain'->>'id';
+          source_ref := NEW.snapshot->'sourceTransactionHashes'->>0;
+          IF source_ref IS NULL THEN
+            RAISE EXCEPTION 'Subsidy source evidence is missing';
+          END IF;
+          recipient := CASE WHEN NEW.subsidy_chain_id LIKE 'tron:%'
+            THEN NEW.snapshot->>'recipient' ELSE lower(NEW.snapshot->>'recipient') END;
+          token_address := CASE WHEN NEW.subsidy_chain_id LIKE 'tron:%'
+            THEN NEW.subsidy_token_address ELSE lower(NEW.subsidy_token_address) END;
+          INSERT INTO routes_transfer_subsidies (
+            source_chain_id, transaction_ref, destination_chain_id, recipient,
+            token_address, transaction, transfer_id, created_at
+          ) VALUES (
+            source_chain, source_ref, NEW.subsidy_chain_id, recipient,
+            token_address, NEW.provider_state->'transferSubsidy', NEW.id, NEW.updated_at
+          ) ON CONFLICT DO NOTHING;
+          SELECT * INTO STRICT settlement FROM routes_transfer_subsidies
+            WHERE source_chain_id = source_chain AND transaction_ref = source_ref;
+          IF settlement.transaction IS DISTINCT FROM NEW.provider_state->'transferSubsidy'
+            OR settlement.destination_chain_id IS DISTINCT FROM NEW.subsidy_chain_id
+            OR settlement.recipient IS DISTINCT FROM recipient
+            OR settlement.token_address IS DISTINCT FROM token_address THEN
+            RAISE EXCEPTION 'Source payment already has a different subsidy settlement';
+          END IF;
+          IF settlement.transfer_id <> NEW.id THEN
+            NEW.subsidy_amount := NULL;
+            NEW.subsidy_commitment_amount := NULL;
+            NEW.subsidy_native_amount := NULL;
+          END IF;
+          RETURN NEW;
+        END $capture$`,
+      ),
+  },
+  {
+    name: '0293_routes_transfer_subsidies_case_sensitive_addresses',
+    up: (db) =>
+      raw(
+        db,
+        sql`CREATE OR REPLACE FUNCTION capture_routes_transfer_subsidy() RETURNS trigger
+        LANGUAGE plpgsql SET search_path FROM CURRENT AS $capture$
+        DECLARE
+          settlement routes_transfer_subsidies%ROWTYPE;
+          source_chain text;
+          source_ref text;
+          recipient text;
+          token_address text;
+        BEGIN
+          IF NEW.subsidy_transaction_hash IS NULL OR NEW.provider_state->'transferSubsidy' IS NULL THEN
+            RETURN NEW;
+          END IF;
+          source_chain := NEW.snapshot->'sourceChain'->>'id';
+          source_ref := NEW.snapshot->'sourceTransactionHashes'->>0;
+          IF source_ref IS NULL THEN
+            RAISE EXCEPTION 'Subsidy source evidence is missing';
+          END IF;
+          recipient := CASE WHEN NEW.subsidy_chain_id LIKE 'eip155:%'
+            THEN lower(NEW.snapshot->>'recipient') ELSE NEW.snapshot->>'recipient' END;
+          token_address := CASE WHEN NEW.subsidy_chain_id LIKE 'eip155:%'
+            THEN lower(NEW.subsidy_token_address) ELSE NEW.subsidy_token_address END;
+          INSERT INTO routes_transfer_subsidies (
+            source_chain_id, transaction_ref, destination_chain_id, recipient,
+            token_address, transaction, transfer_id, created_at
+          ) VALUES (
+            source_chain, source_ref, NEW.subsidy_chain_id, recipient,
+            token_address, NEW.provider_state->'transferSubsidy', NEW.id, NEW.updated_at
+          ) ON CONFLICT DO NOTHING;
+          SELECT * INTO STRICT settlement FROM routes_transfer_subsidies
+            WHERE source_chain_id = source_chain AND transaction_ref = source_ref;
+          IF settlement.transaction IS DISTINCT FROM NEW.provider_state->'transferSubsidy'
+            OR settlement.destination_chain_id IS DISTINCT FROM NEW.subsidy_chain_id
+            OR settlement.recipient IS DISTINCT FROM recipient
+            OR settlement.token_address IS DISTINCT FROM token_address THEN
+            RAISE EXCEPTION 'Source payment already has a different subsidy settlement';
+          END IF;
+          IF settlement.transfer_id <> NEW.id THEN
+            NEW.subsidy_amount := NULL;
+            NEW.subsidy_commitment_amount := NULL;
+            NEW.subsidy_native_amount := NULL;
+          END IF;
+          RETURN NEW;
+        END $capture$`,
+      ),
+  },
+  {
+    name: '0294_routes_transfer_subsidies_status',
+    up: (db) =>
+      raw(
+        db,
+        sql`ALTER TABLE routes_transfer_subsidies ADD COLUMN IF NOT EXISTS status text NOT NULL DEFAULT 'active'`,
+      ),
+  },
+  {
+    name: '0295_routes_transfer_subsidies_status_check',
+    up: (db) =>
+      raw(
+        db,
+        sql`DO $$ BEGIN
+          IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint WHERE conname = 'routes_transfer_subsidies_status_check'
+          ) THEN
+            ALTER TABLE routes_transfer_subsidies
+              ADD CONSTRAINT routes_transfer_subsidies_status_check
+              CHECK (status IN ('active', 'expired'));
+          END IF;
+        END $$`,
+      ),
+  },
+  {
+    name: '0296_routes_transfer_subsidy_expired_attempts',
+    up: (db) =>
+      db.schema
+        .createTable('routesTransferSubsidyExpiredAttempts')
+        .ifNotExists()
+        .addColumn('createdAt', 'text', (c) => c.notNull())
+        .addColumn('expiredAt', 'text', (c) => c.notNull())
+        .addColumn('sourceChainId', 'text', (c) => c.notNull())
+        .addColumn('transaction', 'jsonb', (c) => c.notNull())
+        .addColumn('transactionHash', 'text', (c) => c.notNull())
+        .addColumn('transactionRef', 'text', (c) => c.notNull())
+        .addColumn('transferId', 'text', (c) => c.notNull())
+        .addPrimaryKeyConstraint('routes_transfer_subsidy_expired_attempts_pkey', [
+          'sourceChainId',
+          'transactionRef',
+          'transactionHash',
+        ]),
+  },
+  {
+    name: '0297_routes_transfer_subsidy_expiry_capture',
+    up: (db) =>
+      raw(
+        db,
+        sql`CREATE OR REPLACE FUNCTION capture_routes_transfer_subsidy() RETURNS trigger
+        LANGUAGE plpgsql SET search_path FROM CURRENT AS $capture$
+        DECLARE
+          settlement routes_transfer_subsidies%ROWTYPE;
+          source_chain text;
+          source_ref text;
+          recipient text;
+          token_address text;
+          expired_signed jsonb;
+          replacement_signed jsonb;
+        BEGIN
+          IF NEW.subsidy_transaction_hash IS NULL OR NEW.provider_state->'transferSubsidy' IS NULL THEN
+            RETURN NEW;
+          END IF;
+          source_chain := NEW.snapshot->'sourceChain'->>'id';
+          source_ref := NEW.snapshot->'sourceTransactionHashes'->>0;
+          IF source_ref IS NULL THEN
+            RAISE EXCEPTION 'Subsidy source evidence is missing';
+          END IF;
+          recipient := CASE WHEN NEW.subsidy_chain_id LIKE 'eip155:%'
+            THEN lower(NEW.snapshot->>'recipient') ELSE NEW.snapshot->>'recipient' END;
+          token_address := CASE WHEN NEW.subsidy_chain_id LIKE 'eip155:%'
+            THEN lower(NEW.subsidy_token_address) ELSE NEW.subsidy_token_address END;
+          INSERT INTO routes_transfer_subsidies (
+            source_chain_id, transaction_ref, destination_chain_id, recipient,
+            token_address, transaction, transfer_id, created_at
+          ) VALUES (
+            source_chain, source_ref, NEW.subsidy_chain_id, recipient,
+            token_address, NEW.provider_state->'transferSubsidy', NEW.id, NEW.updated_at
+          ) ON CONFLICT DO NOTHING;
+          SELECT * INTO STRICT settlement FROM routes_transfer_subsidies
+            WHERE source_chain_id = source_chain AND transaction_ref = source_ref;
+          IF settlement.destination_chain_id IS DISTINCT FROM NEW.subsidy_chain_id
+            OR settlement.recipient IS DISTINCT FROM recipient
+            OR settlement.token_address IS DISTINCT FROM token_address THEN
+            RAISE EXCEPTION 'Source payment already has a different subsidy settlement';
+          END IF;
+          IF settlement.status = 'expired'
+            AND settlement.destination_chain_id LIKE 'solana:%'
+            AND settlement.transaction IS DISTINCT FROM NEW.provider_state->'transferSubsidy' THEN
+            IF settlement.transfer_id IS DISTINCT FROM NEW.id THEN
+              RAISE EXCEPTION 'Only the subsidy owner may replace an expired settlement';
+            END IF;
+            expired_signed := (settlement.transaction #>> '{}')::jsonb;
+            replacement_signed := (NEW.provider_state->>'transferSubsidy')::jsonb;
+            IF expired_signed->>'account' IS DISTINCT FROM replacement_signed->>'account'
+              OR expired_signed->>'amount' IS DISTINCT FROM replacement_signed->>'amount'
+              OR expired_signed->>'chainId' IS DISTINCT FROM replacement_signed->>'chainId'
+              OR replacement_signed->>'hash' IS DISTINCT FROM NEW.subsidy_transaction_hash THEN
+              RAISE EXCEPTION 'Expired subsidy replacement changed settlement terms';
+            END IF;
+            UPDATE routes_transfer_subsidies SET
+              transaction = NEW.provider_state->'transferSubsidy',
+              created_at = NEW.updated_at,
+              status = 'active'
+            WHERE source_chain_id = source_chain AND transaction_ref = source_ref;
+          ELSIF settlement.transaction IS DISTINCT FROM NEW.provider_state->'transferSubsidy' THEN
+            RAISE EXCEPTION 'Source payment already has a different subsidy settlement';
+          END IF;
+          IF settlement.transfer_id <> NEW.id THEN
+            NEW.subsidy_amount := NULL;
+            NEW.subsidy_commitment_amount := NULL;
+            NEW.subsidy_native_amount := NULL;
+          END IF;
+          RETURN NEW;
+        END $capture$`,
+      ),
+  },
+  {
+    name: '0298_routes_transfer_subsidies_status_check_schema',
+    up: (db) =>
+      raw(
+        db,
+        sql`DO $$ BEGIN
+          IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint
+            WHERE conname = 'routes_transfer_subsidies_status_check'
+              AND conrelid = 'routes_transfer_subsidies'::regclass
+          ) THEN
+            ALTER TABLE routes_transfer_subsidies
+              ADD CONSTRAINT routes_transfer_subsidies_status_check
+              CHECK (status IN ('active', 'expired'));
+          END IF;
+        END $$`,
+      ),
+  },
+  {
+    name: '0299_verified_tokens_ousd',
+    up: (db) =>
+      raw(
+        db,
+        // Matches the verified-token publisher's "vtok" lock for Tempo mainnet.
+        sql`DO $migration$ BEGIN PERFORM pg_advisory_xact_lock(1987342187, 4217); WITH list AS (UPDATE verified_token_lists SET updated_at = CASE WHEN version LIKE '%_0299_ousd' THEN updated_at ELSE to_char(GREATEST(updated_at::timestamptz, clock_timestamp()) AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') END, version = CASE WHEN version LIKE '%_0299_ousd' THEN version ELSE version || '_0299_ousd' END WHERE chain_id = 4217 RETURNING chain_id) INSERT INTO verified_tokens (address, chain_id, currency, decimals, logo_uri, name, position, symbol) SELECT '0x20c0000000000000000000006a37da5c996874be', list.chain_id, 'USD', 6, NULL, 'OpenUSD', COALESCE((SELECT max(position) + 1 FROM verified_tokens WHERE chain_id = list.chain_id), 0), 'OUSD' FROM list ON CONFLICT (chain_id, address) DO UPDATE SET currency = EXCLUDED.currency, decimals = EXCLUDED.decimals, logo_uri = EXCLUDED.logo_uri, name = EXCLUDED.name, symbol = EXCLUDED.symbol; END $migration$`,
+      ),
+  },
+  {
+    name: '0300_reward_runs_latest_delivered_index',
+    // Serves latest-run lookups per vault and phase without sorting every run.
+    up: (db) => raw(db, sql`CREATE INDEX IF NOT EXISTS reward_runs_latest_idx ON reward_runs (chain_id, vault_address, phase, ends_at DESC)`), // prettier-ignore
+  },
+  {
+    name: '0301_verified_tokens_ousd_testnet',
+    up: (db) =>
+      raw(
+        db,
+        // Matches the verified-token publisher's "vtok" lock for Tempo testnet.
+        sql`DO $migration$ BEGIN PERFORM pg_advisory_xact_lock(1987342187, 42431); WITH list AS (UPDATE verified_token_lists SET updated_at = CASE WHEN version LIKE '%_0301_ousd' THEN updated_at ELSE to_char(GREATEST(updated_at::timestamptz, clock_timestamp()) AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') END, version = CASE WHEN version LIKE '%_0301_ousd' THEN version ELSE version || '_0301_ousd' END WHERE chain_id = 42431 RETURNING chain_id) INSERT INTO verified_tokens (address, chain_id, currency, decimals, logo_uri, name, position, symbol) SELECT '0x20c0000000000000000000006a37da5c996874be', list.chain_id, 'USD', 6, NULL, 'OpenUSD', COALESCE((SELECT max(position) + 1 FROM verified_tokens WHERE chain_id = list.chain_id), 0), 'OUSD' FROM list ON CONFLICT (chain_id, address) DO UPDATE SET currency = EXCLUDED.currency, decimals = EXCLUDED.decimals, logo_uri = EXCLUDED.logo_uri, name = EXCLUDED.name, symbol = EXCLUDED.symbol; END $migration$`,
+      ),
+  },
+  {
+    name: '0302_extend_d730_reward_campaign',
+    up: (db) =>
+      raw(
+        db,
+        // December 17, 2026 at noon EST. Preserve the delivered cursor so expired intervals accrue during catch-up.
+        sql`DO $migration$
+        DECLARE
+          campaign reward_campaigns%ROWTYPE;
+          replacement jsonb;
+          capability text;
+        BEGIN
+          SELECT * INTO campaign FROM reward_campaigns
+          WHERE chain_id = 4217 AND vault_address = '0xd730394f3bb85a4828e35fc5e361dcc9f894fa4f'
+          FOR UPDATE;
+          IF NOT FOUND THEN RETURN; END IF;
+
+          replacement := campaign.config;
+          FOREACH capability IN ARRAY ARRAY['targetYield', 'boostRewards'] LOOP
+            IF (replacement -> capability ->> 'endTimestamp')::bigint < 1797526800 THEN
+              replacement := jsonb_set(replacement, ARRAY[capability, 'endTimestamp'], '1797526800'::jsonb);
+            END IF;
+          END LOOP;
+          IF replacement = campaign.config THEN RETURN; END IF;
+
+          IF campaign.pending_config IS NOT NULL OR campaign.pending_effective_at IS NOT NULL THEN
+            RAISE EXCEPTION 'Cannot extend d730 reward campaign: resolve the pending configuration before retrying migration';
+          END IF;
+          IF EXISTS (
+            SELECT 1 FROM reward_runs
+            WHERE chain_id = campaign.chain_id AND vault_address = campaign.vault_address
+              AND (phase <> 'delivered' OR starts_after >= campaign.delivered_through)
+          ) THEN
+            RAISE EXCEPTION 'Cannot extend d730 reward campaign: finish outstanding reward runs before retrying migration';
+          END IF;
+
+          UPDATE reward_campaigns SET config = replacement,
+            updated_at = to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+          WHERE chain_id = campaign.chain_id AND vault_address = campaign.vault_address;
+        END $migration$`,
+      ),
+  },
 ]
 
 /**
@@ -3004,9 +3432,78 @@ export function from(dialect: Dialect): Db {
   return fromDialect(dialect)
 }
 
+/**
+ * Times executions that {@link observe} tagged. Acquisition (pool checkout,
+ * connect) is charged to the connection's next query so cold connects count.
+ */
+function observeDriver(driver: Driver): Driver {
+  const inner = new WeakMap<DatabaseConnection, DatabaseConnection>()
+  const unwrap = (connection: DatabaseConnection) => inner.get(connection) ?? connection
+  return {
+    async acquireConnection() {
+      const start = performance.now()
+      const connection = await driver.acquireConnection()
+      let pending = performance.now() - start
+      const wrapped: DatabaseConnection = {
+        async executeQuery(compiledQuery) {
+          const onQuery = queryObservers.get(compiledQuery.queryId)
+          if (!onQuery) return connection.executeQuery(compiledQuery)
+          const acquired = pending
+          pending = 0
+          const started = performance.now()
+          try {
+            return await connection.executeQuery(compiledQuery)
+          } finally {
+            const query = performance.now() - started
+            onQuery(acquired + query, { acquire: acquired, query })
+          }
+        },
+        streamQuery(compiledQuery, chunkSize) {
+          return connection.streamQuery(compiledQuery, chunkSize)
+        },
+      }
+      inner.set(wrapped, connection)
+      return wrapped
+    },
+    beginTransaction: (connection, settings) =>
+      driver.beginTransaction(unwrap(connection), settings),
+    commitTransaction: (connection) => driver.commitTransaction(unwrap(connection)),
+    destroy: () => driver.destroy(),
+    init: () => driver.init(),
+    releaseConnection: (connection) => driver.releaseConnection(unwrap(connection)),
+    rollbackTransaction: (connection) => driver.rollbackTransaction(unwrap(connection)),
+    ...(driver.releaseSavepoint
+      ? {
+          releaseSavepoint: (connection, name, compile) =>
+            driver.releaseSavepoint!(unwrap(connection), name, compile),
+        }
+      : {}),
+    ...(driver.rollbackToSavepoint
+      ? {
+          rollbackToSavepoint: (connection, name, compile) =>
+            driver.rollbackToSavepoint!(unwrap(connection), name, compile),
+        }
+      : {}),
+    ...(driver.savepoint
+      ? {
+          savepoint: (connection, name, compile) =>
+            driver.savepoint!(unwrap(connection), name, compile),
+        }
+      : {}),
+  }
+}
+
 /** Builds a database with internal dialect-specific options. */
 function fromDialect(dialect: Dialect, options: fromDialect.Options = {}): Db {
-  const root = new Kysely<Database>({ dialect, plugins: [new CamelCasePlugin()] })
+  // Delegate method by method: the dialect is a class instance, so a spread
+  // would drop its prototype methods.
+  const observed: Dialect = {
+    createAdapter: () => dialect.createAdapter(),
+    createDriver: () => observeDriver(dialect.createDriver()),
+    createIntrospector: (db) => dialect.createIntrospector(db),
+    createQueryCompiler: () => dialect.createQueryCompiler(),
+  }
+  const root = new Kysely<Database>({ dialect: observed, plugins: [new CamelCasePlugin()] })
   // Qualify repository queries instead of relying on session search_path;
   // transaction poolers reset session state between statements.
   const kysely = options.schema ? root.withPlugin(new WithSchemaPlugin(options.schema)) : root