@secondlayer/shared 11.7.1 → 11.8.1

package/dist/src/index.js

@@ -13,6 +13,70 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+// src/event-types.ts
+import {
+  DECODED_EVENT_TYPES
+} from "@secondlayer/stacks/filters";
+import {
+  DECODED_EVENT_TYPES as DECODED_EVENT_TYPES2,
+  VM_EVENT_TYPES,
+  VM_NODE_TO_STORED_TYPE
+} from "@secondlayer/stacks/filters";
+var VM_STORED_TO_NODE_TYPE = {
+  nested_contract_call: "contract_call_event",
+  var_set: "var_set_event",
+  map_set: "map_set_event",
+  map_insert: "map_insert_event",
+  map_delete: "map_delete_event"
+};
+var STREAMS_EVENT_TYPES = DECODED_EVENT_TYPES;
+// src/db-event-types.ts
+var STREAMS_DB_EVENT_TYPES = [
+  "stx_transfer_event",
+  "stx_mint_event",
+  "stx_burn_event",
+  "stx_lock_event",
+  "ft_transfer_event",
+  "ft_mint_event",
+  "ft_burn_event",
+  "nft_transfer_event",
+  "nft_mint_event",
+  "nft_burn_event",
+  "smart_contract_event",
+  "contract_event"
+];
+var DB_TO_STREAMS_EVENT_TYPE = {
+  stx_transfer_event: "stx_transfer",
+  stx_mint_event: "stx_mint",
+  stx_burn_event: "stx_burn",
+  stx_lock_event: "stx_lock",
+  ft_transfer_event: "ft_transfer",
+  ft_mint_event: "ft_mint",
+  ft_burn_event: "ft_burn",
+  nft_transfer_event: "nft_transfer",
+  nft_mint_event: "nft_mint",
+  nft_burn_event: "nft_burn",
+  smart_contract_event: "print",
+  contract_event: "print"
+};
+var STREAMS_TO_DB_EVENT_TYPES = {
+  stx_transfer: ["stx_transfer_event"],
+  stx_mint: ["stx_mint_event"],
+  stx_burn: ["stx_burn_event"],
+  stx_lock: ["stx_lock_event"],
+  ft_transfer: ["ft_transfer_event"],
+  ft_mint: ["ft_mint_event"],
+  ft_burn: ["ft_burn_event"],
+  nft_transfer: ["nft_transfer_event"],
+  nft_mint: ["nft_mint_event"],
+  nft_burn: ["nft_burn_event"],
+  print: ["smart_contract_event", "contract_event"]
+};
+// src/db/index.ts
+import { Kysely } from "kysely";
+import { PostgresJSDialect } from "kysely-postgres-js";
+import postgres from "postgres";
+
 // src/env.ts
 import { z } from "zod";
 var networksSchema = z.string().transform((val) => {
@@ -178,27 +242,7 @@ function isOssMode() {
   return getInstanceMode() === "oss";
 }
 
-// src/db/jsonb.ts
-import { sql } from "kysely";
-function jsonb(value) {
-  const escaped = JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''");
-  return sql`${sql.raw(`'${escaped}'::jsonb`)}`;
-}
-function parseJsonb(value) {
-  if (typeof value === "string") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return 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
@@ -715,6 +759,22 @@ var SOURCE_READ_PKS = {
   events: ["tx_id", "event_index"],
   chain_reorgs: null
 };
+// src/db/jsonb.ts
+import { sql } from "kysely";
+function jsonb(value) {
+  const escaped = JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''");
+  return sql`${sql.raw(`'${escaped}'::jsonb`)}`;
+}
+function parseJsonb(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value ?? {};
+}
 // src/db/migration-role.ts
 var currentRole = "both";
 function setMigrationRole(role) {
@@ -787,6 +847,7 @@ var TABLE_TO_DB = {
   subgraph_processing_stats: "target",
   account_credits: "target",
   archive_fetches: "target",
+  usage_ledger: "target",
   waitlists: "target",
   waitlist_signups: "target",
   service_heartbeats: "both"
@@ -1098,12 +1159,58 @@ var CODE_TO_STATUS = {
 function getErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
-
+// src/finality.ts
+var DEFAULT_BTC_CONFIRMATIONS = 6;
+function finalizedBurnHeight(burnTipHeight, confirmations = DEFAULT_BTC_CONFIRMATIONS) {
+  if (!Number.isInteger(burnTipHeight) || burnTipHeight < 0) {
+    throw new Error("burnTipHeight must be a non-negative integer");
+  }
+  if (!Number.isInteger(confirmations) || confirmations < 0) {
+    throw new Error("confirmations must be a non-negative integer");
+  }
+  return Math.max(0, burnTipHeight - confirmations);
+}
+// src/streams-cursor.ts
+var EMPTY_RANGE_EVENT_INDEX_SENTINEL = 2147483647;
+function encodeStreamsCursor(cursor) {
+  return `${cursor.block_height}:${cursor.event_index}`;
+}
+function decodeStreamsCursor(cursor) {
+  const match = /^(0|[1-9]\d*):(0|[1-9]\d*)$/.exec(cursor);
+  if (!match) {
+    throw new Error("Invalid Streams cursor");
+  }
+  const decoded = {
+    block_height: Number(match[1]),
+    event_index: Number(match[2])
+  };
+  if (!Number.isSafeInteger(decoded.block_height) || !Number.isSafeInteger(decoded.event_index)) {
+    throw new Error("Invalid Streams cursor");
+  }
+  return decoded;
+}
+function compareStreamsCursor(a, b) {
+  if (a.block_height !== b.block_height) {
+    return a.block_height < b.block_height ? -1 : 1;
+  }
+  if (a.event_index !== b.event_index) {
+    return a.event_index < b.event_index ? -1 : 1;
+  }
+  return 0;
+}
+function isEmptyRangeCursor(cursor) {
+  return cursor.event_index === EMPTY_RANGE_EVENT_INDEX_SENTINEL;
+}
+function blockEndCursor(height) {
+  return {
+    block_height: height,
+    event_index: EMPTY_RANGE_EVENT_INDEX_SENTINEL
+  };
+}
 // src/schemas/subgraphs.ts
 import { z as z2 } from "zod";
 var DeploySubgraphRequestSchema = z2.object({
   name: z2.string().regex(/^[a-z0-9-]+$/, "lowercase alphanumeric + hyphens only").max(63),
-  version: z2.string().optional(),
   description: z2.string().optional(),
   sources: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).refine((s) => Object.keys(s).length > 0, "Must have at least one source"),
   schema: z2.record(z2.string(), z2.unknown()),
@@ -1112,7 +1219,6 @@ var DeploySubgraphRequestSchema = z2.object({
   sourceCode: z2.string().max(1048576, "source code exceeds 1MB limit").optional(),
   dryRun: z2.boolean().optional()
 });
-
 // src/schemas/webhooks.ts
 import { z as z3 } from "zod";
 var WEBHOOK_FORMATS = [
@@ -1130,6 +1236,47 @@ var WEBHOOK_RUNTIMES = [
   "node"
 ];
 var WEBHOOK_STATUSES = ["active", "paused", "error"];
+var WEBHOOK_MAX_RETRIES_CEILING_DEFAULT = 100;
+var WEBHOOK_TIMEOUT_MS_CEILING_DEFAULT = 300000;
+function ceilingFromEnv(envVar, fallback) {
+  const raw = process.env[envVar];
+  if (raw === undefined)
+    return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function webhookMaxRetriesCeiling() {
+  return ceilingFromEnv("WEBHOOK_MAX_RETRIES_CEILING", WEBHOOK_MAX_RETRIES_CEILING_DEFAULT);
+}
+function webhookTimeoutMsCeiling() {
+  return ceilingFromEnv("WEBHOOK_TIMEOUT_MS_CEILING", WEBHOOK_TIMEOUT_MS_CEILING_DEFAULT);
+}
+function maxRetriesField() {
+  return z3.number().int().min(0).optional().superRefine((v, ctx) => {
+    if (v === undefined)
+      return;
+    const ceiling = webhookMaxRetriesCeiling();
+    if (v > ceiling) {
+      ctx.addIssue({
+        code: "custom",
+        message: `maxRetries exceeds ceiling (${ceiling})`
+      });
+    }
+  });
+}
+function timeoutMsField() {
+  return z3.number().int().min(100).optional().superRefine((v, ctx) => {
+    if (v === undefined)
+      return;
+    const ceiling = webhookTimeoutMsCeiling();
+    if (v > ceiling) {
+      ctx.addIssue({
+        code: "custom",
+        message: `timeoutMs exceeds ceiling (${ceiling})`
+      });
+    }
+  });
+}
 var WEBHOOK_FILTER_OPERATORS = [
   "eq",
   "neq",
@@ -1350,8 +1497,8 @@ var CreateWebhookRequestSchema = z3.object({
   format: WebhookFormatSchema.default("standard-webhooks"),
   runtime: WebhookRuntimeSchema.nullable().optional(),
   authConfig: z3.record(z3.string(), z3.unknown()).optional(),
-  maxRetries: z3.number().int().min(0).max(100).optional(),
-  timeoutMs: z3.number().int().min(100).max(300000).optional(),
+  maxRetries: maxRetriesField(),
+  timeoutMs: timeoutMsField(),
   concurrency: z3.number().int().min(1).max(100).optional()
 }).refine((v) => {
   const subgraphMode = v.subgraphName !== undefined || v.tableName !== undefined;
@@ -1374,8 +1521,8 @@ var UpdateWebhookRequestSchema = z3.object({
   format: WebhookFormatSchema.optional(),
   runtime: WebhookRuntimeSchema.nullable().optional(),
   authConfig: z3.record(z3.string(), z3.unknown()).optional(),
-  maxRetries: z3.number().int().min(0).max(100).optional(),
-  timeoutMs: z3.number().int().min(100).max(300000).optional(),
+  maxRetries: maxRetriesField(),
+  timeoutMs: timeoutMsField(),
   concurrency: z3.number().int().min(1).max(100).optional()
 }).refine((value) => Object.keys(value).length > 0, {
   message: "At least one field must be provided"
@@ -1517,24 +1664,19 @@ function validateWebhookFilterForTable(input) {
 }
 // src/subgraphs/spec.ts
 var SYSTEM_COLUMNS = ["_id", "_block_height", "_tx_id", "_created_at"];
-var BASE_QUERY_PARAMS = ["_limit", "_offset", "_sort", "_order", "_fields"];
-var PUBLIC_BASE_QUERY_PARAMS = ["_limit", "cursor", "_order", "_fields"];
+var BASE_QUERY_PARAMS = ["_limit", "cursor", "_order", "_fields"];
 var COMPARISON_OPS = ["neq", "gt", "gte", "lt", "lte"];
-function isPublicRead(detail, options) {
-  return options.forcePublicRead ?? detail.visibility === "public";
-}
 function generatedAt(options) {
   return options.generatedAt ?? new Date().toISOString();
 }
 function normalizeServerUrl(serverUrl) {
   return (serverUrl ?? "http://127.0.0.1:3800").replace(/\/+$/, "");
 }
-function tablePath(subgraphName, tableName, publicRead) {
-  const base = publicRead ? "/v1/subgraphs" : "/api/subgraphs";
-  return `${base}/${subgraphName}/${tableName}`;
+function tablePath(subgraphName, tableName) {
+  return `/v1/subgraphs/${subgraphName}/${tableName}`;
 }
-function countPath(subgraphName, tableName, publicRead) {
-  return `${tablePath(subgraphName, tableName, publicRead)}/count`;
+function countPath(subgraphName, tableName) {
+  return `${tablePath(subgraphName, tableName)}/count`;
 }
 function isTextLike(type) {
   return type === "text" || type === "principal" || type === "timestamp";
@@ -1601,50 +1743,50 @@ function columnEntries(table) {
   return Object.entries(table.columns);
 }
 function selectableColumns(table) {
-  return columnEntries(table).map(([name2]) => name2);
+  return columnEntries(table).map(([name]) => name);
 }
 function searchableColumns(table) {
-  return columnEntries(table).filter(([, col]) => col.searchable).map(([name2]) => name2);
+  return columnEntries(table).filter(([, col]) => col.searchable).map(([name]) => name);
 }
 function filterNames(table) {
   const result = [];
-  for (const [name2, col] of columnEntries(table)) {
-    result.push(name2);
-    result.push(`${name2}.neq`);
+  for (const [name, col] of columnEntries(table)) {
+    result.push(name);
+    result.push(`${name}.neq`);
     if (isComparable(col.type)) {
-      for (const op of COMPARISON_OPS.filter((op2) => op2 !== "neq")) {
-        result.push(`${name2}.${op}`);
+      for (const op of COMPARISON_OPS.filter((op) => op !== "neq")) {
+        result.push(`${name}.${op}`);
       }
     }
     if (isTextLike(col.type))
-      result.push(`${name2}.like`);
+      result.push(`${name}.like`);
   }
   return result;
 }
-function queryParameters(table, publicRead) {
-  const params = publicRead ? [...PUBLIC_BASE_QUERY_PARAMS] : [...BASE_QUERY_PARAMS];
+function queryParameters(table) {
+  const params = [...BASE_QUERY_PARAMS];
   if (searchableColumns(table).length > 0)
     params.push("_search");
   return params;
 }
 function rowExample(table) {
   const row = {};
-  for (const [name2, col] of columnEntries(table)) {
-    row[name2] = exampleForColumn(col.type);
+  for (const [name, col] of columnEntries(table)) {
+    row[name] = exampleForColumn(col.type);
   }
   return row;
 }
-function openApiParameter(name2, description, schema = { type: "string" }) {
+function openApiParameter(name, description, schema = { type: "string" }) {
   return {
-    name: name2,
+    name,
     in: "query",
     required: false,
     description,
     schema
   };
 }
-function tableParameters(table, publicRead) {
-  const parameters = publicRead ? [
+function tableParameters(table) {
+  const parameters = [
     openApiParameter("_limit", "Maximum rows to return.", {
       type: "integer",
       default: 50,
@@ -1660,52 +1802,28 @@ function tableParameters(table, publicRead) {
     openApiParameter("_fields", "Comma-separated columns to include.", {
       type: "string"
     })
-  ] : [
-    openApiParameter("_limit", "Maximum rows to return.", {
-      type: "integer",
-      default: 50,
-      minimum: 1,
-      maximum: 1000
-    }),
-    openApiParameter("_offset", "Rows to skip for pagination.", {
-      type: "integer",
-      default: 0,
-      minimum: 0
-    }),
-    openApiParameter("_sort", "Column to sort by.", {
-      type: "string",
-      enum: selectableColumns(table)
-    }),
-    openApiParameter("_order", "Sort direction.", {
-      type: "string",
-      enum: ["asc", "desc"],
-      default: "asc"
-    }),
-    openApiParameter("_fields", "Comma-separated columns to include.", {
-      type: "string"
-    })
   ];
   if (searchableColumns(table).length > 0) {
     parameters.push(openApiParameter("_search", "Search across searchable columns.", {
       type: "string"
     }));
   }
-  for (const [name2, col] of columnEntries(table)) {
-    parameters.push(openApiParameter(name2, `Filter ${name2} by equality.`, {
+  for (const [name, col] of columnEntries(table)) {
+    parameters.push(openApiParameter(name, `Filter ${name} by equality.`, {
       type: "string"
     }));
-    parameters.push(openApiParameter(`${name2}.neq`, `Filter ${name2} by inequality.`, {
+    parameters.push(openApiParameter(`${name}.neq`, `Filter ${name} by inequality.`, {
       type: "string"
     }));
     if (isComparable(col.type)) {
       for (const op of ["gt", "gte", "lt", "lte"]) {
-        parameters.push(openApiParameter(`${name2}.${op}`, `Filter ${name2} with ${op}.`, {
+        parameters.push(openApiParameter(`${name}.${op}`, `Filter ${name} with ${op}.`, {
           type: "string"
         }));
       }
     }
     if (isTextLike(col.type)) {
-      parameters.push(openApiParameter(`${name2}.like`, `Case-insensitive contains filter for ${name2}.`, {
+      parameters.push(openApiParameter(`${name}.like`, `Case-insensitive contains filter for ${name}.`, {
         type: "string"
       }));
     }
@@ -1714,24 +1832,21 @@ function tableParameters(table, publicRead) {
 }
 function generateSubgraphAgentSchema(detail, options = {}) {
   const serverUrl = normalizeServerUrl(options.serverUrl);
-  const publicRead = isPublicRead(detail, options);
   const tables = {};
   for (const [tableName, table] of Object.entries(detail.tables)) {
-    const path = tablePath(detail.name, tableName, publicRead);
+    const path = tablePath(detail.name, tableName);
     tables[tableName] = {
       endpoint: `${serverUrl}${path}`,
-      countEndpoint: `${serverUrl}${countPath(detail.name, tableName, publicRead)}`,
-      ...publicRead ? {
-        aggregateEndpoint: `${serverUrl}${path}/aggregate`,
-        streamEndpoint: `${serverUrl}${path}/stream`
-      } : {},
+      countEndpoint: `${serverUrl}${countPath(detail.name, tableName)}`,
+      aggregateEndpoint: `${serverUrl}${path}/aggregate`,
+      streamEndpoint: `${serverUrl}${path}/stream`,
       rowCount: table.rowCount,
       columns: table.columns,
       ...table.indexes ? { indexes: table.indexes } : {},
       ...table.uniqueKeys ? { uniqueKeys: table.uniqueKeys } : {},
       query: {
-        parameters: queryParameters(table, publicRead),
-        sortable: publicRead ? [] : selectableColumns(table),
+        parameters: queryParameters(table),
+        sortable: [],
         selectable: selectableColumns(table),
         searchable: searchableColumns(table),
         filters: filterNames(table)
@@ -1739,7 +1854,7 @@ function generateSubgraphAgentSchema(detail, options = {}) {
       examples: {
         list: rowExample(table),
         count: { count: table.rowCount },
-        curl: publicRead ? `curl '${serverUrl}${path}?_limit=10&_order=desc'` : `curl '${serverUrl}${path}?_limit=10&_sort=_block_height&_order=desc'`
+        curl: `curl '${serverUrl}${path}?_limit=10&_order=desc'`
       }
     };
   }
@@ -1756,7 +1871,6 @@ function generateSubgraphAgentSchema(detail, options = {}) {
 }
 function generateSubgraphOpenApi(detail, options = {}) {
   const serverUrl = normalizeServerUrl(options.serverUrl);
-  const publicRead = isPublicRead(detail, options);
   const paths = {};
   const schemas = {};
   for (const [tableName, table] of Object.entries(detail.tables)) {
@@ -1774,7 +1888,7 @@ function generateSubgraphOpenApi(detail, options = {}) {
       required,
       example: rowExample(table)
     };
-    const responseSchema = publicRead ? {
+    const responseSchema = {
       type: "object",
       properties: {
         rows: {
@@ -1791,28 +1905,12 @@ function generateSubgraphOpenApi(detail, options = {}) {
           }
         }
       }
-    } : {
-      type: "object",
-      properties: {
-        data: {
-          type: "array",
-          items: { $ref: `#/components/schemas/${schemaName}` }
-        },
-        meta: {
-          type: "object",
-          properties: {
-            total: { type: "integer" },
-            limit: { type: "integer" },
-            offset: { type: "integer" }
-          }
-        }
-      }
     };
-    paths[tablePath(detail.name, tableName, publicRead)] = {
+    paths[tablePath(detail.name, tableName)] = {
       get: {
         summary: `Query ${detail.name}.${tableName}`,
         operationId: `query_${detail.name.replace(/-/g, "_")}_${tableName}`,
-        parameters: tableParameters(table, publicRead),
+        parameters: tableParameters(table),
         responses: {
           "200": {
             description: "Rows returned from the subgraph table.",
@@ -1825,11 +1923,11 @@ function generateSubgraphOpenApi(detail, options = {}) {
         }
       }
     };
-    paths[countPath(detail.name, tableName, publicRead)] = {
+    paths[countPath(detail.name, tableName)] = {
       get: {
         summary: `Count ${detail.name}.${tableName}`,
         operationId: `count_${detail.name.replace(/-/g, "_")}_${tableName}`,
-        parameters: tableParameters(table, publicRead),
+        parameters: tableParameters(table),
         responses: {
           "200": {
             description: "Row count for the filtered table query.",
@@ -1868,14 +1966,13 @@ function generateSubgraphOpenApi(detail, options = {}) {
 }
 function generateSubgraphMarkdown(detail, options = {}) {
   const agent = generateSubgraphAgentSchema(detail, options);
-  const publicRead = isPublicRead(detail, options);
   const lines = [
     `# ${detail.name} Subgraph API`,
     "",
     `Version: ${detail.version}`,
     detail.schemaHash ? `Schema hash: ${detail.schemaHash}` : undefined,
     `Server: ${agent.serverUrl}`,
-    publicRead ? "Visibility: public — anon reads, no API key. Responses use the `{ rows, next_cursor, tip }` envelope; paginate with `?cursor=<next_cursor>` and `_order=asc|desc` (`_offset`/`_sort` are rejected)." : undefined,
+    "Responses use the `{ rows, next_cursor, tip }` envelope; paginate with `?cursor=<next_cursor>` and `_order=asc|desc` (`_offset` is rejected).",
     "",
     detail.description
   ].filter((line) => line !== undefined && line !== "");
@@ -1903,15 +2000,14 @@ function generateSubgraphSpec(detail, format, options = {}) {
     return generateSubgraphAgentSchema(detail, options);
   return generateSubgraphMarkdown(detail, options);
 }
-
 // src/crypto/hmac.ts
 var exports_hmac = {};
 __export(exports_hmac, {
-  verifySignatureHeader: () => verifySignatureHeader,
-  verifySignature: () => verifySignature,
-  signPayload: () => signPayload,
+  createSignatureHeader: () => createSignatureHeader,
   generateSecret: () => generateSecret,
-  createSignatureHeader: () => createSignatureHeader
+  signPayload: () => signPayload,
+  verifySignature: () => verifySignature,
+  verifySignatureHeader: () => verifySignatureHeader
 });
 import { createHmac, randomBytes } from "node:crypto";
 function generateSecret() {
@@ -1957,17 +2053,16 @@ function verifySignatureHeader(payload, header, secret, toleranceSeconds = 300)
   const signedPayload = `${ts}.${payload}`;
   return verifySignature(signedPayload, signature, secret);
 }
-
 // src/crypto/ed25519.ts
 var exports_ed25519 = {};
 __export(exports_ed25519, {
-  verifyEd25519: () => verifyEd25519,
-  signEd25519: () => signEd25519,
-  publicKeyPemFromPrivate: () => publicKeyPemFromPrivate,
-  loadEd25519PublicKey: () => loadEd25519PublicKey,
-  loadEd25519PrivateKey: () => loadEd25519PrivateKey,
+  ed25519KeyId: () => ed25519KeyId,
   generateEd25519KeyPair: () => generateEd25519KeyPair,
-  ed25519KeyId: () => ed25519KeyId
+  loadEd25519PrivateKey: () => loadEd25519PrivateKey,
+  loadEd25519PublicKey: () => loadEd25519PublicKey,
+  publicKeyPemFromPrivate: () => publicKeyPemFromPrivate,
+  signEd25519: () => signEd25519,
+  verifyEd25519: () => verifyEd25519
 });
 import {
   createHash,
@@ -2010,197 +2105,90 @@ function verifyEd25519(payload, signatureBase64, publicKey) {
     return false;
   }
 }
-// src/event-types.ts
-import {
-  DECODED_EVENT_TYPES
-} from "@secondlayer/stacks/filters";
-import {
-  DECODED_EVENT_TYPES as DECODED_EVENT_TYPES2,
-  VM_EVENT_TYPES,
-  VM_NODE_TO_STORED_TYPE
-} from "@secondlayer/stacks/filters";
-var VM_STORED_TO_NODE_TYPE = {
-  nested_contract_call: "contract_call_event",
-  var_set: "var_set_event",
-  map_set: "map_set_event",
-  map_insert: "map_insert_event",
-  map_delete: "map_delete_event"
-};
-var STREAMS_EVENT_TYPES = DECODED_EVENT_TYPES;
-// src/db-event-types.ts
-var STREAMS_DB_EVENT_TYPES = [
-  "stx_transfer_event",
-  "stx_mint_event",
-  "stx_burn_event",
-  "stx_lock_event",
-  "ft_transfer_event",
-  "ft_mint_event",
-  "ft_burn_event",
-  "nft_transfer_event",
-  "nft_mint_event",
-  "nft_burn_event",
-  "smart_contract_event",
-  "contract_event"
-];
-var DB_TO_STREAMS_EVENT_TYPE = {
-  stx_transfer_event: "stx_transfer",
-  stx_mint_event: "stx_mint",
-  stx_burn_event: "stx_burn",
-  stx_lock_event: "stx_lock",
-  ft_transfer_event: "ft_transfer",
-  ft_mint_event: "ft_mint",
-  ft_burn_event: "ft_burn",
-  nft_transfer_event: "nft_transfer",
-  nft_mint_event: "nft_mint",
-  nft_burn_event: "nft_burn",
-  smart_contract_event: "print",
-  contract_event: "print"
-};
-var STREAMS_TO_DB_EVENT_TYPES = {
-  stx_transfer: ["stx_transfer_event"],
-  stx_mint: ["stx_mint_event"],
-  stx_burn: ["stx_burn_event"],
-  stx_lock: ["stx_lock_event"],
-  ft_transfer: ["ft_transfer_event"],
-  ft_mint: ["ft_mint_event"],
-  ft_burn: ["ft_burn_event"],
-  nft_transfer: ["nft_transfer_event"],
-  nft_mint: ["nft_mint_event"],
-  nft_burn: ["nft_burn_event"],
-  print: ["smart_contract_event", "contract_event"]
-};
-// src/finality.ts
-var DEFAULT_BTC_CONFIRMATIONS = 6;
-function finalizedBurnHeight(burnTipHeight, confirmations = DEFAULT_BTC_CONFIRMATIONS) {
-  if (!Number.isInteger(burnTipHeight) || burnTipHeight < 0) {
-    throw new Error("burnTipHeight must be a non-negative integer");
-  }
-  if (!Number.isInteger(confirmations) || confirmations < 0) {
-    throw new Error("confirmations must be a non-negative integer");
-  }
-  return Math.max(0, burnTipHeight - confirmations);
-}
-// src/streams-cursor.ts
-var EMPTY_RANGE_EVENT_INDEX_SENTINEL = 2147483647;
-function encodeStreamsCursor(cursor) {
-  return `${cursor.block_height}:${cursor.event_index}`;
-}
-function decodeStreamsCursor(cursor) {
-  const match = /^(0|[1-9]\d*):(0|[1-9]\d*)$/.exec(cursor);
-  if (!match) {
-    throw new Error("Invalid Streams cursor");
-  }
-  const decoded = {
-    block_height: Number(match[1]),
-    event_index: Number(match[2])
-  };
-  if (!Number.isSafeInteger(decoded.block_height) || !Number.isSafeInteger(decoded.event_index)) {
-    throw new Error("Invalid Streams cursor");
-  }
-  return decoded;
-}
-function compareStreamsCursor(a, b) {
-  if (a.block_height !== b.block_height) {
-    return a.block_height < b.block_height ? -1 : 1;
-  }
-  if (a.event_index !== b.event_index) {
-    return a.event_index < b.event_index ? -1 : 1;
-  }
-  return 0;
-}
-function isEmptyRangeCursor(cursor) {
-  return cursor.event_index === EMPTY_RANGE_EVENT_INDEX_SENTINEL;
-}
-function blockEndCursor(height) {
-  return {
-    block_height: height,
-    event_index: EMPTY_RANGE_EVENT_INDEX_SENTINEL
-  };
-}
 export {
-  validateWebhookFilterForTable,
-  sql2 as sql,
-  setMigrationRole,
-  parseJsonb,
-  onControlPlane,
-  onChainPlane,
-  logger,
-  jsonb,
-  isSbtcDecoderEnabled,
-  isPox5DecoderEnabled,
-  isPox4DecoderEnabled,
-  isEmptyRangeCursor,
-  isBnsDecoderEnabled,
-  getTargetDb,
-  getSourceDb,
-  getRawClientFor,
-  getRawClient,
-  getMigrationRole,
-  getErrorMessage,
-  getEnv,
-  getDbSplitStatus,
-  getDb,
-  generateSubgraphSpec,
-  generateSubgraphOpenApi,
-  generateSubgraphMarkdown,
-  generateSubgraphAgentSchema,
-  formatWebhookSchemaErrors,
-  finalizedBurnHeight,
-  encodeStreamsCursor,
-  exports_ed25519 as ed25519,
-  decodeStreamsCursor,
-  exports_hmac as crypto,
-  compareStreamsCursor,
-  closeDb,
-  blockEndCursor,
-  assertDbSplit,
-  applicationDatabaseUrl,
-  WebhookStatusSchema,
-  WebhookRuntimeSchema,
-  WebhookFormatSchema,
-  WebhookFilterSchema,
-  WebhookFilterPrimitiveSchema,
-  WebhookFilterOperatorSchema,
-  WebhookFilterClauseSchema,
-  WEBHOOK_STATUSES,
-  WEBHOOK_RUNTIMES,
-  WEBHOOK_FORMATS,
-  WEBHOOK_FILTER_OPERATORS,
-  VersionConflictError,
-  ValidationError,
-  VM_STORED_TO_NODE_TYPE,
-  VM_NODE_TO_STORED_TYPE,
-  VM_EVENT_TYPES,
-  UpdateWebhookRequestSchema,
-  TenantSuspendedError,
-  TABLE_TO_DB,
-  SecondLayerError,
-  STREAMS_TO_DB_EVENT_TYPES,
-  STREAMS_EVENT_TYPES,
-  STREAMS_DB_EVENT_TYPES,
-  SOURCE_READ_TYPES,
-  SOURCE_READ_PKS,
-  SOURCE_READ_COLUMNS,
-  ReplayWebhookRequestSchema,
-  RateLimitError,
-  PaymentRequiredError,
-  NotFoundError,
-  KeyRotatedError,
-  ForbiddenError,
-  ErrorCodes,
-  EMPTY_RANGE_EVENT_INDEX_SENTINEL,
-  DeploySubgraphRequestSchema,
-  DatabaseError,
-  DEFAULT_BTC_CONFIRMATIONS,
-  DECODED_EVENT_TYPES2 as DECODED_EVENT_TYPES,
-  DB_TO_STREAMS_EVENT_TYPE,
-  CreateWebhookRequestSchema,
-  CODE_TO_STATUS,
-  CHAIN_TRIGGER_TYPES,
-  CHAIN_TRIGGER_FIELDS,
+  AuthenticationError,
   AuthorizationError,
-  AuthenticationError
+  CHAIN_TRIGGER_FIELDS,
+  CHAIN_TRIGGER_TYPES,
+  CODE_TO_STATUS,
+  CreateWebhookRequestSchema,
+  DB_TO_STREAMS_EVENT_TYPE,
+  DECODED_EVENT_TYPES2 as DECODED_EVENT_TYPES,
+  DEFAULT_BTC_CONFIRMATIONS,
+  DatabaseError,
+  DeploySubgraphRequestSchema,
+  EMPTY_RANGE_EVENT_INDEX_SENTINEL,
+  ErrorCodes,
+  ForbiddenError,
+  KeyRotatedError,
+  NotFoundError,
+  PaymentRequiredError,
+  RateLimitError,
+  ReplayWebhookRequestSchema,
+  SOURCE_READ_COLUMNS,
+  SOURCE_READ_PKS,
+  SOURCE_READ_TYPES,
+  STREAMS_DB_EVENT_TYPES,
+  STREAMS_EVENT_TYPES,
+  STREAMS_TO_DB_EVENT_TYPES,
+  SecondLayerError,
+  TABLE_TO_DB,
+  TenantSuspendedError,
+  UpdateWebhookRequestSchema,
+  VM_EVENT_TYPES,
+  VM_NODE_TO_STORED_TYPE,
+  VM_STORED_TO_NODE_TYPE,
+  ValidationError,
+  VersionConflictError,
+  WEBHOOK_FILTER_OPERATORS,
+  WEBHOOK_FORMATS,
+  WEBHOOK_RUNTIMES,
+  WEBHOOK_STATUSES,
+  WebhookFilterClauseSchema,
+  WebhookFilterOperatorSchema,
+  WebhookFilterPrimitiveSchema,
+  WebhookFilterSchema,
+  WebhookFormatSchema,
+  WebhookRuntimeSchema,
+  WebhookStatusSchema,
+  applicationDatabaseUrl,
+  assertDbSplit,
+  blockEndCursor,
+  closeDb,
+  compareStreamsCursor,
+  exports_hmac as crypto,
+  decodeStreamsCursor,
+  exports_ed25519 as ed25519,
+  encodeStreamsCursor,
+  finalizedBurnHeight,
+  formatWebhookSchemaErrors,
+  generateSubgraphAgentSchema,
+  generateSubgraphMarkdown,
+  generateSubgraphOpenApi,
+  generateSubgraphSpec,
+  getDb,
+  getDbSplitStatus,
+  getEnv,
+  getErrorMessage,
+  getMigrationRole,
+  getRawClient,
+  getRawClientFor,
+  getSourceDb,
+  getTargetDb,
+  isBnsDecoderEnabled,
+  isEmptyRangeCursor,
+  isPox4DecoderEnabled,
+  isPox5DecoderEnabled,
+  isSbtcDecoderEnabled,
+  jsonb,
+  logger,
+  onChainPlane,
+  onControlPlane,
+  parseJsonb,
+  setMigrationRole,
+  sql2 as sql,
+  validateWebhookFilterForTable
 };
 
-//# debugId=A60A47C6792357BF64756E2164756E21
+//# debugId=615FC1FF75B4DD1364756E2164756E21
 //# sourceMappingURL=index.js.map