@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/core/activity/sqliteActivityStoreRows.js

@@ -0,0 +1,430 @@
+import { actionPlanSchema } from "../action/schemas.js";
+import { assertNoForbiddenMcpFields } from "../action/forbiddenFields.js";
+import { ActivityStoreReadError, EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT, REVIEW_ACTIVITY_LIST_DEFAULT_LIMIT, REVIEW_ACTIVITY_LIST_MAX_LIMIT, REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD } from "./activityStore.js";
+import { EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES, externalActivityTransactionDetailJsonByteLength, externalActivityTransactionDetailSchema, externalActivityTransactionDetailsReferenceOnlyAccount } from "./transactionActivityDetails.js";
+import { ActivityStoreError } from "./sqliteActivityStoreTypes.js";
+export const INTERNAL_SESSION_STATUSES = [
+    "proposed",
+    "awaiting_wallet",
+    "wallet_connected",
+    "ready_for_wallet_review",
+    "refresh_required",
+    "blocked",
+    "signed_pending_result",
+    "success",
+    "failure",
+    "expired"
+];
+export const REVIEW_STATE_STATUSES = [
+    "ready_for_wallet_review",
+    "blocked",
+    "refresh_required"
+];
+export const REVIEW_TRANSITION_EVENTS = [
+    "created",
+    "opened",
+    "wallet_connected",
+    "state_computed",
+    "result_recorded",
+    "expired"
+];
+export const EXTERNAL_ACTIVITY_RELATIONSHIPS = ["affected", "sent"];
+export const EXTERNAL_ACTIVITY_STATUSES = ["success", "failure", "unknown"];
+const EXTERNAL_ACTIVITY_INCOMPLETE_REASONS = [
+    "limit_reached",
+    "ordering_unverified",
+    "cursor_invalid",
+    "provider_error"
+];
+export function parseIsoTimestamp(value, field) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value) {
+        throw new ActivityStoreReadError("input_invalid", `${field} must be an ISO 8601 UTC timestamp`, {
+            field
+        });
+    }
+    return value;
+}
+export function parseOptionalIsoTimestamp(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return parseIsoTimestamp(value, field);
+}
+export function assertDateRange(from, to) {
+    if (from && to && from > to) {
+        throw new ActivityStoreReadError("input_invalid", "from must be before or equal to to", {
+            from,
+            to
+        });
+    }
+}
+export function normalizeListLimit(limit) {
+    if (limit === undefined) {
+        return REVIEW_ACTIVITY_LIST_DEFAULT_LIMIT;
+    }
+    if (!Number.isInteger(limit) || limit < 1 || limit > REVIEW_ACTIVITY_LIST_MAX_LIMIT) {
+        throw new ActivityStoreReadError("input_invalid", "limit must be an integer from 1 to 100", {
+            limit,
+            min: 1,
+            max: REVIEW_ACTIVITY_LIST_MAX_LIMIT
+        });
+    }
+    return limit;
+}
+export function normalizeExternalActivityLimit(limit) {
+    if (limit === undefined) {
+        return EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT;
+    }
+    if (!Number.isInteger(limit) || limit < 1 || limit > EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT) {
+        throw new ActivityStoreReadError("input_invalid", "limit must be an integer from 1 to 100", {
+            limit,
+            min: 1,
+            max: EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT
+        });
+    }
+    return limit;
+}
+export function reviewSessionWhere(accountId, from, to, status) {
+    const conditions = ["rs.account_id = ?"];
+    const params = [accountId];
+    if (from) {
+        conditions.push("rs.created_at >= ?");
+        params.push(from);
+    }
+    if (to) {
+        conditions.push("rs.created_at <= ?");
+        params.push(to);
+    }
+    if (status) {
+        conditions.push("rs.current_status = ?");
+        params.push(status);
+    }
+    return {
+        whereSql: `WHERE ${conditions.join(" AND ")}`,
+        params
+    };
+}
+export function reviewActivityRowFromStorage(row) {
+    return {
+        reviewSessionId: asString(row.review_session_id),
+        planId: asString(row.plan_id),
+        actionKind: asString(row.action_kind),
+        adapterId: asString(row.adapter_id),
+        protocol: asString(row.protocol),
+        currentStatus: asInternalSessionStatus(row.current_status),
+        account: asString(row.account),
+        createdAt: asString(row.created_at),
+        updatedAt: asString(row.updated_at),
+        executionStatus: row.execution_status === null ? undefined : asString(row.execution_status),
+        txDigest: row.tx_digest === null ? undefined : asString(row.tx_digest),
+        snapshotCount: row.snapshot_count,
+        transitionCount: row.transition_count
+    };
+}
+export function reviewActivityListResult(scope, from, to, activities, truncated, recordCount) {
+    return {
+        dataScope: dataScope(scope.account, from, to, recordCount),
+        accountSource: scope.accountSource,
+        lowSampleWarning: recordCount < REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD,
+        lowSampleThreshold: REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD,
+        truncated: {
+            activities: truncated,
+            snapshots: false,
+            transitions: false
+        },
+        activities
+    };
+}
+export function reviewFunnelResult(scope, from, to, summary, recordCount) {
+    return {
+        dataScope: dataScope(scope.account, from, to, recordCount),
+        accountSource: scope.accountSource,
+        lowSampleWarning: recordCount < REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD,
+        lowSampleThreshold: REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD,
+        truncated: {
+            activities: false,
+            snapshots: false,
+            transitions: false
+        },
+        summary
+    };
+}
+function dataScope(account, from, to, recordCount) {
+    const scope = {
+        account,
+        recordCount
+    };
+    if (from !== undefined) {
+        scope.from = from;
+    }
+    if (to !== undefined) {
+        scope.to = to;
+    }
+    return scope;
+}
+export function externalActivityScanFromRow(row) {
+    return {
+        scanId: asString(row.scan_id),
+        kind: asExternalActivityScanKind(row.kind),
+        accountId: row.account_id,
+        account: asString(row.account),
+        relationship: asExternalActivityRelationship(row.relationship),
+        inputDigest: row.input_digest === null ? undefined : asString(row.input_digest),
+        fromCheckpoint: row.from_checkpoint === null ? undefined : asString(row.from_checkpoint),
+        toCheckpoint: row.to_checkpoint === null ? undefined : asString(row.to_checkpoint),
+        fromTimestamp: row.from_timestamp === null ? undefined : asString(row.from_timestamp),
+        toTimestamp: row.to_timestamp === null ? undefined : asString(row.to_timestamp),
+        limit: row.limit_count,
+        requestCursor: row.request_cursor === null ? undefined : asString(row.request_cursor),
+        responseCursor: row.response_cursor === null ? undefined : asString(row.response_cursor),
+        endpointHost: asString(row.endpoint_host),
+        chainIdentifier: asString(row.chain_identifier),
+        fetchedAt: asString(row.fetched_at),
+        storedCount: row.stored_count,
+        skippedCount: row.skipped_count,
+        hasMore: row.has_more === 1,
+        windowComplete: row.window_complete === null ? null : row.window_complete === 1,
+        incompleteReason: row.incomplete_reason === null
+            ? undefined
+            : asExternalActivityIncompleteReason(row.incomplete_reason)
+    };
+}
+export function externalActivityTransactionFromRow(row) {
+    return {
+        accountId: row.account_id,
+        account: asString(row.account),
+        digest: asString(row.digest),
+        relationship: asExternalActivityRelationship(row.relationship),
+        checkpoint: row.checkpoint === null ? undefined : asString(row.checkpoint),
+        timestamp: row.timestamp === null ? undefined : asString(row.timestamp),
+        status: asExternalActivityStatus(row.status),
+        knownSenderAccountId: row.known_sender_account_id === null ? undefined : row.known_sender_account_id,
+        firstScanId: asString(row.first_scan_id),
+        lastScanId: asString(row.last_scan_id),
+        firstFetchedAt: asString(row.first_fetched_at),
+        lastFetchedAt: asString(row.last_fetched_at),
+        lastScanIncompleteReason: row.last_scan_incomplete_reason === null
+            ? undefined
+            : asExternalActivityIncompleteReason(row.last_scan_incomplete_reason),
+        details: row.detail_json === null
+            ? undefined
+            : parseEvidenceJson(row.detail_json, asString(row.digest), "external_activity_detail", externalActivityTransactionDetailSchema)
+    };
+}
+export function externalActivitySummaryResult(scope, from, to, transactions, truncated, stats) {
+    const summary = {
+        transactionCount: stats.transactionCount,
+        statusCounts: stats.statusCounts,
+        relationshipCounts: stats.relationshipCounts
+    };
+    if (stats.earliestTimestamp !== undefined) {
+        summary.earliestTimestamp = stats.earliestTimestamp;
+    }
+    if (stats.latestTimestamp !== undefined) {
+        summary.latestTimestamp = stats.latestTimestamp;
+    }
+    return {
+        dataScope: dataScope(scope.account, from, to, stats.transactionCount),
+        accountSource: scope.accountSource,
+        lowSampleWarning: stats.transactionCount < REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD,
+        lowSampleThreshold: REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD,
+        truncated,
+        summary,
+        transactions
+    };
+}
+export function emptyExternalActivitySummaryStats() {
+    return {
+        transactionCount: 0,
+        statusCounts: Object.fromEntries(EXTERNAL_ACTIVITY_STATUSES.map((status) => [status, 0])),
+        relationshipCounts: Object.fromEntries(EXTERNAL_ACTIVITY_RELATIONSHIPS.map((relationship) => [relationship, 0]))
+    };
+}
+export function emptyReviewFunnelSummary() {
+    return {
+        total: 0,
+        opened: 0,
+        walletConnected: 0,
+        stateComputed: 0,
+        currentStatusCounts: countMap(INTERNAL_SESSION_STATUSES, []),
+        everReachedReviewStateCounts: countMap(REVIEW_STATE_STATUSES, []),
+        signedPending: 0,
+        success: 0,
+        failure: 0,
+        expiredBeforeResult: 0,
+        avgCreatedToSignedSeconds: null,
+        avgOpenedToSignedSeconds: null
+    };
+}
+export function countMap(keys, rows) {
+    const result = Object.fromEntries(keys.map((key) => [key, 0]));
+    for (const row of rows) {
+        if (keys.includes(row.key)) {
+            result[row.key] = row.count;
+        }
+    }
+    return result;
+}
+export function nullableSeconds(value) {
+    return value === null ? null : Math.round(value * 1000) / 1000;
+}
+export function parseEvidenceJson(value, reviewSessionId, evidenceField, schema) {
+    if (value === null) {
+        throw new ActivityStoreReadError("internal_error", "Malformed activity JSON evidence", {
+            reviewSessionId,
+            evidenceField
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new ActivityStoreReadError("internal_error", "Malformed activity JSON evidence", {
+            reviewSessionId,
+            evidenceField
+        });
+    }
+    if (schema !== undefined) {
+        const result = schema.safeParse(parsed);
+        if (!result.success) {
+            throw new ActivityStoreReadError("internal_error", "Malformed activity JSON evidence", {
+                reviewSessionId,
+                evidenceField
+            });
+        }
+        return result.data;
+    }
+    return parsed;
+}
+export function serializeJson(value) {
+    assertNoForbiddenMcpFields(value);
+    return JSON.stringify(value);
+}
+export function serializeExternalActivityTransactionDetail(details, account) {
+    const parsed = externalActivityTransactionDetailSchema.safeParse(details);
+    if (!parsed.success || !externalActivityTransactionDetailsReferenceOnlyAccount(parsed.data, account)) {
+        throw new ActivityStoreReadError("input_invalid", "Invalid external activity transaction detail", {
+            reason: "invalid_external_activity_detail_json"
+        });
+    }
+    const json = serializeJson(parsed.data);
+    if (externalActivityTransactionDetailJsonByteLength(json) > EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES) {
+        throw new ActivityStoreReadError("input_invalid", "External activity transaction detail JSON is too large", {
+            reason: "external_activity_detail_too_large",
+            maxBytes: EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES
+        });
+    }
+    return json;
+}
+export function serializeOptionalJson(value) {
+    if (value === undefined) {
+        return null;
+    }
+    return serializeJson(value);
+}
+export function parseActionPlanEvidence(plan) {
+    const parsed = actionPlanSchema.safeParse(plan);
+    if (!parsed.success) {
+        throw new ActivityStoreError("Invalid review session action plan evidence");
+    }
+    return parsed.data;
+}
+export function extractRequestedIntent(plan) {
+    // Adapter convention: full plan_json stays canonical, while requestedIntent
+    // is materialized only to make activity queries avoid nested JSON paths.
+    return plan.adapterData.requestedIntent;
+}
+export function reasonForReviewState(state) {
+    if ("blockedReason" in state) {
+        return state.blockedReason;
+    }
+    if ("refreshReason" in state) {
+        return state.refreshReason;
+    }
+    return undefined;
+}
+export function asString(value) {
+    if (typeof value !== "string") {
+        throw new ActivityStoreError("Unexpected SQLite value type");
+    }
+    return value;
+}
+export function coinMetadataCacheRecordFromRow(row) {
+    return {
+        coinType: asString(row.coin_type),
+        chainIdentifier: asString(row.chain_identifier),
+        decimals: row.decimals,
+        symbol: asString(row.symbol),
+        name: asString(row.name),
+        fetchedAt: asString(row.fetched_at),
+        expiresAt: asString(row.expires_at)
+    };
+}
+export function asInternalSessionStatus(value) {
+    if (typeof value === "string" && INTERNAL_SESSION_STATUSES.includes(value)) {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected review status");
+}
+export function asReviewTransitionEvent(value) {
+    if (typeof value === "string" && REVIEW_TRANSITION_EVENTS.includes(value)) {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected review transition event");
+}
+export function asAccountSource(value) {
+    if (value === "wallet_identity" || value === "review_execution") {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected account source");
+}
+function asExternalActivityScanKind(value) {
+    if (value === "digest_lookup" || value === "account_scan" || value === "function_scan") {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected external activity scan kind");
+}
+function asExternalActivityRelationship(value) {
+    if (typeof value === "string" && EXTERNAL_ACTIVITY_RELATIONSHIPS.includes(value)) {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected external activity relationship");
+}
+function asExternalActivityStatus(value) {
+    if (typeof value === "string" && EXTERNAL_ACTIVITY_STATUSES.includes(value)) {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected external activity status");
+}
+function asExternalActivityIncompleteReason(value) {
+    if (typeof value === "string" && EXTERNAL_ACTIVITY_INCOMPLETE_REASONS.includes(value)) {
+        return value;
+    }
+    throw new ActivityStoreError("Unexpected external activity incomplete reason");
+}
+export function isSameReviewExecution(existing, accountId, input) {
+    return (existing.plan_id === input.planId &&
+        existing.account_id === accountId &&
+        existing.status === input.status &&
+        nullableString(existing.tx_digest) === nullableString(input.txDigest) &&
+        nullableString(existing.explorer_url) === nullableString(input.explorerUrl) &&
+        nullableString(existing.failure_reason) === nullableString(input.failureReason));
+}
+export function canAdvanceReviewExecution(existing, accountId, input) {
+    if (existing.plan_id !== input.planId || existing.account_id !== accountId) {
+        return false;
+    }
+    if (existing.status !== "signed_pending_result") {
+        return false;
+    }
+    if (input.status === "signed_pending_result") {
+        return false;
+    }
+    const nextDigest = nullableString(input.txDigest);
+    return existing.tx_digest === null || existing.tx_digest === nextDigest;
+}
+function nullableString(value) {
+    return value ?? null;
+}

package/dist/core/activity/sqliteActivityStoreSchema.js

@@ -0,0 +1,258 @@
+import { EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT } from "./activityStore.js";
+import { DB_USER_VERSION } from "./schemaVersion.js";
+import { ActivityStoreError } from "./sqliteActivityStoreTypes.js";
+const EXTERNAL_ACTIVITY_SCAN_INDEX_SQL = `CREATE INDEX IF NOT EXISTS idx_external_activity_scans_account_fetched
+  ON external_activity_scans(account_id, fetched_at)`;
+export function configureDatabase(db) {
+    db.exec("PRAGMA journal_mode=WAL");
+    db.exec("PRAGMA synchronous=NORMAL");
+    db.exec("PRAGMA foreign_keys=ON");
+}
+export function initializeDatabase(db) {
+    const currentUserVersion = db.pragma("user_version", { simple: true });
+    if (currentUserVersion > DB_USER_VERSION) {
+        throw new ActivityStoreError(`Local activity database version ${currentUserVersion} is newer than this runtime supports (${DB_USER_VERSION}).`);
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS accounts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sui_address TEXT NOT NULL UNIQUE,
+      first_seen_at TEXT NOT NULL,
+      last_used_at TEXT NOT NULL,
+      first_source TEXT NOT NULL CHECK (first_source IN ('wallet_identity', 'review_execution')),
+      last_source TEXT NOT NULL CHECK (last_source IN ('wallet_identity', 'review_execution'))
+    );
+
+    CREATE TABLE IF NOT EXISTS active_account_context (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      account_id INTEGER REFERENCES accounts(id) ON DELETE SET NULL,
+      source TEXT NOT NULL CHECK (source IN ('wallet_identity', 'cleared')),
+      set_at TEXT NOT NULL,
+      wallet_name TEXT,
+      wallet_id TEXT,
+      CHECK (
+        (source = 'cleared' AND account_id IS NULL)
+        OR (source = 'wallet_identity' AND account_id IS NOT NULL)
+      )
+    );
+
+    CREATE TABLE IF NOT EXISTS review_sessions (
+      id TEXT PRIMARY KEY,
+      plan_id TEXT NOT NULL,
+      action_kind TEXT NOT NULL,
+      adapter_id TEXT NOT NULL,
+      protocol TEXT NOT NULL,
+      account_id INTEGER REFERENCES accounts(id) ON DELETE SET NULL,
+      current_status TEXT NOT NULL,
+      plan_json TEXT NOT NULL,
+      intent_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_review_sessions_account_created
+      ON review_sessions(account_id, created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_review_sessions_status_account
+      ON review_sessions(current_status, account_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS review_state_snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      review_session_id TEXT NOT NULL REFERENCES review_sessions(id) ON DELETE RESTRICT,
+      plan_id TEXT NOT NULL,
+      account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+      status TEXT NOT NULL CHECK (status IN ('ready_for_wallet_review', 'refresh_required', 'blocked')),
+      blocked_reason TEXT,
+      refresh_reason TEXT,
+      state_json TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      recorded_at TEXT NOT NULL,
+      CHECK (
+        (status = 'blocked' AND blocked_reason IS NOT NULL AND refresh_reason IS NULL)
+        OR (status = 'refresh_required' AND refresh_reason IS NOT NULL AND blocked_reason IS NULL)
+        OR (status = 'ready_for_wallet_review' AND blocked_reason IS NULL AND refresh_reason IS NULL)
+      )
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_review_state_snapshots_session_recorded
+      ON review_state_snapshots(review_session_id, recorded_at);
+
+    CREATE TABLE IF NOT EXISTS review_status_transitions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      review_session_id TEXT NOT NULL REFERENCES review_sessions(id) ON DELETE RESTRICT,
+      event TEXT NOT NULL CHECK (
+        event IN ('created', 'opened', 'wallet_connected', 'state_computed', 'result_recorded', 'expired')
+      ),
+      from_status TEXT,
+      to_status TEXT NOT NULL,
+      account_id INTEGER REFERENCES accounts(id) ON DELETE SET NULL,
+      reason TEXT,
+      transitioned_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_review_transitions_session_time
+      ON review_status_transitions(review_session_id, transitioned_at);
+
+    CREATE TABLE IF NOT EXISTS review_executions (
+      review_session_id TEXT PRIMARY KEY REFERENCES review_sessions(id) ON DELETE RESTRICT,
+      plan_id TEXT NOT NULL,
+      account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+      status TEXT NOT NULL CHECK (status IN ('signed_pending_result', 'success', 'failure')),
+      tx_digest TEXT,
+      explorer_url TEXT,
+      failure_reason TEXT,
+      result_json TEXT NOT NULL,
+      recorded_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      CHECK (
+        (status = 'failure' AND failure_reason IS NOT NULL)
+        OR (status != 'failure' AND failure_reason IS NULL)
+      )
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_review_executions_account_updated
+      ON review_executions(account_id, updated_at);
+
+    CREATE INDEX IF NOT EXISTS idx_review_executions_digest
+      ON review_executions(tx_digest);
+
+    ${externalActivityScansTableSql("external_activity_scans", { ifNotExists: true })};
+
+    ${EXTERNAL_ACTIVITY_SCAN_INDEX_SQL};
+
+    CREATE TABLE IF NOT EXISTS external_activity_transactions (
+      account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+      digest TEXT NOT NULL,
+      relationship TEXT NOT NULL CHECK (relationship IN ('affected', 'sent')),
+      checkpoint TEXT,
+      timestamp TEXT,
+      status TEXT NOT NULL CHECK (status IN ('success', 'failure', 'unknown')),
+      known_sender_account_id INTEGER REFERENCES accounts(id) ON DELETE SET NULL,
+      first_scan_id TEXT NOT NULL REFERENCES external_activity_scans(scan_id) ON DELETE RESTRICT,
+      last_scan_id TEXT NOT NULL REFERENCES external_activity_scans(scan_id) ON DELETE RESTRICT,
+      first_fetched_at TEXT NOT NULL,
+      last_fetched_at TEXT NOT NULL,
+      detail_json TEXT,
+      PRIMARY KEY (account_id, digest, relationship)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_external_activity_transactions_account_time
+      ON external_activity_transactions(account_id, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_external_activity_transactions_digest
+      ON external_activity_transactions(digest);
+
+    CREATE TABLE IF NOT EXISTS local_settings (
+      key TEXT PRIMARY KEY,
+      value_json TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS coin_metadata_cache (
+      coin_type TEXT NOT NULL,
+      chain_identifier TEXT NOT NULL,
+      decimals INTEGER NOT NULL CHECK (decimals >= 0 AND decimals <= 255),
+      symbol TEXT NOT NULL,
+      name TEXT NOT NULL,
+      fetched_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      PRIMARY KEY (coin_type, chain_identifier)
+    );
+
+  `);
+    migrateDatabase(db, currentUserVersion);
+    if (db.pragma("user_version", { simple: true }) !== DB_USER_VERSION) {
+        db.pragma(`user_version = ${DB_USER_VERSION}`);
+    }
+}
+function migrateDatabase(db, currentUserVersion) {
+    if (currentUserVersion < 3 && !tableHasColumn(db, "external_activity_transactions", "detail_json")) {
+        db.exec("ALTER TABLE external_activity_transactions ADD COLUMN detail_json TEXT");
+    }
+    if (currentUserVersion > 0 && currentUserVersion < 4 && tableExists(db, "external_activity_scans")) {
+        rebuildExternalActivityScansForFunctionScan(db);
+    }
+    if (currentUserVersion > 0 && currentUserVersion < 5 && tableExists(db, "active_account_context")) {
+        if (!tableHasColumn(db, "active_account_context", "wallet_name")) {
+            db.exec("ALTER TABLE active_account_context ADD COLUMN wallet_name TEXT");
+        }
+        if (!tableHasColumn(db, "active_account_context", "wallet_id")) {
+            db.exec("ALTER TABLE active_account_context ADD COLUMN wallet_id TEXT");
+        }
+    }
+}
+function tableHasColumn(db, table, column) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return rows.some((row) => row.name === column);
+}
+function tableExists(db, table) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .get(table);
+    return row !== undefined;
+}
+function rebuildExternalActivityScansForFunctionScan(db) {
+    const previousForeignKeys = db.pragma("foreign_keys", { simple: true });
+    const rebuild = db.transaction(() => {
+        db.exec(`
+      DROP TABLE IF EXISTS external_activity_scans_new;
+
+      ${externalActivityScansTableSql("external_activity_scans_new", { ifNotExists: false })};
+
+      INSERT INTO external_activity_scans_new
+        (scan_id, kind, account_id, relationship, input_digest, from_checkpoint, to_checkpoint,
+         from_timestamp, to_timestamp, limit_count, request_cursor, response_cursor, endpoint_host,
+         chain_identifier, fetched_at, stored_count, skipped_count, has_more, window_complete,
+         incomplete_reason)
+      SELECT
+        scan_id, kind, account_id, relationship, input_digest, from_checkpoint, to_checkpoint,
+        from_timestamp, to_timestamp, limit_count, request_cursor, response_cursor, endpoint_host,
+        chain_identifier, fetched_at, stored_count, skipped_count, has_more, window_complete,
+        incomplete_reason
+      FROM external_activity_scans;
+
+      DROP TABLE external_activity_scans;
+      ALTER TABLE external_activity_scans_new RENAME TO external_activity_scans;
+      ${EXTERNAL_ACTIVITY_SCAN_INDEX_SQL};
+    `);
+        const foreignKeyFailures = db.prepare("PRAGMA foreign_key_check").all();
+        if (foreignKeyFailures.length > 0) {
+            throw new ActivityStoreError("Local activity database migration failed foreign key check");
+        }
+        db.pragma(`user_version = ${DB_USER_VERSION}`);
+    });
+    db.pragma("foreign_keys = OFF");
+    try {
+        rebuild();
+    }
+    finally {
+        db.pragma(`foreign_keys = ${previousForeignKeys === 0 ? "OFF" : "ON"}`);
+    }
+}
+function externalActivityScansTableSql(tableName, options) {
+    return `CREATE TABLE ${options.ifNotExists ? "IF NOT EXISTS " : ""}${tableName} (
+    scan_id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL CHECK (kind IN ('digest_lookup', 'account_scan', 'function_scan')),
+    account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+    relationship TEXT NOT NULL CHECK (relationship IN ('affected', 'sent')),
+    input_digest TEXT,
+    from_checkpoint TEXT,
+    to_checkpoint TEXT,
+    from_timestamp TEXT,
+    to_timestamp TEXT,
+    limit_count INTEGER NOT NULL CHECK (limit_count >= 1 AND limit_count <= ${EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT}),
+    request_cursor TEXT,
+    response_cursor TEXT,
+    endpoint_host TEXT NOT NULL,
+    chain_identifier TEXT NOT NULL,
+    fetched_at TEXT NOT NULL,
+    stored_count INTEGER NOT NULL CHECK (stored_count >= 0),
+    skipped_count INTEGER NOT NULL CHECK (skipped_count >= 0),
+    has_more INTEGER NOT NULL CHECK (has_more IN (0, 1)),
+    window_complete INTEGER CHECK (window_complete IN (0, 1)),
+    incomplete_reason TEXT CHECK (
+      incomplete_reason IS NULL
+      OR incomplete_reason IN ('limit_reached', 'ordering_unverified', 'cursor_invalid', 'provider_error')
+    )
+  )`;
+}

package/dist/core/activity/sqliteActivityStoreTypes.js

@@ -0,0 +1,5 @@
+export class ActivityStoreError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}