tapimo 0.15.1 → 0.18.0

package/dist/db/Db.js

@@ -1,5 +1,26 @@
 import { CamelCasePlugin, CompiledQuery, Kysely, PostgresDialect, sql, WithSchemaPlugin, } from 'kysely';
 import * as pg from 'pg';
+/** Per-execution observers, keyed by Kysely's query id so the driver can find them. */
+const queryObservers = new WeakMap();
+/**
+ * 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, options) {
+    // The plugin only tags executions; the driver wrapper installed by
+    // `fromDialect` does the timing, so rejected queries report too.
+    const plugin = {
+        transformQuery(args) {
+            queryObservers.set(args.queryId, options.onQuery);
+            return args.node;
+        },
+        async transformResult(args) {
+            return args.result;
+        },
+    };
+    return { ...db, kysely: db.kysely.withPlugin(plugin) };
+}
 /**
  * Resolves a {@link Source} to a {@link Db}. Call at the request leaf so
  * factories create per-request instances; singletons resolve to themselves.
@@ -2208,6 +2229,331 @@ export const migrations = [
         name: '0270_routes_deposits_legacy_provider_subsidies_reported',
         up: (db) => raw(db, 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$`),
+    },
 ];
 /**
  * Adapts a raw statement to the migration contract (argument-less
@@ -2229,9 +2575,75 @@ function raw(db, statement) {
 export function from(dialect) {
     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) {
+    const inner = new WeakMap();
+    const unwrap = (connection) => inner.get(connection) ?? connection;
+    return {
+        async acquireConnection() {
+            const start = performance.now();
+            const connection = await driver.acquireConnection();
+            let pending = performance.now() - start;
+            const wrapped = {
+                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, options = {}) {
-    const root = new Kysely({ dialect, plugins: [new CamelCasePlugin()] });
+    // Delegate method by method: the dialect is a class instance, so a spread
+    // would drop its prototype methods.
+    const observed = {
+        createAdapter: () => dialect.createAdapter(),
+        createDriver: () => observeDriver(dialect.createDriver()),
+        createIntrospector: (db) => dialect.createIntrospector(db),
+        createQueryCompiler: () => dialect.createQueryCompiler(),
+    };
+    const root = new Kysely({ 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;