@secondlayer/shared 7.11.2 → 8.0.0

package/dist/src/db/queries/subgraphs.js

@@ -14,139 +14,34 @@ var __export = (target, all) => {
     });
 };
 
-// src/env.ts
-import { z } from "zod";
-var networksSchema = z.string().transform((val) => {
-  const networks = val.split(",").map((n) => n.trim()).filter(Boolean);
-  const valid = ["mainnet", "testnet"];
-  for (const n of networks) {
-    if (!valid.includes(n)) {
-      throw new Error(`Invalid network: ${n}. Must be one of: ${valid.join(", ")}`);
-    }
-  }
-  return networks;
-});
-var envSchema = z.object({
-  DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
-  SOURCE_DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
-  TARGET_DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
-  NETWORK: z.enum(["mainnet", "testnet"]).optional(),
-  NETWORKS: networksSchema.optional(),
-  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
-  NODE_ENV: z.enum(["development", "production", "test"]).default("development")
-});
-var cachedEnv = null;
-function getEnv() {
-  if (cachedEnv) {
-    return cachedEnv;
-  }
-  const result = envSchema.safeParse(process.env);
-  if (!result.success) {
-    console.error("❌ Invalid environment configuration:");
-    console.error(z.treeifyError(result.error));
-    throw new Error("Invalid environment configuration");
-  }
-  let enabledNetworks;
-  if (result.data.NETWORKS && result.data.NETWORKS.length > 0) {
-    enabledNetworks = result.data.NETWORKS;
-  } else if (result.data.NETWORK) {
-    enabledNetworks = [result.data.NETWORK];
-  } else {
-    enabledNetworks = ["mainnet"];
-  }
-  cachedEnv = { ...result.data, enabledNetworks };
-  return cachedEnv;
-}
-function isProductionEnv() {
-  return process.env["NODE_ENV"] === "production";
-}
-function isPox4DecoderEnabled() {
-  return process.env.POX4_DECODER_ENABLED !== "false";
-}
-function isPox5DecoderEnabled() {
-  return process.env.POX5_DECODER_ENABLED !== "false";
-}
-// src/logger.ts
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-
-class Logger {
-  _level;
-  _isProduction;
-  _initialized = false;
-  init() {
-    if (this._initialized)
-      return;
-    this._initialized = true;
-    try {
-      const env = getEnv();
-      this._level = env.LOG_LEVEL;
-      this._isProduction = env.NODE_ENV === "production";
-    } catch {
-      this._level = "info";
-      this._isProduction = false;
-    }
-  }
-  get level() {
-    this.init();
-    return this._level;
-  }
-  get isProduction() {
-    this.init();
-    return this._isProduction;
-  }
-  shouldLog(level) {
-    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
-  }
-  formatMessage(level, message, meta) {
-    const timestamp = new Date().toISOString();
-    if (this.isProduction) {
-      return JSON.stringify({
-        timestamp,
-        level,
-        message,
-        ...meta
-      });
-    }
-    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
-    return `[${timestamp}] ${level.toUpperCase()}: ${message}${metaStr}`;
-  }
-  debug(message, meta) {
-    if (this.shouldLog("debug")) {
-      console.debug(this.formatMessage("debug", message, meta));
-    }
-  }
-  info(message, meta) {
-    if (this.shouldLog("info")) {
-      console.info(this.formatMessage("info", message, meta));
-    }
-  }
-  warn(message, meta) {
-    if (this.shouldLog("warn")) {
-      console.warn(this.formatMessage("warn", message, meta));
-    }
-  }
-  error(message, meta) {
-    if (this.shouldLog("error")) {
-      console.error(this.formatMessage("error", message, meta));
-    }
-  }
-}
-var logger = new Logger;
-
 // src/mode.ts
-var VALID_MODES = ["oss", "platform"];
-function getInstanceMode() {
+var VALID_MODES = [
+  "oss",
+  "platform",
+  "archive"
+];
+function declaredMode() {
   const raw = process.env.INSTANCE_MODE?.trim().toLowerCase();
   if (raw && VALID_MODES.includes(raw)) {
     return raw;
   }
   return "oss";
 }
+function getInstanceMode() {
+  const declared = declaredMode();
+  return declared === "archive" ? "platform" : declared;
+}
+function getDeclaredInstanceMode() {
+  return declaredMode();
+}
+function isMeteredReads() {
+  const override = process.env.METERED_READS?.trim().toLowerCase();
+  if (override === "true")
+    return true;
+  if (override === "false")
+    return false;
+  return getInstanceMode() === "platform";
+}
 function isPlatformMode() {
   return getInstanceMode() === "platform";
 }
@@ -171,934 +66,8 @@ function parseJsonb(value) {
   return value ?? {};
 }
 
-// src/db/index.ts
-import { Kysely } from "kysely";
-import { PostgresJSDialect } from "kysely-postgres-js";
-import postgres from "postgres";
-import { sql as sql2 } from "kysely";
-
-// src/db/source-read-columns.ts
-var SOURCE_READ_COLUMNS = {
-  blocks: [
-    "burn_block_hash",
-    "burn_block_height",
-    "canonical",
-    "hash",
-    "height",
-    "parent_hash",
-    "timestamp"
-  ],
-  decoded_events: [
-    "amount",
-    "asset_identifier",
-    "block_height",
-    "canonical",
-    "contract_id",
-    "cursor",
-    "event_index",
-    "event_type",
-    "memo",
-    "payload",
-    "recipient",
-    "sender",
-    "tx_id",
-    "tx_index",
-    "value"
-  ],
-  transactions: [
-    "block_height",
-    "contract_id",
-    "function_args",
-    "function_name",
-    "raw_result",
-    "raw_tx",
-    "sender",
-    "status",
-    "tx_id",
-    "tx_index",
-    "type"
-  ],
-  mempool_transactions: [
-    "contract_id",
-    "function_args",
-    "function_name",
-    "raw_tx",
-    "received_at",
-    "sender",
-    "seq",
-    "tx_id",
-    "type"
-  ],
-  pox4_calls: [
-    "aggregated_amount_ustx",
-    "aggregated_signer_index",
-    "amount_ustx",
-    "auth_allowed",
-    "auth_id",
-    "auth_period",
-    "auth_topic",
-    "block_height",
-    "block_time",
-    "burn_block_height",
-    "caller",
-    "canonical",
-    "cursor",
-    "delegate_to",
-    "end_cycle",
-    "function_name",
-    "lock_period",
-    "max_amount",
-    "pox_addr_btc",
-    "pox_addr_hashbytes",
-    "pox_addr_version",
-    "result_ok",
-    "reward_cycle",
-    "signer_key",
-    "signer_signature",
-    "source_cursor",
-    "stacker",
-    "start_cycle",
-    "tx_id",
-    "tx_index"
-  ],
-  pox5_events: [
-    "amount_sats",
-    "amount_ustx",
-    "block_height",
-    "block_time",
-    "bond_index",
-    "canonical",
-    "cursor",
-    "data",
-    "event_index",
-    "first_reward_cycle",
-    "is_l1_lock",
-    "reward_cycle",
-    "signer",
-    "signer_key",
-    "signer_manager",
-    "staker",
-    "topic",
-    "tx_id",
-    "tx_index",
-    "unlock_burn_height",
-    "unlock_cycle"
-  ],
-  sbtc_events: [
-    "amount",
-    "bitcoin_txid",
-    "block_height",
-    "block_time",
-    "burn_hash",
-    "burn_height",
-    "canonical",
-    "cursor",
-    "event_index",
-    "fee",
-    "governance_contract_type",
-    "governance_new_contract",
-    "max_fee",
-    "output_index",
-    "recipient_btc_hashbytes",
-    "recipient_btc_version",
-    "request_id",
-    "sender",
-    "signer_address",
-    "signer_aggregate_pubkey",
-    "signer_bitmap",
-    "signer_keys_count",
-    "signer_threshold",
-    "sweep_txid",
-    "topic",
-    "tx_id",
-    "tx_index"
-  ],
-  sbtc_token_events: [
-    "amount",
-    "block_height",
-    "block_time",
-    "canonical",
-    "cursor",
-    "event_index",
-    "event_type",
-    "memo",
-    "recipient",
-    "sender",
-    "tx_id",
-    "tx_index"
-  ],
-  bns_name_events: [
-    "block_height",
-    "block_time",
-    "bns_id",
-    "canonical",
-    "cursor",
-    "event_index",
-    "fqn",
-    "hashed_salted_fqn_preorder",
-    "imported_at",
-    "name",
-    "namespace",
-    "owner",
-    "preordered_by",
-    "registered_at",
-    "renewal_height",
-    "stx_burn",
-    "topic",
-    "tx_id",
-    "tx_index"
-  ],
-  bns_namespace_events: [
-    "block_height",
-    "block_time",
-    "canonical",
-    "cursor",
-    "event_index",
-    "launched_at",
-    "lifetime",
-    "manager",
-    "manager_frozen",
-    "manager_transfers_disabled",
-    "namespace",
-    "price_frozen",
-    "price_function",
-    "revealed_at",
-    "status",
-    "tx_id",
-    "tx_index"
-  ],
-  bns_marketplace_events: [
-    "action",
-    "block_height",
-    "block_time",
-    "bns_id",
-    "canonical",
-    "commission",
-    "cursor",
-    "event_index",
-    "price_ustx",
-    "tx_id",
-    "tx_index"
-  ],
-  bns_names: [
-    "bns_id",
-    "fqn",
-    "last_event_at",
-    "last_event_cursor",
-    "name",
-    "namespace",
-    "owner",
-    "registered_at",
-    "renewal_height"
-  ],
-  bns_namespaces: [
-    "last_event_at",
-    "last_event_cursor",
-    "launched_at",
-    "lifetime",
-    "manager",
-    "manager_frozen",
-    "name_count",
-    "namespace",
-    "price_frozen"
-  ],
-  burn_block_rewards: [
-    "amount_sats",
-    "burn_amount",
-    "burn_block_hash",
-    "burn_block_height",
-    "cursor",
-    "recipient_btc",
-    "reward_index"
-  ],
-  burn_block_reward_slots: [
-    "burn_block_hash",
-    "burn_block_height",
-    "cursor",
-    "holder_btc",
-    "slot_index"
-  ],
-  events: ["block_height", "data", "event_index", "tx_id", "type"],
-  chain_reorgs: ["detected_at"]
-};
-var SOURCE_READ_TYPES = {
-  blocks: {
-    burn_block_hash: { type: "text", nullable: true },
-    burn_block_height: { type: "int" },
-    canonical: { type: "boolean" },
-    hash: { type: "text" },
-    height: { type: "int" },
-    parent_hash: { type: "text" },
-    timestamp: { type: "int" }
-  },
-  decoded_events: {
-    amount: { type: "text", nullable: true },
-    asset_identifier: { type: "text", nullable: true },
-    block_height: { type: "int" },
-    canonical: { type: "boolean" },
-    contract_id: { type: "text", nullable: true },
-    cursor: { type: "text" },
-    event_index: { type: "int" },
-    event_type: { type: "text" },
-    memo: { type: "text", nullable: true },
-    payload: { type: "jsonb", nullable: true },
-    recipient: { type: "text", nullable: true },
-    sender: { type: "text", nullable: true },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" },
-    value: { type: "text", nullable: true }
-  },
-  transactions: {
-    block_height: { type: "int" },
-    contract_id: { type: "text", nullable: true },
-    function_args: { type: "jsonb", nullable: true },
-    function_name: { type: "text", nullable: true },
-    raw_result: { type: "text", nullable: true },
-    raw_tx: { type: "text" },
-    sender: { type: "text" },
-    status: { type: "text" },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" },
-    type: { type: "text" }
-  },
-  mempool_transactions: {
-    contract_id: { type: "text", nullable: true },
-    function_args: { type: "jsonb", nullable: true },
-    function_name: { type: "text", nullable: true },
-    raw_tx: { type: "text" },
-    received_at: { type: "timestamp" },
-    sender: { type: "text" },
-    seq: { type: "text" },
-    tx_id: { type: "text" },
-    type: { type: "text" }
-  },
-  pox4_calls: {
-    aggregated_amount_ustx: { type: "text", nullable: true },
-    aggregated_signer_index: { type: "int", nullable: true },
-    amount_ustx: { type: "text", nullable: true },
-    auth_allowed: { type: "boolean", nullable: true },
-    auth_id: { type: "text", nullable: true },
-    auth_period: { type: "int", nullable: true },
-    auth_topic: { type: "text", nullable: true },
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    burn_block_height: { type: "int" },
-    caller: { type: "text" },
-    canonical: { type: "boolean" },
-    cursor: { type: "text" },
-    delegate_to: { type: "text", nullable: true },
-    end_cycle: { type: "int", nullable: true },
-    function_name: { type: "text" },
-    lock_period: { type: "int", nullable: true },
-    max_amount: { type: "text", nullable: true },
-    pox_addr_btc: { type: "text", nullable: true },
-    pox_addr_hashbytes: { type: "text", nullable: true },
-    pox_addr_version: { type: "int", nullable: true },
-    result_ok: { type: "boolean" },
-    reward_cycle: { type: "int", nullable: true },
-    signer_key: { type: "text", nullable: true },
-    signer_signature: { type: "text", nullable: true },
-    source_cursor: { type: "text" },
-    stacker: { type: "text", nullable: true },
-    start_cycle: { type: "int", nullable: true },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" }
-  },
-  pox5_events: {
-    amount_sats: { type: "text", nullable: true },
-    amount_ustx: { type: "text", nullable: true },
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    bond_index: { type: "int", nullable: true },
-    canonical: { type: "boolean" },
-    cursor: { type: "text" },
-    data: { type: "jsonb", nullable: true },
-    event_index: { type: "int" },
-    first_reward_cycle: { type: "int", nullable: true },
-    is_l1_lock: { type: "boolean", nullable: true },
-    reward_cycle: { type: "int", nullable: true },
-    signer: { type: "text", nullable: true },
-    signer_key: { type: "text", nullable: true },
-    signer_manager: { type: "text", nullable: true },
-    staker: { type: "text", nullable: true },
-    topic: { type: "text" },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" },
-    unlock_burn_height: { type: "int", nullable: true },
-    unlock_cycle: { type: "int", nullable: true }
-  },
-  sbtc_events: {
-    amount: { type: "text", nullable: true },
-    bitcoin_txid: { type: "text", nullable: true },
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    burn_hash: { type: "text", nullable: true },
-    burn_height: { type: "int", nullable: true },
-    canonical: { type: "boolean" },
-    cursor: { type: "text" },
-    event_index: { type: "int" },
-    fee: { type: "text", nullable: true },
-    governance_contract_type: { type: "int", nullable: true },
-    governance_new_contract: { type: "text", nullable: true },
-    max_fee: { type: "text", nullable: true },
-    output_index: { type: "int", nullable: true },
-    recipient_btc_hashbytes: { type: "text", nullable: true },
-    recipient_btc_version: { type: "int", nullable: true },
-    request_id: { type: "int", nullable: true },
-    sender: { type: "text", nullable: true },
-    signer_address: { type: "text", nullable: true },
-    signer_aggregate_pubkey: { type: "text", nullable: true },
-    signer_bitmap: { type: "text", nullable: true },
-    signer_keys_count: { type: "int", nullable: true },
-    signer_threshold: { type: "int", nullable: true },
-    sweep_txid: { type: "text", nullable: true },
-    topic: { type: "text" },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" }
-  },
-  sbtc_token_events: {
-    amount: { type: "text" },
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    canonical: { type: "boolean" },
-    cursor: { type: "text" },
-    event_index: { type: "int" },
-    event_type: { type: "text" },
-    memo: { type: "text", nullable: true },
-    recipient: { type: "text", nullable: true },
-    sender: { type: "text", nullable: true },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" }
-  },
-  bns_name_events: {
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    bns_id: { type: "text" },
-    canonical: { type: "boolean" },
-    cursor: { type: "text" },
-    event_index: { type: "int" },
-    fqn: { type: "text" },
-    hashed_salted_fqn_preorder: { type: "text", nullable: true },
-    imported_at: { type: "int", nullable: true },
-    name: { type: "text" },
-    namespace: { type: "text" },
-    owner: { type: "text", nullable: true },
-    preordered_by: { type: "text", nullable: true },
-    registered_at: { type: "int", nullable: true },
-    renewal_height: { type: "int", nullable: true },
-    stx_burn: { type: "text", nullable: true },
-    topic: { type: "text" },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" }
-  },
-  bns_namespace_events: {
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    canonical: { type: "boolean" },
-    cursor: { type: "text" },
-    event_index: { type: "int" },
-    launched_at: { type: "int", nullable: true },
-    lifetime: { type: "int", nullable: true },
-    manager: { type: "text", nullable: true },
-    manager_frozen: { type: "boolean", nullable: true },
-    manager_transfers_disabled: { type: "boolean", nullable: true },
-    namespace: { type: "text" },
-    price_frozen: { type: "boolean", nullable: true },
-    price_function: { type: "text", nullable: true },
-    revealed_at: { type: "int", nullable: true },
-    status: { type: "text" },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" }
-  },
-  bns_marketplace_events: {
-    action: { type: "text" },
-    block_height: { type: "int" },
-    block_time: { type: "timestamp" },
-    bns_id: { type: "text" },
-    canonical: { type: "boolean" },
-    commission: { type: "text", nullable: true },
-    cursor: { type: "text" },
-    event_index: { type: "int" },
-    price_ustx: { type: "text", nullable: true },
-    tx_id: { type: "text" },
-    tx_index: { type: "int" }
-  },
-  bns_names: {
-    bns_id: { type: "text" },
-    fqn: { type: "text" },
-    last_event_at: { type: "timestamp" },
-    last_event_cursor: { type: "text" },
-    name: { type: "text" },
-    namespace: { type: "text" },
-    owner: { type: "text" },
-    registered_at: { type: "int", nullable: true },
-    renewal_height: { type: "int", nullable: true }
-  },
-  bns_namespaces: {
-    last_event_at: { type: "timestamp" },
-    last_event_cursor: { type: "text" },
-    launched_at: { type: "int", nullable: true },
-    lifetime: { type: "int", nullable: true },
-    manager: { type: "text", nullable: true },
-    manager_frozen: { type: "boolean" },
-    name_count: { type: "int" },
-    namespace: { type: "text" },
-    price_frozen: { type: "boolean" }
-  },
-  burn_block_rewards: {
-    amount_sats: { type: "text" },
-    burn_amount: { type: "text" },
-    burn_block_hash: { type: "text" },
-    burn_block_height: { type: "int" },
-    cursor: { type: "text" },
-    recipient_btc: { type: "text" },
-    reward_index: { type: "int" }
-  },
-  burn_block_reward_slots: {
-    burn_block_hash: { type: "text" },
-    burn_block_height: { type: "int" },
-    cursor: { type: "text" },
-    holder_btc: { type: "text" },
-    slot_index: { type: "int" }
-  },
-  events: {
-    block_height: { type: "int" },
-    data: { type: "jsonb" },
-    event_index: { type: "int" },
-    tx_id: { type: "text" },
-    type: { type: "text" }
-  },
-  chain_reorgs: {
-    detected_at: { type: "timestamp" }
-  }
-};
-var SOURCE_READ_PKS = {
-  blocks: ["height"],
-  decoded_events: ["cursor"],
-  transactions: ["tx_id"],
-  mempool_transactions: ["seq"],
-  pox4_calls: ["cursor"],
-  pox5_events: ["cursor"],
-  sbtc_events: ["cursor"],
-  sbtc_token_events: ["cursor"],
-  bns_name_events: ["cursor"],
-  bns_namespace_events: ["cursor"],
-  bns_marketplace_events: ["cursor"],
-  bns_names: ["fqn"],
-  bns_namespaces: ["namespace"],
-  burn_block_rewards: ["cursor"],
-  burn_block_reward_slots: ["cursor"],
-  events: ["tx_id", "event_index"],
-  chain_reorgs: null
-};
-// src/db/migration-role.ts
-var currentRole = "both";
-function setMigrationRole(role) {
-  currentRole = role;
-}
-function getMigrationRole() {
-  return currentRole;
-}
-async function onControlPlane(fn) {
-  if (currentRole === "target" || currentRole === "both")
-    await fn();
-}
-async function onChainPlane(fn) {
-  if (currentRole === "source" || currentRole === "both")
-    await fn();
-}
-// src/db/table-plane.ts
-var TABLE_TO_DB = {
-  blocks: "source",
-  transactions: "source",
-  events: "source",
-  transactions_archive: "source",
-  events_archive: "source",
-  dead_letter_events: "source",
-  mempool_transactions: "source",
-  index_progress: "source",
-  contracts: "source",
-  chain_reorgs: "source",
-  chain_read_cache: "source",
-  pending_fork_blocks: "source",
-  observer_journal: "source",
-  stage_registry: "source",
-  stage_runs: "source",
-  stage_block_receipts: "source",
-  coverage_segments: "source",
-  stage_failures: "source",
-  decoded_events: "source",
-  decoder_checkpoints: "source",
-  pox4_calls: "source",
-  pox4_cycles_daily: "source",
-  pox4_signers_daily: "source",
-  pox5_events: "source",
-  burn_block_rewards: "source",
-  burn_block_reward_slots: "source",
-  sbtc_events: "source",
-  sbtc_token_events: "source",
-  sbtc_settlements: "source",
-  sbtc_supply_snapshots: "source",
-  bns_name_events: "source",
-  bns_namespace_events: "source",
-  bns_marketplace_events: "source",
-  bns_names: "source",
-  bns_namespaces: "source",
-  instances: "target",
-  accounts: "target",
-  api_keys: "target",
-  sessions: "target",
-  magic_links: "target",
-  claim_tokens: "target",
-  usage_daily: "target",
-  usage_snapshots: "target",
-  account_insights: "target",
-  account_agent_runs: "target",
-  account_spend_caps: "target",
-  processed_stripe_events: "target",
-  tenants: "target",
-  tenant_usage_monthly: "target",
-  tenant_compute_addons: "target",
-  provisioning_audit_log: "target",
-  projects: "target",
-  team_members: "target",
-  team_invitations: "target",
-  subscriptions: "target",
-  subscription_outbox: "target",
-  subscription_deliveries: "target",
-  trigger_evaluator_state: "target",
-  subgraphs: "target",
-  subgraph_operations: "target",
-  subgraph_health_snapshots: "target",
-  subgraph_gaps: "target",
-  subgraph_usage_daily: "target",
-  subgraph_processing_stats: "target",
-  subgraph_table_snapshots: "target",
-  x402_payments: "target",
-  x402_balances: "target",
-  account_credits: "target",
-  service_heartbeats: "both"
-};
-
-// src/db/index.ts
-var DEFAULT_URL = "postgres://postgres:postgres@localhost:5432/secondlayer_dev";
-var pools = new Map;
-var poolSeq = 0;
-function maxPools() {
-  return Number.parseInt(process.env.DATABASE_MAX_POOLS ?? "25", 10);
-}
-function evictIfNeeded() {
-  if (pools.size <= maxPools())
-    return;
-  const protectedUrls = new Set([resolveSourceUrl(), resolveTargetUrl()]);
-  let lruUrl;
-  let lruEntry;
-  for (const [url, entry] of pools) {
-    if (protectedUrls.has(url))
-      continue;
-    if (!lruEntry || entry.lastUsed < lruEntry.lastUsed || entry.lastUsed === lruEntry.lastUsed && entry.seq < lruEntry.seq) {
-      lruUrl = url;
-      lruEntry = entry;
-    }
-  }
-  if (!lruUrl || !lruEntry)
-    return;
-  pools.delete(lruUrl);
-  const evicted = lruEntry;
-  evicted.db.destroy().catch(() => {}).then(() => evicted.rawClient.end({ timeout: 5 })).catch(() => {});
-}
-function applicationDatabaseUrl() {
-  return process.env.DATABASE_URL || DEFAULT_URL;
-}
-function resolveSourceUrl() {
-  if (!isPlatformMode())
-    return applicationDatabaseUrl();
-  return process.env.SOURCE_DATABASE_URL || process.env.DATABASE_URL || DEFAULT_URL;
-}
-function resolveTargetUrl() {
-  if (!isPlatformMode())
-    return applicationDatabaseUrl();
-  return process.env.TARGET_DATABASE_URL || process.env.DATABASE_URL || DEFAULT_URL;
-}
-function describeDbUrl(url) {
-  try {
-    const u = new URL(url);
-    return `${u.hostname}${u.port ? `:${u.port}` : ""}${u.pathname}`;
-  } catch {
-    return "invalid-url";
-  }
-}
-var warnedDefaultUrlFallthrough = false;
-function warnIfTestRunFallsThroughToDefault() {
-  if (warnedDefaultUrlFallthrough)
-    return;
-  if (process.env["NODE_ENV"] !== "test")
-    return;
-  if (process.env.DATABASE_URL || process.env.SOURCE_DATABASE_URL || process.env.TARGET_DATABASE_URL) {
-    return;
-  }
-  warnedDefaultUrlFallthrough = true;
-  console.warn(`⚠️  DATABASE_URL unset — falling through to the built-in DEFAULT_URL (${describeDbUrl(DEFAULT_URL)}). Database-backed tests will skip or hit the wrong Postgres. Copy .env.example to .env in this package (see \`bun run db\`).`);
-}
-warnIfTestRunFallsThroughToDefault();
-function getDbSplitStatus() {
-  const source = resolveSourceUrl();
-  const target = resolveTargetUrl();
-  const active = source !== target;
-  return {
-    mode: active ? "split" : "single",
-    active,
-    sourceDb: describeDbUrl(source),
-    targetDb: describeDbUrl(target)
-  };
-}
-function assertDbSplit() {
-  const isProd = isProductionEnv();
-  const wantsSplit = !!(process.env.SOURCE_DATABASE_URL || process.env.TARGET_DATABASE_URL);
-  const databaseUrlSet = !!process.env.DATABASE_URL;
-  const source = resolveSourceUrl();
-  const target = resolveTargetUrl();
-  if (wantsSplit && !databaseUrlSet && (source === DEFAULT_URL || target === DEFAULT_URL)) {
-    const which = source === DEFAULT_URL ? "SOURCE_DATABASE_URL" : "TARGET_DATABASE_URL";
-    const msg = `${which} unset and DATABASE_URL absent — resolving to built-in DEFAULT_URL; refusing to silently use the wrong database`;
-    if (isProd)
-      console.error(`❌ ${msg}`);
-    else
-      console.warn(`⚠️  ${msg}`);
-    return;
-  }
-  if (!wantsSplit) {
-    if (isProd) {
-      console.warn("⚠️  DB split dormant — all services share one Postgres failure domain (SOURCE_/TARGET_DATABASE_URL unset)");
-    }
-    return;
-  }
-  if (source === target) {
-    const msg = "DB split requested but SOURCE_DATABASE_URL === TARGET_DATABASE_URL (check for a typo or a stray DATABASE_URL fallback)";
-    if (isProd)
-      console.error(`❌ ${msg}`);
-    else
-      console.warn(`⚠️  ${msg}`);
-  }
-}
-function getOrCreatePool(url) {
-  const existing = pools.get(url);
-  if (existing) {
-    existing.lastUsed = Date.now();
-    existing.seq = poolSeq++;
-    return existing;
-  }
-  const host = (() => {
-    try {
-      return new URL(url).hostname;
-    } catch {
-      return "";
-    }
-  })();
-  const isLocal = host === "localhost" || host === "127.0.0.1" || !host.includes(".");
-  const poolMax = Number.parseInt(process.env.DATABASE_POOL_MAX ?? "20", 10);
-  const idleTimeout = Number.parseInt(process.env.DATABASE_IDLE_TIMEOUT ?? "300", 10);
-  const rawClient = postgres(url, {
-    max: poolMax,
-    idle_timeout: idleTimeout,
-    ssl: isLocal ? undefined : {
-      rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== "0"
-    }
-  });
-  const db = new Kysely({
-    dialect: new PostgresJSDialect({ postgres: rawClient }),
-    log: (event) => {
-      if (event.level !== "error")
-        return;
-      const err = event.error;
-      if (err?.code !== "42P10")
-        return;
-      logger.warn("db.on_conflict_constraint_missing", {
-        code: err.code,
-        message: err.message,
-        sql: event.query.sql,
-        params: event.query.parameters
-      });
-    }
-  });
-  const entry = {
-    db,
-    rawClient,
-    lastUsed: Date.now(),
-    seq: poolSeq++
-  };
-  pools.set(url, entry);
-  evictIfNeeded();
-  return entry;
-}
-function getSourceDb() {
-  return getOrCreatePool(resolveSourceUrl()).db;
-}
-function getTargetDb() {
-  return getOrCreatePool(resolveTargetUrl()).db;
-}
-function getDb(connectionString) {
-  if (connectionString)
-    return getOrCreatePool(connectionString).db;
-  return getTargetDb();
-}
-function getRawClient(role = "target") {
-  const url = role === "source" ? resolveSourceUrl() : resolveTargetUrl();
-  return getOrCreatePool(url).rawClient;
-}
-function getRawClientFor(url) {
-  return getOrCreatePool(url).rawClient;
-}
-async function closeDb() {
-  for (const entry of pools.values()) {
-    await entry.db.destroy();
-    await entry.rawClient.end();
-  }
-  pools.clear();
-}
-// src/crypto/secrets.ts
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-import {
-  appendFileSync,
-  closeSync,
-  existsSync,
-  openSync,
-  readFileSync,
-  unlinkSync
-} from "node:fs";
-import { resolve } from "node:path";
-var KEY_ENV = "SECONDLAYER_SECRETS_KEY";
-var IV_LEN = 12;
-var TAG_LEN = 16;
-function readExistingKey(envPath) {
-  if (!existsSync(envPath))
-    return null;
-  const contents = readFileSync(envPath, "utf8");
-  const match = contents.match(/^SECONDLAYER_SECRETS_KEY=([a-fA-F0-9]{64})/m);
-  return match ? match[1] : null;
-}
-var STALE_LOCK_MS = 1e4;
-var POLL_MS = 25;
-function bootstrapOssKey() {
-  const envPath = resolve(process.cwd(), ".env.local");
-  const existing = readExistingKey(envPath);
-  if (existing) {
-    process.env[KEY_ENV] = existing;
-    return existing;
-  }
-  const lockPath = `${envPath}.secret-bootstrap.lock`;
-  let lockFd = null;
-  try {
-    lockFd = openSync(lockPath, "wx", 384);
-  } catch (err) {
-    const e = err;
-    if (e.code !== "EEXIST")
-      throw err;
-  }
-  if (lockFd === null) {
-    const deadline = Date.now() + STALE_LOCK_MS;
-    while (Date.now() < deadline) {
-      const key = readExistingKey(envPath);
-      if (key) {
-        process.env[KEY_ENV] = key;
-        return key;
-      }
-      Bun.sleepSync(POLL_MS);
-    }
-    try {
-      unlinkSync(lockPath);
-    } catch {}
-    return bootstrapOssKey();
-  }
-  try {
-    const hex = randomBytes(32).toString("hex");
-    const line = `${existsSync(envPath) ? `
-` : ""}${KEY_ENV}=${hex}
-`;
-    appendFileSync(envPath, line, { mode: 384 });
-    process.env[KEY_ENV] = hex;
-    console.log(`[secondlayer] generated ${KEY_ENV}; saved to ${envPath} (mode 0600)`);
-    return hex;
-  } finally {
-    closeSync(lockFd);
-    try {
-      unlinkSync(lockPath);
-    } catch {}
-  }
-}
-function loadKey() {
-  let hex = process.env[KEY_ENV];
-  if (!hex) {
-    if (getInstanceMode() === "oss") {
-      hex = bootstrapOssKey();
-    } else {
-      throw new Error(`${KEY_ENV} not set. Generate one with: openssl rand -hex 32`);
-    }
-  }
-  const key = Buffer.from(hex, "hex");
-  if (key.length !== 32) {
-    throw new Error(`${KEY_ENV} must be 32 bytes hex (got ${key.length})`);
-  }
-  return key;
-}
-var _cachedKey = null;
-function getKey() {
-  if (!_cachedKey)
-    _cachedKey = loadKey();
-  return _cachedKey;
-}
-function secretsKeyAvailable() {
-  if (process.env[KEY_ENV])
-    return true;
-  if (getInstanceMode() === "oss") {
-    const envPath = resolve(process.cwd(), ".env.local");
-    return readExistingKey(envPath) !== null;
-  }
-  return false;
-}
-function encryptSecret(plaintext) {
-  const key = getKey();
-  const iv = randomBytes(IV_LEN);
-  const cipher = createCipheriv("aes-256-gcm", key, iv);
-  const ciphertext = Buffer.concat([
-    cipher.update(plaintext, "utf8"),
-    cipher.final()
-  ]);
-  const tag = cipher.getAuthTag();
-  return Buffer.concat([iv, tag, ciphertext]);
-}
-function decryptSecret(envelope) {
-  const key = getKey();
-  const iv = envelope.subarray(0, IV_LEN);
-  const tag = envelope.subarray(IV_LEN, IV_LEN + TAG_LEN);
-  const ciphertext = envelope.subarray(IV_LEN + TAG_LEN);
-  const decipher = createDecipheriv("aes-256-gcm", key, iv);
-  decipher.setAuthTag(tag);
-  return decipher.update(ciphertext).toString("utf8") + decipher.final("utf8");
-}
-function generateSecretsKey() {
-  return randomBytes(32).toString("hex");
-}
-
 // src/db/queries/subgraphs.ts
-import { sql as sql3 } from "kysely";
-function encryptDatabaseUrl(url) {
-  return encryptSecret(url);
-}
-function subgraphDatabaseUrl(subgraph) {
-  return subgraph.database_url_enc ? decryptSecret(subgraph.database_url_enc) : null;
-}
-function isByoSubgraph(subgraph) {
-  return subgraph.database_url_enc != null;
-}
-function resolveSubgraphDb(subgraph) {
-  const url = subgraphDatabaseUrl(subgraph);
-  return url ? getDb(url) : getTargetDb();
-}
-function resolveSubgraphRawClient(subgraph) {
-  const url = subgraphDatabaseUrl(subgraph);
-  return url ? getRawClientFor(url) : getRawClient("target");
-}
+import { sql as sql2 } from "kysely";
 function pgSchemaName(subgraphName) {
   const safeName = subgraphName.replace(/-/g, "_");
   return `subgraph_${safeName}`;
@@ -1128,7 +97,7 @@ async function registerSubgraph(db, data) {
     source_code: data.sourceCode ?? null,
     schema_name: data.schemaName ?? null,
     start_block: data.startBlock ?? 0,
-    database_url_enc: data.databaseUrlEnc ?? null
+    database_url_enc: null
   };
   const updateSet = {
     version: data.version,
@@ -1139,7 +108,7 @@ async function registerSubgraph(db, data) {
     source_code: data.sourceCode ?? null,
     schema_name: data.schemaName ?? null,
     start_block: data.startBlock ?? 0,
-    database_url_enc: data.databaseUrlEnc ?? null,
+    database_url_enc: null,
     updated_at: new Date
   };
   if (!isPlatformMode()) {
@@ -1188,8 +157,8 @@ async function recordLiveError(db, name, blockHeight) {
 }
 async function recordSubgraphProcessed(db, name, processed, errors, lastError) {
   await db.updateTable("subgraphs").set({
-    total_processed: sql3`total_processed + ${processed}`,
-    total_errors: sql3`total_errors + ${errors}`,
+    total_processed: sql2`total_processed + ${processed}`,
+    total_errors: sql2`total_errors + ${errors}`,
     ...lastError ? { last_error: lastError, last_error_at: new Date } : {},
     updated_at: new Date
   }).where("name", "=", name).execute();
@@ -1213,9 +182,7 @@ async function deleteSubgraph(db, name, accountId) {
     updated_at: new Date
   }).where("subgraph_name", "=", name).execute();
   await db.deleteFrom("subscription_outbox").where("status", "=", "pending").where("subscription_id", "in", (qb) => qb.selectFrom("subscriptions").select("id").where("subgraph_name", "=", name)).execute();
-  if (!isByoSubgraph(subgraph)) {
-    await sql3`DROP SCHEMA IF EXISTS ${sql3.raw(`"${schemaName}"`)} CASCADE`.execute(db);
-  }
+  await sql2`DROP SCHEMA IF EXISTS ${sql2.raw(`"${schemaName}"`)} CASCADE`.execute(db);
   await db.deleteFrom("subgraphs").where("id", "=", subgraph.id).execute();
   return subgraph;
 }
@@ -1225,7 +192,7 @@ async function updateSubgraphExpiry(db, name, accountId, expiresAt) {
 async function recordLiveProgress(db, name, lastProcessedBlock) {
   const result = await db.updateTable("subgraphs").set({
     last_processed_block: lastProcessedBlock,
-    status: sql3`CASE WHEN status = 'reindexing' THEN status ELSE 'active' END`,
+    status: sql2`CASE WHEN status = 'reindexing' THEN status ELSE 'active' END`,
     updated_at: new Date
   }).where("name", "=", name).where("last_processed_block", "<", lastProcessedBlock).executeTakeFirst();
   return Number(result.numUpdatedRows ?? 0n) > 0;
@@ -1233,7 +200,7 @@ async function recordLiveProgress(db, name, lastProcessedBlock) {
 async function rewindLiveProgress(db, name, lastProcessedBlock) {
   await db.updateTable("subgraphs").set({
     last_processed_block: lastProcessedBlock,
-    status: sql3`CASE WHEN status = 'reindexing' THEN status ELSE 'active' END`,
+    status: sql2`CASE WHEN status = 'reindexing' THEN status ELSE 'active' END`,
     updated_at: new Date
   }).where("name", "=", name).execute();
 }
@@ -1242,10 +209,7 @@ export {
   updateSubgraphStatus,
   updateSubgraphHandlerPath,
   updateSubgraphExpiry,
-  subgraphDatabaseUrl,
   rewindLiveProgress,
-  resolveSubgraphRawClient,
-  resolveSubgraphDb,
   registerSubgraph,
   recordSubgraphProcessed,
   recordLiveProgress,
@@ -1254,12 +218,10 @@ export {
   pgSchemaName,
   localSubgraphAccountId,
   listSubgraphs,
-  isByoSubgraph,
   getSubgraph,
   findPublicSubgraphByName,
-  encryptDatabaseUrl,
   deleteSubgraph
 };
 
-//# debugId=9656EAE5754BCCD264756E2164756E21
+//# debugId=99813C300C0409BA64756E2164756E21
 //# sourceMappingURL=subgraphs.js.map