sorokeep 1.0.0

package/dist/db/repositories.js

@@ -0,0 +1,809 @@
+export { upsertBudget, getBudget, addBudgetSpent } from "./budget.js";
+// ---------------------------- Database Access Functions For Schema: Contract ----------------------------
+export function insertContract(db, contract) {
+    db.prepare(`
+        INSERT INTO contracts (id, name, network, wasm_hash, tags, poll_interval_seconds, active)
+        VALUES (@id, @name, @network, @wasm_hash, @tags, @poll_interval_seconds, @active)
+        ON CONFLICT(id) DO UPDATE SET
+            name = excluded.name,
+            network = excluded.network,
+            wasm_hash = excluded.wasm_hash,
+            tags = excluded.tags,
+            poll_interval_seconds = COALESCE(excluded.poll_interval_seconds, contracts.poll_interval_seconds),
+            active = COALESCE(excluded.active, contracts.active)
+    `).run({
+        id: contract.id,
+        name: contract.name ?? null,
+        network: contract.network,
+        wasm_hash: contract.wasm_hash ?? null,
+        tags: contract.tags ?? null,
+        poll_interval_seconds: contract.poll_interval_seconds ?? null,
+        active: contract.active ?? 1,
+    });
+}
+export function getContract(db, id) {
+    return db.prepare("SELECT * FROM contracts WHERE id = ?").get(id);
+}
+export function getAllContracts(db) {
+    return db.prepare("SELECT * FROM contracts").all();
+}
+export function updateLastCheckedLedger(db, contractId, ledger) {
+    db.prepare("UPDATE contracts SET last_checked_ledger = ? WHERE id = ?").run(ledger, contractId);
+}
+export function deleteContract(db, id) {
+    db.prepare("DELETE FROM contracts WHERE id = ?").run(id);
+}
+export function updateContractPollInterval(db, contractId, pollIntervalSeconds) {
+    db.prepare("UPDATE contracts SET poll_interval_seconds = ? WHERE id = ?").run(pollIntervalSeconds, contractId);
+}
+export function getContractPollInterval(db, contractId) {
+    const row = db.prepare("SELECT poll_interval_seconds FROM contracts WHERE id = ?").get(contractId);
+    return row?.poll_interval_seconds ?? null;
+}
+export function setContractActiveStatus(db, contractId, active) {
+    db.prepare("UPDATE contracts SET active = ? WHERE id = ?").run(active ? 1 : 0, contractId);
+}
+/**
+ * Record that a successful contract introspection (instance/WASM key discovery)
+ * was performed at the given timestamp. Accepts an ISO-8601 string so callers
+ * can control the clock in tests.
+ */
+export function updateLastIntrospectedAt(db, contractId, isoTimestamp) {
+    db.prepare("UPDATE contracts SET last_introspected_at = ? WHERE id = ?").run(isoTimestamp, contractId);
+}
+/**
+ * Return true when the introspection cache for the given contract is still
+ * valid — i.e. `last_introspected_at` is not NULL and the timestamp is
+ * strictly less than `maxAgeMs` milliseconds ago.
+ *
+ * The default max-age is 24 hours (86 400 000 ms).
+ * The boundary is *exclusive on the valid side*: exactly 24 h ago is expired.
+ */
+export function isIntrospectionCacheValid(db, contractId, maxAgeMs = 24 * 60 * 60 * 1_000) {
+    const row = db
+        .prepare("SELECT last_introspected_at FROM contracts WHERE id = ?")
+        .get(contractId);
+    if (!row || row.last_introspected_at === null)
+        return false;
+    const introspectedAt = new Date(row.last_introspected_at).getTime();
+    const ageMs = Date.now() - introspectedAt;
+    // strictly less than → at exactly 24 h the cache is expired
+    return ageMs < maxAgeMs;
+}
+// ---------------------------- Database Access Functions For Schema: ContractEntry ----------------------------
+export function upsertEntry(db, entry) {
+    db.prepare(`
+    INSERT INTO contract_entries (contract_id, entry_key_xdr, entry_type, label, live_until_ledger, last_modified_ledger, discovery_source, last_checked_at)
+    VALUES (@contract_id, @entry_key_xdr, @entry_type, @label, @live_until_ledger, @last_modified_ledger, @discovery_source, datetime('now'))
+    ON CONFLICT(contract_id, entry_key_xdr) DO UPDATE SET
+      live_until_ledger = @live_until_ledger,
+      last_modified_ledger = @last_modified_ledger,
+      last_checked_at = datetime('now')
+  `).run({
+        contract_id: entry.contract_id,
+        entry_key_xdr: entry.entry_key_xdr,
+        entry_type: entry.entry_type,
+        label: entry.label ?? null,
+        live_until_ledger: entry.live_until_ledger ?? null,
+        last_modified_ledger: entry.last_modified_ledger ?? null,
+        discovery_source: entry.discovery_source ?? "deterministic",
+    });
+}
+export function getEntriesForContract(db, contractId) {
+    return db.prepare("SELECT * FROM contract_entries WHERE contract_id = ?").all(contractId);
+}
+// ---------------------------- Database Access Functions For Other Schema: ExtensionPolicy----------------------------
+export function upsertExtensionPolicy(db, policy) {
+    db.prepare(`
+    INSERT INTO extension_policies (contract_id, enabled, target_ttl_ledgers, extend_when_below_ledgers, keypair_public, keypair_source)
+    VALUES (@contract_id, @enabled, @target_ttl_ledgers, @extend_when_below_ledgers, @keypair_public, @keypair_source)
+    ON CONFLICT(contract_id) DO UPDATE SET
+      enabled = @enabled,
+      target_ttl_ledgers = @target_ttl_ledgers,
+      extend_when_below_ledgers = @extend_when_below_ledgers,
+      keypair_public = @keypair_public,
+      keypair_source = @keypair_source
+  `).run({
+        contract_id: policy.contract_id,
+        enabled: policy.enabled !== false ? 1 : 0,
+        target_ttl_ledgers: policy.target_ttl_ledgers,
+        extend_when_below_ledgers: policy.extend_when_below_ledgers,
+        keypair_public: policy.keypair_public ?? null,
+        keypair_source: policy.keypair_source ?? null,
+    });
+}
+export function getExtensionPolicy(db, contractId) {
+    return db.prepare("SELECT * FROM extension_policies WHERE contract_id = ?").get(contractId);
+}
+// ---------------------------- Database Access Functions For Other Schema: AlertConfig----------------------------
+export function insertAlertConfig(db, config) {
+    db.prepare(`
+    INSERT INTO alert_configs (contract_id, channel_type, channel_target, threshold_ledgers, webhook_secret)
+    VALUES (@contract_id, @channel_type, @channel_target, @threshold_ledgers, @webhook_secret)
+  `).run({
+        ...config,
+        webhook_secret: config.webhook_secret ?? null,
+    });
+}
+export function getAlertConfigById(db, id) {
+    return db.prepare("SELECT * FROM alert_configs WHERE id = ?").get(id);
+}
+export function getAlertConfigsForContract(db, contractId) {
+    return db.prepare("SELECT * FROM alert_configs WHERE contract_id = ?").all(contractId);
+}
+export function deleteAlertConfig(db, id) {
+    db.prepare("DELETE FROM alert_configs WHERE id = ?").run(id);
+}
+// ---------------------------- Database Access Functions For Other Schema: AlertFired----------------------------
+export function recordAlertFired(db, alert) {
+    db.prepare(`
+    INSERT INTO alerts_fired (alert_config_id, contract_entry_id, fired_at_ledger, ttl_at_fire)
+    VALUES (@alert_config_id, @contract_entry_id, @fired_at_ledger, @ttl_at_fire)
+  `).run(alert);
+}
+export function hasUnresolvedAlert(db, alertConfigId, entryId) {
+    const row = db.prepare(`
+    SELECT 1 FROM alerts_fired
+    WHERE alert_config_id = ? AND contract_entry_id = ? AND resolved = 0
+    LIMIT 1
+  `).get(alertConfigId, entryId);
+    return row !== undefined;
+}
+export function resolveAlerts(db, entryId, alertConfigId) {
+    const rows = db.prepare(`
+    SELECT alert_config_id FROM alerts_fired
+    WHERE contract_entry_id = ? AND alert_config_id = ? AND resolved = 0
+  `).all(entryId, alertConfigId);
+    if (rows.length > 0) {
+        db.prepare(`
+      UPDATE alerts_fired SET resolved = 1, resolved_at = datetime('now')
+      WHERE contract_entry_id = ? AND alert_config_id = ? AND resolved = 0
+    `).run(entryId, alertConfigId);
+    }
+    return rows.map(r => r.alert_config_id);
+}
+// ---------------------------- Database Access Functions For Other Schema: ExtensionRecord----------------------------
+export function recordExtension(db, record) {
+    db.prepare(`
+    INSERT INTO extension_history (contract_id, contract_entry_id, old_ttl_ledgers, new_ttl_ledgers, tx_hash, cost_xlm, cpu_insns, mem_bytes, is_anomaly, executed_at_ledger)
+    VALUES (@contract_id, @contract_entry_id, @old_ttl_ledgers, @new_ttl_ledgers, @tx_hash, @cost_xlm, @cpu_insns, @mem_bytes, @is_anomaly, @executed_at_ledger)
+  `).run({
+        ...record,
+        cost_xlm: record.cost_xlm ?? null,
+        cpu_insns: record.cpu_insns ?? null,
+        mem_bytes: record.mem_bytes ?? null,
+        is_anomaly: record.is_anomaly ? 1 : 0,
+    });
+}
+export function getExtensionHistory(db, contractId, days) {
+    if (days) {
+        return db.prepare(`
+      SELECT * FROM extension_history
+      WHERE contract_id = ? AND executed_at >= datetime('now', ?)
+      ORDER BY executed_at DESC
+    `).all(contractId, `-${days} days`);
+    }
+    return db.prepare(`
+    SELECT * FROM extension_history WHERE contract_id = ? ORDER BY executed_at DESC
+  `).all(contractId);
+}
+export function aggregateDailyCostSnapshots(db) {
+    const rows = db.prepare(`
+        SELECT
+            eh.contract_id AS contract_id,
+            date(eh.executed_at) AS snapshot_date,
+            COUNT(*) AS total_extensions,
+            SUM(COALESCE(eh.cost_xlm, 0.0)) AS total_cost_xlm,
+            SUM(CASE WHEN ce.entry_type = 'instance' THEN 1 ELSE 0 END) AS instance_extensions,
+            SUM(CASE WHEN ce.entry_type = 'instance' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END) AS instance_cost_xlm,
+            SUM(CASE WHEN ce.entry_type = 'wasm' THEN 1 ELSE 0 END) AS wasm_extensions,
+            SUM(CASE WHEN ce.entry_type = 'wasm' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END) AS wasm_cost_xlm,
+            SUM(CASE WHEN ce.entry_type = 'persistent' THEN 1 ELSE 0 END) AS persistent_extensions,
+            SUM(CASE WHEN ce.entry_type = 'persistent' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END) AS persistent_cost_xlm,
+            SUM(CASE WHEN ce.entry_type = 'temporary' THEN 1 ELSE 0 END) AS temporary_extensions,
+            SUM(CASE WHEN ce.entry_type = 'temporary' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END) AS temporary_cost_xlm
+        FROM extension_history eh
+        JOIN contract_entries ce ON ce.id = eh.contract_entry_id
+        WHERE date(eh.executed_at) < date('now')
+          AND date(eh.executed_at) >= date('now', '-7 days')
+        GROUP BY eh.contract_id, date(eh.executed_at)
+    `).all();
+    const upsert = db.prepare(`
+        INSERT INTO cost_daily_snapshots (
+            contract_id, snapshot_date,
+            total_extensions, total_cost_xlm,
+            instance_extensions, instance_cost_xlm,
+            wasm_extensions, wasm_cost_xlm,
+            persistent_extensions, persistent_cost_xlm,
+            temporary_extensions, temporary_cost_xlm
+        ) VALUES (
+            @contract_id, @snapshot_date,
+            @total_extensions, @total_cost_xlm,
+            @instance_extensions, @instance_cost_xlm,
+            @wasm_extensions, @wasm_cost_xlm,
+            @persistent_extensions, @persistent_cost_xlm,
+            @temporary_extensions, @temporary_cost_xlm
+        )
+        ON CONFLICT(contract_id, snapshot_date) DO UPDATE SET
+            total_extensions = excluded.total_extensions,
+            total_cost_xlm = excluded.total_cost_xlm,
+            instance_extensions = excluded.instance_extensions,
+            instance_cost_xlm = excluded.instance_cost_xlm,
+            wasm_extensions = excluded.wasm_extensions,
+            wasm_cost_xlm = excluded.wasm_cost_xlm,
+            persistent_extensions = excluded.persistent_extensions,
+            persistent_cost_xlm = excluded.persistent_cost_xlm,
+            temporary_extensions = excluded.temporary_extensions,
+            temporary_cost_xlm = excluded.temporary_cost_xlm
+    `);
+    const transaction = db.transaction((snapshotRows) => {
+        for (const row of snapshotRows) {
+            upsert.run(row);
+        }
+    });
+    transaction(rows);
+}
+export function getCostDailySnapshots(db, contractId, days) {
+    if (days) {
+        return db.prepare(`
+            SELECT * FROM cost_daily_snapshots
+            WHERE contract_id = ? AND snapshot_date >= date('now', ?)
+            ORDER BY snapshot_date DESC
+        `).all(contractId, `-${Math.max(days - 1, 0)} days`);
+    }
+    return db.prepare(`
+        SELECT * FROM cost_daily_snapshots
+        WHERE contract_id = ?
+        ORDER BY snapshot_date DESC
+    `).all(contractId);
+}
+export function getContractCostSummary(db, contractId, days) {
+    const snapshotParams = days ? [`-${Math.max(days - 1, 0)} days`] : [];
+    const snapshotRow = days
+        ? db.prepare(`
+            SELECT
+                COALESCE(SUM(total_extensions), 0) AS total_extensions,
+                COALESCE(SUM(total_cost_xlm), 0.0) AS total_cost_xlm,
+                COALESCE(SUM(instance_extensions), 0) AS instance_extensions,
+                COALESCE(SUM(instance_cost_xlm), 0.0) AS instance_cost_xlm,
+                COALESCE(SUM(wasm_extensions), 0) AS wasm_extensions,
+                COALESCE(SUM(wasm_cost_xlm), 0.0) AS wasm_cost_xlm,
+                COALESCE(SUM(persistent_extensions), 0) AS persistent_extensions,
+                COALESCE(SUM(persistent_cost_xlm), 0.0) AS persistent_cost_xlm,
+                COALESCE(SUM(temporary_extensions), 0) AS temporary_extensions,
+                COALESCE(SUM(temporary_cost_xlm), 0.0) AS temporary_cost_xlm
+            FROM cost_daily_snapshots
+            WHERE contract_id = ? AND snapshot_date >= date('now', ?)
+        `).get(contractId, ...snapshotParams)
+        : db.prepare(`
+            SELECT
+                COALESCE(SUM(total_extensions), 0) AS total_extensions,
+                COALESCE(SUM(total_cost_xlm), 0.0) AS total_cost_xlm,
+                COALESCE(SUM(instance_extensions), 0) AS instance_extensions,
+                COALESCE(SUM(instance_cost_xlm), 0.0) AS instance_cost_xlm,
+                COALESCE(SUM(wasm_extensions), 0) AS wasm_extensions,
+                COALESCE(SUM(wasm_cost_xlm), 0.0) AS wasm_cost_xlm,
+                COALESCE(SUM(persistent_extensions), 0) AS persistent_extensions,
+                COALESCE(SUM(persistent_cost_xlm), 0.0) AS persistent_cost_xlm,
+                COALESCE(SUM(temporary_extensions), 0) AS temporary_extensions,
+                COALESCE(SUM(temporary_cost_xlm), 0.0) AS temporary_cost_xlm
+            FROM cost_daily_snapshots
+            WHERE contract_id = ?
+        `).get(contractId);
+    const currentDayRow = db.prepare(`
+        SELECT
+            COUNT(*) AS total_extensions,
+            COALESCE(SUM(COALESCE(eh.cost_xlm, 0.0)), 0.0) AS total_cost_xlm,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'instance' THEN 1 ELSE 0 END), 0) AS instance_extensions,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'instance' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END), 0.0) AS instance_cost_xlm,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'wasm' THEN 1 ELSE 0 END), 0) AS wasm_extensions,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'wasm' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END), 0.0) AS wasm_cost_xlm,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'persistent' THEN 1 ELSE 0 END), 0) AS persistent_extensions,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'persistent' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END), 0.0) AS persistent_cost_xlm,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'temporary' THEN 1 ELSE 0 END), 0) AS temporary_extensions,
+            COALESCE(SUM(CASE WHEN ce.entry_type = 'temporary' THEN COALESCE(eh.cost_xlm, 0.0) ELSE 0 END), 0.0) AS temporary_cost_xlm
+        FROM extension_history eh
+        JOIN contract_entries ce ON ce.id = eh.contract_entry_id
+        WHERE eh.contract_id = ?
+          AND date(eh.executed_at) = date('now')
+    `).get(contractId);
+    return {
+        contract_id: contractId,
+        total_extensions: Number((snapshotRow.total_extensions ?? 0) + (currentDayRow.total_extensions ?? 0)),
+        total_cost_xlm: Number((snapshotRow.total_cost_xlm ?? 0) + (currentDayRow.total_cost_xlm ?? 0)),
+        byType: {
+            instance: {
+                count: Number((snapshotRow.instance_extensions ?? 0) + (currentDayRow.instance_extensions ?? 0)),
+                cost_xlm: Number((snapshotRow.instance_cost_xlm ?? 0) + (currentDayRow.instance_cost_xlm ?? 0)),
+            },
+            wasm: {
+                count: Number((snapshotRow.wasm_extensions ?? 0) + (currentDayRow.wasm_extensions ?? 0)),
+                cost_xlm: Number((snapshotRow.wasm_cost_xlm ?? 0) + (currentDayRow.wasm_cost_xlm ?? 0)),
+            },
+            persistent: {
+                count: Number((snapshotRow.persistent_extensions ?? 0) + (currentDayRow.persistent_extensions ?? 0)),
+                cost_xlm: Number((snapshotRow.persistent_cost_xlm ?? 0) + (currentDayRow.persistent_cost_xlm ?? 0)),
+            },
+            temporary: {
+                count: Number((snapshotRow.temporary_extensions ?? 0) + (currentDayRow.temporary_extensions ?? 0)),
+                cost_xlm: Number((snapshotRow.temporary_cost_xlm ?? 0) + (currentDayRow.temporary_cost_xlm ?? 0)),
+            },
+        },
+    };
+}
+/**
+ * Count the number of auto-extension transactions that were executed for the
+ * given contract within the last hour.
+ *
+ * Used by the rate limiter to enforce a maximum of N extensions per hour
+ * per contract (issue #142).
+ *
+ * @param db - The SQLite database connection.
+ * @param contractId - The contract to check.
+ * @returns The number of extensions recorded in the last 60 minutes.
+ */
+export function countExtensionsInLastHour(db, contractId) {
+    const row = db.prepare(`
+        SELECT COUNT(*) AS cnt
+        FROM extension_history
+        WHERE contract_id = ?
+          AND datetime(executed_at) >= datetime('now', '-1 hour')
+    `).get(contractId);
+    return row?.cnt ?? 0;
+}
+export function getAverageResourceUsage(db, contractId, limit) {
+    const params = [contractId];
+    let query = `
+    SELECT cpu_insns, mem_bytes
+    FROM extension_history
+    WHERE contract_id = ? AND cpu_insns IS NOT NULL AND mem_bytes IS NOT NULL
+    ORDER BY executed_at DESC, id DESC
+  `;
+    if (limit !== undefined) {
+        query += ` LIMIT ?`;
+        params.push(limit);
+    }
+    const rows = db.prepare(query).all(...params);
+    if (rows.length === 0)
+        return null;
+    const sumCpu = rows.reduce((acc, row) => acc + row.cpu_insns, 0);
+    const sumMem = rows.reduce((acc, row) => acc + row.mem_bytes, 0);
+    return {
+        avg_cpu_insns: sumCpu / rows.length,
+        avg_mem_bytes: sumMem / rows.length,
+        count: rows.length
+    };
+}
+/** Maximum number of delivery attempts before giving up on an alert. */
+export const MAX_RETRY_COUNT = 5;
+/**
+ * Return all undelivered (delivered = 0) alerts for the given network,
+ * joining alerts_fired → alert_configs → contract_entries → contracts.
+ * Alerts that have exceeded MAX_RETRY_COUNT are excluded.
+ */
+export function getUndeliveredAlerts(db, network) {
+    const rows = db.prepare(`
+        SELECT
+            af.id            AS alertFiredId,
+            ac.id            AS alertConfigId,
+            c.id             AS contractId,
+            c.name           AS contractName,
+            c.network        AS network,
+            ce.id            AS entryId,
+            ce.entry_key_xdr AS entryKeyXdr,
+            ce.entry_type    AS entryType,
+            ce.label         AS entryLabel,
+            ac.channel_type  AS channelType,
+            ac.channel_target AS channelTarget,
+            ac.threshold_ledgers AS thresholdLedgers,
+            ac.webhook_secret AS webhookSecret,
+            af.ttl_at_fire   AS remainingTTL,
+            af.fired_at_ledger AS firedAtLedger,
+            af.fired_at      AS firedAt,
+            af.retry_count   AS retryCount
+        FROM alerts_fired af
+        JOIN alert_configs ac  ON ac.id  = af.alert_config_id
+        JOIN contract_entries ce ON ce.id = af.contract_entry_id
+        JOIN contracts c       ON c.id  = ce.contract_id
+        WHERE af.delivered = 0
+          AND af.retry_count < ?
+          AND c.network = ?
+        ORDER BY af.fired_at ASC
+    `).all(MAX_RETRY_COUNT, network);
+    return rows;
+}
+/**
+ * Mark a single alerts_fired record as delivered.
+ * Idempotent — safe to call more than once.
+ */
+export function markAlertDelivered(db, alertFiredId) {
+    db.prepare(`
+        UPDATE alerts_fired
+        SET delivered = 1, delivered_at = datetime('now')
+        WHERE id = ?
+    `).run(alertFiredId);
+}
+/**
+ * Count the number of undelivered alerts for the given network.
+ * Uses the same filtering logic as getUndeliveredAlerts:
+ * - delivered = 0
+ * - retry_count < MAX_RETRY_COUNT
+ * - matches the specified network
+ */
+export function countUndeliveredAlerts(db, network) {
+    const row = db.prepare(`
+        SELECT COUNT(*) as count
+        FROM alerts_fired af
+        JOIN alert_configs ac  ON ac.id  = af.alert_config_id
+        JOIN contract_entries ce ON ce.id = af.contract_entry_id
+        JOIN contracts c       ON c.id  = ce.contract_id
+        WHERE af.delivered = 0
+          AND af.retry_count < ?
+          AND c.network = ?
+    `).get(MAX_RETRY_COUNT, network);
+    return row.count;
+}
+/**
+ * Increment the retry count for a failed alert delivery.
+ */
+export function incrementRetryCount(db, alertFiredId) {
+    db.prepare(`
+        UPDATE alerts_fired
+        SET retry_count = retry_count + 1
+        WHERE id = ?
+    `).run(alertFiredId);
+}
+export function getAlertHistory(db, contractId, limit) {
+    const sql = `
+        SELECT
+            af.id              AS alertFiredId,
+            ac.channel_type    AS channelType,
+            ac.channel_target  AS channelTarget,
+            ce.entry_key_xdr   AS entryKeyXdr,
+            ce.entry_type      AS entryType,
+            ce.label           AS entryLabel,
+            ac.threshold_ledgers AS thresholdLedgers,
+            af.ttl_at_fire     AS ttlAtFire,
+            af.fired_at_ledger AS firedAtLedger,
+            af.fired_at        AS firedAt,
+            af.resolved        AS resolved,
+            af.resolved_at     AS resolvedAt,
+            af.delivered        AS delivered,
+            af.delivered_at    AS deliveredAt,
+            af.retry_count     AS retryCount
+        FROM alerts_fired af
+        JOIN alert_configs ac  ON ac.id  = af.alert_config_id
+        JOIN contract_entries ce ON ce.id = af.contract_entry_id
+        WHERE ac.contract_id = ?
+        ORDER BY af.fired_at DESC
+        ${limit ? "LIMIT ?" : ""}
+    `;
+    return (limit
+        ? db.prepare(sql).all(contractId, limit)
+        : db.prepare(sql).all(contractId));
+}
+export function insertChannelAccount(db, account) {
+    db.prepare(`
+        INSERT INTO channel_accounts (public_key, label, network)
+        VALUES (@public_key, @label, @network)
+    `).run({
+        public_key: account.public_key,
+        label: account.label ?? null,
+        network: account.network,
+    });
+}
+export function upsertChannelAccount(db, account) {
+    db.prepare(`
+        INSERT INTO channel_accounts (public_key, keypair_source, network)
+        VALUES (@public_key, @keypair_source, @network)
+        ON CONFLICT(public_key) DO UPDATE SET
+            keypair_source = @keypair_source,
+            network = @network
+    `).run(account);
+}
+export function getChannelAccounts(db, network) {
+    return db.prepare("SELECT * FROM channel_accounts WHERE network = ? ORDER BY id ASC")
+        .all(network);
+}
+export function updateChannelBalance(db, publicKey, balanceXlm) {
+    db.prepare(`
+        UPDATE channel_accounts
+        SET balance_xlm = ?, balance_checked_at = datetime('now')
+        WHERE public_key = ?
+    `).run(balanceXlm, publicKey);
+}
+export function deleteChannelAccount(db, publicKey) {
+    db.prepare("DELETE FROM channel_accounts WHERE public_key = ?").run(publicKey);
+}
+export function markChannelFunded(db, publicKey) {
+    db.prepare("UPDATE channel_accounts SET funded = 1 WHERE public_key = ?").run(publicKey);
+}
+// ---------------------------- Database Access Functions For Schema: StateSnapshot ----------------------------
+export function insertStateSnapshot(db, snapshot) {
+    const result = db.prepare(`
+        INSERT INTO state_snapshots (contract_entry_id, snapshot_ledger, value_hash, value_xdr)
+        VALUES (@contract_entry_id, @snapshot_ledger, @value_hash, @value_xdr)
+    `).run(snapshot);
+    return result.lastInsertRowid;
+}
+export function getLatestSnapshot(db, contractEntryId) {
+    return db.prepare(`
+        SELECT * FROM state_snapshots
+        WHERE contract_entry_id = ?
+        ORDER BY snapshot_ledger DESC, id DESC
+        LIMIT 1
+    `).get(contractEntryId);
+}
+// ---------------------------- Database Access Functions For Schema: StateChange ----------------------------
+export function insertStateChange(db, change) {
+    const result = db.prepare(`
+        INSERT INTO state_changes (contract_entry_id, old_snapshot_id, new_snapshot_id, diff_type, diff_json, detected_at_ledger)
+        VALUES (@contract_entry_id, @old_snapshot_id, @new_snapshot_id, @diff_type, @diff_json, @detected_at_ledger)
+    `).run({
+        ...change,
+        old_snapshot_id: change.old_snapshot_id ?? null,
+        new_snapshot_id: change.new_snapshot_id ?? null,
+    });
+    return result.lastInsertRowid;
+}
+export function getStateChanges(db, contractEntryId, limit) {
+    let sql = "SELECT * FROM state_changes WHERE contract_entry_id = ? ORDER BY detected_at_ledger DESC, id DESC";
+    if (limit !== undefined) {
+        if (limit < 0) {
+            throw new Error("limit must be non-negative");
+        }
+        sql += " LIMIT ?";
+        return db.prepare(sql).all(contractEntryId, limit);
+    }
+    return db.prepare(sql).all(contractEntryId);
+}
+/**
+ * Return a rich history view of state changes for a contract,
+ * joining state_changes → contract_entries → state_snapshots.
+ */
+export function getStateChangeHistory(db, contractId, opts) {
+    const limit = opts?.limit;
+    const entryKeyXdr = opts?.entryKeyXdr;
+    let sql = `
+        SELECT
+            sc.id              AS changeId,
+            sc.contract_entry_id AS contractEntryId,
+            ce.entry_key_xdr   AS entryKeyXdr,
+            ce.entry_type      AS entryType,
+            ce.label           AS entryLabel,
+            sc.diff_type       AS diffType,
+            sc.diff_json       AS diffJson,
+            sc.detected_at_ledger AS detectedAtLedger,
+            sc.created_at      AS createdAt,
+            old_snap.value_xdr AS oldValueXdr,
+            new_snap.value_xdr AS newValueXdr
+        FROM state_changes sc
+        JOIN contract_entries ce ON ce.id = sc.contract_entry_id
+        LEFT JOIN state_snapshots old_snap ON old_snap.id = sc.old_snapshot_id
+        LEFT JOIN state_snapshots new_snap ON new_snap.id = sc.new_snapshot_id
+        WHERE ce.contract_id = ?
+    `;
+    const params = [contractId];
+    if (entryKeyXdr) {
+        sql += " AND ce.entry_key_xdr = ?";
+        params.push(entryKeyXdr);
+    }
+    sql += " ORDER BY sc.detected_at_ledger DESC, sc.id DESC";
+    if (limit !== undefined && limit >= 0) {
+        sql += " LIMIT ?";
+        params.push(limit);
+    }
+    return db.prepare(sql).all(...params);
+}
+export function insertResourceAlertConfig(db, config) {
+    db.prepare(`
+        INSERT INTO resource_alert_configs (contract_id, channel_type, channel_target, cpu_limit, mem_limit, webhook_secret)
+        VALUES (@contract_id, @channel_type, @channel_target, @cpu_limit, @mem_limit, @webhook_secret)
+    `).run({
+        contract_id: config.contract_id,
+        channel_type: config.channel_type,
+        channel_target: config.channel_target,
+        cpu_limit: config.cpu_limit,
+        mem_limit: config.mem_limit,
+        webhook_secret: config.webhook_secret ?? null,
+    });
+}
+export function getResourceAlertConfigsForContract(db, contractId) {
+    return db.prepare("SELECT * FROM resource_alert_configs WHERE contract_id = ?").all(contractId);
+}
+export function getResourceAlertConfigById(db, id) {
+    return db.prepare("SELECT * FROM resource_alert_configs WHERE id = ?").get(id);
+}
+export function deleteResourceAlertConfig(db, id) {
+    db.prepare("DELETE FROM resource_alert_configs WHERE id = ?").run(id);
+}
+export function recordResourceAlertFired(db, alert) {
+    const result = db.prepare(`
+      INSERT INTO resource_alerts_fired (resource_alert_config_id, resource_type, usage, "limit", usage_percent, fired_at_ledger)
+      VALUES (@resource_alert_config_id, @resource_type, @usage, @limit, @usage_percent, @fired_at_ledger)
+    `).run({
+        resource_alert_config_id: alert.resource_alert_config_id,
+        resource_type: alert.resource_type,
+        usage: alert.usage,
+        limit: alert.limit,
+        usage_percent: alert.usage_percent,
+        fired_at_ledger: alert.fired_at_ledger ?? null,
+    });
+    return result.lastInsertRowid;
+}
+export function getResourceUsageHistory(db, contractId, days) {
+    if (days) {
+        return db.prepare(`
+            SELECT raf.resource_type AS resourceType,
+                   raf.usage,
+                   raf.usage_percent AS usagePercent,
+                   raf.fired_at AS firedAt
+            FROM resource_alerts_fired raf
+            JOIN resource_alert_configs rac ON rac.id = raf.resource_alert_config_id
+            WHERE rac.contract_id = ?
+              AND raf.fired_at >= datetime('now', ?)
+            ORDER BY raf.fired_at DESC
+        `).all(contractId, `-${days} days`);
+    }
+    return db.prepare(`
+        SELECT raf.resource_type AS resourceType,
+               raf.usage,
+               raf.usage_percent AS usagePercent,
+               raf.fired_at AS firedAt
+        FROM resource_alerts_fired raf
+        JOIN resource_alert_configs rac ON rac.id = raf.resource_alert_config_id
+        WHERE rac.contract_id = ?
+        ORDER BY raf.fired_at DESC
+    `).all(contractId);
+}
+export function getUndeliveredResourceAlerts(db, network) {
+    return db.prepare(`
+        SELECT
+            raf.id               AS alertFiredId,
+            raf.resource_alert_config_id AS resourceAlertConfigId,
+            c.id                 AS contractId,
+            c.name               AS contractName,
+            c.network,
+            raf.resource_type    AS resourceType,
+            raf.usage,
+            raf."limit",
+            raf.usage_percent    AS usagePercent,
+            rac.channel_type     AS channelType,
+            rac.channel_target   AS channelTarget,
+            rac.webhook_secret   AS webhookSecret,
+            raf.retry_count      AS retryCount,
+            raf.fired_at_ledger  AS firedAtLedger
+        FROM resource_alerts_fired raf
+        JOIN resource_alert_configs rac ON rac.id = raf.resource_alert_config_id
+        JOIN contracts c ON c.id = rac.contract_id
+        WHERE c.network = ? AND raf.delivered = 0 AND raf.retry_count < ?
+        ORDER BY raf.fired_at DESC
+    `).all(network, MAX_RETRY_COUNT);
+}
+export function markResourceAlertDelivered(db, alertFiredId) {
+    db.prepare(`
+        UPDATE resource_alerts_fired SET delivered = 1, delivered_at = datetime('now') WHERE id = ?
+    `).run(alertFiredId);
+}
+export function incrementResourceAlertRetryCount(db, alertFiredId) {
+    db.prepare("UPDATE resource_alerts_fired SET retry_count = retry_count + 1 WHERE id = ?").run(alertFiredId);
+}
+export function hasUnresolvedResourceAlert(db, configId, resourceType, currentUsagePercent) {
+    if (typeof currentUsagePercent === "undefined") {
+        const result = db.prepare(`
+      SELECT 1 FROM resource_alerts_fired
+      WHERE resource_alert_config_id = ? AND resource_type = ? AND resolved = 0
+      LIMIT 1
+    `).get(configId, resourceType);
+        return !!result;
+    }
+    // If we have a current usage percent, only consider an existing unresolved
+    // alert to be blocking if its recorded usage_percent is greater than or
+    // equal to the current usage (i.e., no increase). If the current usage
+    // is higher, allow firing a new alert.
+    const row = db.prepare(`
+    SELECT usage_percent FROM resource_alerts_fired
+    WHERE resource_alert_config_id = ? AND resource_type = ? AND resolved = 0
+    ORDER BY fired_at DESC
+    LIMIT 1
+  `).get(configId, resourceType);
+    if (!row || typeof row.usage_percent === "undefined")
+        return false;
+    return row.usage_percent >= currentUsagePercent;
+}
+/**
+ * Insert a new resource-usage log entry.
+ *
+ * @returns The auto-assigned row id of the inserted entry.
+ */
+export function insertResourceUsageLog(db, log) {
+    const result = db.prepare(`
+        INSERT INTO resource_usage_logs (
+            contract_id,
+            cpu_insns,
+            mem_bytes,
+            fee_instructions,
+            fee_read_ledger_entries,
+            fee_write_ledger_entries,
+            fee_read_bytes,
+            fee_write_bytes,
+            fee_transaction_size,
+            fee_historical_ledger,
+            fee_rent_ledger,
+            fee_refundable,
+            recorded_at
+        ) VALUES (
+            @contract_id,
+            @cpu_insns,
+            @mem_bytes,
+            @fee_instructions,
+            @fee_read_ledger_entries,
+            @fee_write_ledger_entries,
+            @fee_read_bytes,
+            @fee_write_bytes,
+            @fee_transaction_size,
+            @fee_historical_ledger,
+            @fee_rent_ledger,
+            @fee_refundable,
+            COALESCE(@recorded_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        )
+    `).run({
+        contract_id: log.contract_id,
+        cpu_insns: log.cpu_insns,
+        mem_bytes: log.mem_bytes,
+        fee_instructions: log.fee_instructions ?? null,
+        fee_read_ledger_entries: log.fee_read_ledger_entries ?? null,
+        fee_write_ledger_entries: log.fee_write_ledger_entries ?? null,
+        fee_read_bytes: log.fee_read_bytes ?? null,
+        fee_write_bytes: log.fee_write_bytes ?? null,
+        fee_transaction_size: log.fee_transaction_size ?? null,
+        fee_historical_ledger: log.fee_historical_ledger ?? null,
+        fee_rent_ledger: log.fee_rent_ledger ?? null,
+        fee_refundable: log.fee_refundable ?? null,
+        recorded_at: log.recorded_at ?? null,
+    });
+    return result.lastInsertRowid;
+}
+/**
+ * Return resource-usage logs for a contract, newest first.
+ *
+ * @param options.limit   Maximum number of rows to return (must be ≥ 0).
+ * @param options.since   ISO-8601 lower-bound for recorded_at (inclusive).
+ */
+export function getResourceUsageLogs(db, contractId, options = {}) {
+    const { limit, since } = options;
+    if (limit !== undefined && limit < 0) {
+        throw new Error("limit must be non-negative");
+    }
+    const conditions = ["contract_id = @contractId"];
+    if (since !== undefined) {
+        conditions.push("recorded_at >= @since");
+    }
+    const where = conditions.join(" AND ");
+    const params = { contractId, since: since ?? null };
+    let query = `
+        SELECT *
+        FROM resource_usage_logs
+        WHERE ${where}
+        ORDER BY recorded_at DESC, id DESC
+    `;
+    if (limit !== undefined) {
+        query += ` LIMIT @limit`;
+        params.limit = limit;
+    }
+    return db.prepare(query).all(params);
+}
+/**
+ * Return the single most-recent resource-usage log for a contract,
+ * or `undefined` if none exist.
+ */
+export function getLatestResourceUsageLog(db, contractId) {
+    return db.prepare(`
+        SELECT *
+        FROM resource_usage_logs
+        WHERE contract_id = ?
+        ORDER BY recorded_at DESC, id DESC
+        LIMIT 1
+    `).get(contractId);
+}
+//# sourceMappingURL=repositories.js.map