@secondlayer/shared 0.2.0

package/dist/src/index.js

@@ -0,0 +1,642 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+// src/db/jsonb.ts
+import { sql } from "kysely";
+function jsonb(value) {
+  const escaped = JSON.stringify(value).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";
+var db = null;
+var rawClient = null;
+function getDb(connectionString) {
+  if (!db) {
+    const url = connectionString || process.env.DATABASE_URL || "postgres://postgres:postgres@localhost:5432/streams_dev";
+    const isLocal = url.includes("localhost") || url.includes("127.0.0.1") || url.includes("@postgres:");
+    rawClient = postgres(url, {
+      ssl: isLocal ? undefined : { rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== "0" }
+    });
+    db = new Kysely({
+      dialect: new PostgresJSDialect({ postgres: rawClient })
+    });
+  }
+  return db;
+}
+function getRawClient() {
+  if (!rawClient)
+    getDb();
+  return rawClient;
+}
+async function closeDb() {
+  if (db) {
+    await db.destroy();
+    db = null;
+  }
+  if (rawClient) {
+    await rawClient.end();
+    rawClient = null;
+  }
+}
+// src/errors.ts
+class StreamsError extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = this.constructor.name;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      stack: this.stack,
+      cause: this.cause
+    };
+  }
+}
+
+class StreamNotFoundError extends StreamsError {
+  constructor(streamId) {
+    super("STREAM_NOT_FOUND", `Stream not found: ${streamId}`);
+  }
+}
+
+class ValidationError extends StreamsError {
+  constructor(message, cause) {
+    super("VALIDATION_ERROR", message, cause);
+  }
+}
+
+class DatabaseError extends StreamsError {
+  constructor(message, cause) {
+    super("DATABASE_ERROR", message, cause);
+  }
+}
+
+class WebhookDeliveryError extends StreamsError {
+  statusCode;
+  constructor(message, statusCode, cause) {
+    super("WEBHOOK_DELIVERY_ERROR", message, cause);
+    this.statusCode = statusCode;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      statusCode: this.statusCode
+    };
+  }
+}
+
+class FilterEvaluationError extends StreamsError {
+  constructor(message, cause) {
+    super("FILTER_EVALUATION_ERROR", message, cause);
+  }
+}
+
+class AuthenticationError extends StreamsError {
+  constructor(message) {
+    super("AUTHENTICATION_ERROR", message);
+  }
+}
+
+class AuthorizationError extends StreamsError {
+  constructor(message) {
+    super("AUTHORIZATION_ERROR", message);
+  }
+}
+
+class RateLimitError extends StreamsError {
+  constructor(message) {
+    super("RATE_LIMIT_ERROR", message);
+  }
+}
+
+// src/env.ts
+import { z } from "zod";
+var networksSchema = z.string().transform((val) => {
+  const networks = val.split(",").map((n) => n.trim()).filter(Boolean);
+  const valid = ["mainnet", "testnet"];
+  for (const n of networks) {
+    if (!valid.includes(n)) {
+      throw new Error(`Invalid network: ${n}. Must be one of: ${valid.join(", ")}`);
+    }
+  }
+  return networks;
+});
+var envSchema = z.object({
+  DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
+  NETWORK: z.enum(["mainnet", "testnet"]).optional(),
+  NETWORKS: networksSchema.optional(),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development")
+});
+var cachedEnv = null;
+function getEnv() {
+  if (cachedEnv) {
+    return cachedEnv;
+  }
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    console.error("❌ Invalid environment configuration:");
+    console.error(result.error.format());
+    throw new Error("Invalid environment configuration");
+  }
+  let enabledNetworks;
+  if (result.data.NETWORKS && result.data.NETWORKS.length > 0) {
+    enabledNetworks = result.data.NETWORKS;
+  } else if (result.data.NETWORK) {
+    enabledNetworks = [result.data.NETWORK];
+  } else {
+    enabledNetworks = ["mainnet"];
+  }
+  cachedEnv = { ...result.data, enabledNetworks };
+  return cachedEnv;
+}
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+class Logger {
+  _level;
+  _isProduction;
+  _initialized = false;
+  init() {
+    if (this._initialized)
+      return;
+    this._initialized = true;
+    try {
+      const env = getEnv();
+      this._level = env.LOG_LEVEL;
+      this._isProduction = env.NODE_ENV === "production";
+    } catch {
+      this._level = "info";
+      this._isProduction = false;
+    }
+  }
+  get level() {
+    this.init();
+    return this._level;
+  }
+  get isProduction() {
+    this.init();
+    return this._isProduction;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  formatMessage(level, message, meta) {
+    const timestamp = new Date().toISOString();
+    if (this.isProduction) {
+      return JSON.stringify({
+        timestamp,
+        level,
+        message,
+        ...meta
+      });
+    }
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `[${timestamp}] ${level.toUpperCase()}: ${message}${metaStr}`;
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.debug(this.formatMessage("debug", message, meta));
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.info(this.formatMessage("info", message, meta));
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.warn(this.formatMessage("warn", message, meta));
+    }
+  }
+  error(message, meta) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message, meta));
+    }
+  }
+}
+var logger = new Logger;
+
+// src/queue/index.ts
+var exports_queue = {};
+__export(exports_queue, {
+  stats: () => stats,
+  getWorkerId: () => getWorkerId,
+  fail: () => fail,
+  enqueue: () => enqueue,
+  complete: () => complete,
+  claim: () => claim,
+  WORKER_ID: () => WORKER_ID
+});
+import { sql as sql3 } from "kysely";
+import { randomUUID } from "crypto";
+var WORKER_ID = `worker-${randomUUID().slice(0, 8)}`;
+async function enqueue(streamId, blockHeight, backfill = false) {
+  const db2 = getDb();
+  const row = await db2.insertInto("jobs").values({
+    stream_id: streamId,
+    block_height: blockHeight,
+    backfill,
+    status: "pending",
+    attempts: 0
+  }).returning(["id"]).executeTakeFirstOrThrow();
+  return row.id;
+}
+async function claim() {
+  const db2 = getDb();
+  const { rows } = await sql3`
+    UPDATE jobs
+    SET
+      status = 'processing',
+      locked_at = NOW(),
+      locked_by = ${WORKER_ID},
+      attempts = attempts + 1
+    WHERE id = (
+      SELECT id FROM jobs
+      WHERE status = 'pending'
+      ORDER BY
+        backfill ASC,
+        block_height ASC,
+        created_at ASC
+      FOR UPDATE SKIP LOCKED
+      LIMIT 1
+    )
+    RETURNING *
+  `.execute(db2);
+  return rows[0] ?? null;
+}
+async function complete(jobId) {
+  const db2 = getDb();
+  await db2.updateTable("jobs").set({
+    status: "completed",
+    completed_at: new Date,
+    locked_at: null,
+    locked_by: null
+  }).where("id", "=", jobId).execute();
+}
+async function fail(jobId, error, maxAttempts = 3) {
+  const db2 = getDb();
+  const job = await db2.selectFrom("jobs").select("attempts").where("id", "=", jobId).executeTakeFirst();
+  if (!job)
+    return;
+  if (job.attempts < maxAttempts) {
+    await db2.updateTable("jobs").set({
+      status: "pending",
+      error,
+      locked_at: null,
+      locked_by: null
+    }).where("id", "=", jobId).execute();
+  } else {
+    await db2.updateTable("jobs").set({
+      status: "failed",
+      error,
+      completed_at: new Date,
+      locked_at: null,
+      locked_by: null
+    }).where("id", "=", jobId).execute();
+  }
+}
+async function stats() {
+  const { rows } = await sql3`
+    SELECT status, COUNT(*) as count
+    FROM jobs
+    GROUP BY status
+  `.execute(getDb());
+  const counts = {};
+  for (const row of rows) {
+    counts[row.status] = parseInt(row.count, 10);
+  }
+  return {
+    pending: counts["pending"] || 0,
+    processing: counts["processing"] || 0,
+    completed: counts["completed"] || 0,
+    failed: counts["failed"] || 0,
+    total: Object.values(counts).reduce((a, b) => a + b, 0)
+  };
+}
+function getWorkerId() {
+  return WORKER_ID;
+}
+// src/schemas/filters.ts
+import { z as z2 } from "zod";
+import { validateStacksAddress } from "@stacks/transactions";
+var stacksPrincipal = z2.string().refine((val) => {
+  const parts = val.split(".");
+  if (parts.length > 2)
+    return false;
+  return validateStacksAddress(parts[0]);
+}, "Invalid Stacks principal address");
+var baseFilter = {
+  sender: stacksPrincipal.optional(),
+  recipient: stacksPrincipal.optional()
+};
+var StxTransferFilterSchema = z2.object({
+  type: z2.literal("stx_transfer"),
+  ...baseFilter,
+  minAmount: z2.coerce.number().int().positive().optional(),
+  maxAmount: z2.coerce.number().int().positive().optional()
+});
+var StxMintFilterSchema = z2.object({
+  type: z2.literal("stx_mint"),
+  recipient: stacksPrincipal.optional(),
+  minAmount: z2.coerce.number().int().positive().optional()
+});
+var StxBurnFilterSchema = z2.object({
+  type: z2.literal("stx_burn"),
+  sender: stacksPrincipal.optional(),
+  minAmount: z2.coerce.number().int().positive().optional()
+});
+var StxLockFilterSchema = z2.object({
+  type: z2.literal("stx_lock"),
+  lockedAddress: stacksPrincipal.optional(),
+  minAmount: z2.coerce.number().int().positive().optional()
+});
+var FtTransferFilterSchema = z2.object({
+  type: z2.literal("ft_transfer"),
+  ...baseFilter,
+  assetIdentifier: z2.string().optional(),
+  minAmount: z2.coerce.number().int().positive().optional()
+});
+var FtMintFilterSchema = z2.object({
+  type: z2.literal("ft_mint"),
+  recipient: stacksPrincipal.optional(),
+  assetIdentifier: z2.string().optional(),
+  minAmount: z2.coerce.number().int().positive().optional()
+});
+var FtBurnFilterSchema = z2.object({
+  type: z2.literal("ft_burn"),
+  sender: stacksPrincipal.optional(),
+  assetIdentifier: z2.string().optional(),
+  minAmount: z2.coerce.number().int().positive().optional()
+});
+var NftTransferFilterSchema = z2.object({
+  type: z2.literal("nft_transfer"),
+  ...baseFilter,
+  assetIdentifier: z2.string().optional(),
+  tokenId: z2.string().optional()
+});
+var NftMintFilterSchema = z2.object({
+  type: z2.literal("nft_mint"),
+  recipient: stacksPrincipal.optional(),
+  assetIdentifier: z2.string().optional(),
+  tokenId: z2.string().optional()
+});
+var NftBurnFilterSchema = z2.object({
+  type: z2.literal("nft_burn"),
+  sender: stacksPrincipal.optional(),
+  assetIdentifier: z2.string().optional(),
+  tokenId: z2.string().optional()
+});
+var ContractCallFilterSchema = z2.object({
+  type: z2.literal("contract_call"),
+  contractId: stacksPrincipal.optional(),
+  functionName: z2.string().optional(),
+  caller: stacksPrincipal.optional()
+});
+var ContractDeployFilterSchema = z2.object({
+  type: z2.literal("contract_deploy"),
+  deployer: stacksPrincipal.optional(),
+  contractName: z2.string().optional()
+});
+var PrintEventFilterSchema = z2.object({
+  type: z2.literal("print_event"),
+  contractId: stacksPrincipal.optional(),
+  topic: z2.string().optional(),
+  contains: z2.string().optional()
+});
+var StreamFilterSchema = z2.discriminatedUnion("type", [
+  StxTransferFilterSchema,
+  StxMintFilterSchema,
+  StxBurnFilterSchema,
+  StxLockFilterSchema,
+  FtTransferFilterSchema,
+  FtMintFilterSchema,
+  FtBurnFilterSchema,
+  NftTransferFilterSchema,
+  NftMintFilterSchema,
+  NftBurnFilterSchema,
+  ContractCallFilterSchema,
+  ContractDeployFilterSchema,
+  PrintEventFilterSchema
+]);
+
+// src/schemas/views.ts
+import { z as z3 } from "zod";
+var DeployViewRequestSchema = z3.object({
+  name: z3.string().regex(/^[a-z0-9-]+$/, "lowercase alphanumeric + hyphens only").max(63),
+  version: z3.string().optional(),
+  description: z3.string().optional(),
+  sources: z3.array(z3.string()).min(1),
+  schema: z3.record(z3.unknown()),
+  handlerCode: z3.string().max(1048576, "handler code exceeds 1MB limit"),
+  reindex: z3.boolean().optional()
+});
+// src/schemas/stream.ts
+import { z as z4 } from "zod";
+var StreamOptionsSchema = z4.object({
+  decodeClarityValues: z4.boolean().default(true),
+  includeRawTx: z4.boolean().default(false),
+  includeBlockMetadata: z4.boolean().default(true),
+  rateLimit: z4.number().int().positive().max(100).default(10),
+  timeoutMs: z4.number().int().positive().max(30000).default(1e4),
+  maxRetries: z4.number().int().min(0).max(10).default(3)
+});
+var CreateStreamSchema = z4.object({
+  name: z4.string().min(1).max(255),
+  webhookUrl: z4.string().url(),
+  filters: z4.array(StreamFilterSchema).min(1),
+  options: StreamOptionsSchema.optional().default({}),
+  startBlock: z4.number().int().positive().optional(),
+  endBlock: z4.number().int().positive().optional()
+});
+var UpdateStreamSchema = z4.object({
+  name: z4.string().min(1).max(255).optional(),
+  webhookUrl: z4.string().url().optional(),
+  filters: z4.array(StreamFilterSchema).min(1).optional(),
+  options: StreamOptionsSchema.partial().optional()
+}).refine((data) => Object.keys(data).length > 0, { message: "At least one field must be provided for update" });
+var WebhookPayloadSchema = z4.object({
+  streamId: z4.string().uuid(),
+  streamName: z4.string(),
+  block: z4.object({
+    height: z4.number(),
+    hash: z4.string(),
+    parentHash: z4.string(),
+    burnBlockHeight: z4.number(),
+    timestamp: z4.number()
+  }),
+  matches: z4.object({
+    transactions: z4.array(z4.object({
+      txId: z4.string(),
+      type: z4.string(),
+      sender: z4.string(),
+      status: z4.string(),
+      contractId: z4.string().nullable(),
+      functionName: z4.string().nullable(),
+      rawTx: z4.string().optional()
+    })),
+    events: z4.array(z4.object({
+      txId: z4.string(),
+      eventIndex: z4.number(),
+      type: z4.string(),
+      data: z4.any()
+    }))
+  }),
+  isBackfill: z4.boolean(),
+  deliveredAt: z4.string().datetime()
+});
+var StreamMetricsSchema = z4.object({
+  totalDeliveries: z4.number(),
+  failedDeliveries: z4.number(),
+  lastTriggeredAt: z4.string().datetime().nullable(),
+  lastTriggeredBlock: z4.number().nullable(),
+  errorMessage: z4.string().nullable()
+});
+var StreamResponseSchema = z4.object({
+  id: z4.string().uuid(),
+  name: z4.string(),
+  status: z4.enum(["inactive", "active", "paused", "failed"]),
+  webhookUrl: z4.string().url(),
+  filters: z4.array(StreamFilterSchema),
+  options: StreamOptionsSchema,
+  totalDeliveries: z4.number().int().default(0),
+  failedDeliveries: z4.number().int().default(0),
+  lastTriggeredAt: z4.string().datetime().nullable().optional(),
+  lastTriggeredBlock: z4.number().int().nullable().optional(),
+  errorMessage: z4.string().nullable().optional(),
+  createdAt: z4.string().datetime(),
+  updatedAt: z4.string().datetime()
+});
+// src/crypto/hmac.ts
+var exports_hmac = {};
+__export(exports_hmac, {
+  verifySignatureHeader: () => verifySignatureHeader,
+  verifySignature: () => verifySignature,
+  signPayload: () => signPayload,
+  generateSecret: () => generateSecret,
+  createSignatureHeader: () => createSignatureHeader
+});
+import { createHmac, randomBytes } from "crypto";
+function generateSecret() {
+  return randomBytes(32).toString("hex");
+}
+function signPayload(payload, secret) {
+  const hmac = createHmac("sha256", secret);
+  hmac.update(payload);
+  return hmac.digest("hex");
+}
+function verifySignature(payload, signature, secret) {
+  const expectedSignature = signPayload(payload, secret);
+  if (signature.length !== expectedSignature.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0;i < signature.length; i++) {
+    result |= signature.charCodeAt(i) ^ expectedSignature.charCodeAt(i);
+  }
+  return result === 0;
+}
+function createSignatureHeader(payload, secret, timestamp) {
+  const ts = timestamp ?? Math.floor(Date.now() / 1000);
+  const signedPayload = `${ts}.${payload}`;
+  const signature = signPayload(signedPayload, secret);
+  return `t=${ts},v1=${signature}`;
+}
+function verifySignatureHeader(payload, header, secret, toleranceSeconds = 300) {
+  const parts = header.split(",");
+  const timestamp = parts.find((p) => p.startsWith("t="))?.slice(2);
+  const signature = parts.find((p) => p.startsWith("v1="))?.slice(3);
+  if (!timestamp || !signature) {
+    return false;
+  }
+  const ts = parseInt(timestamp, 10);
+  if (isNaN(ts)) {
+    return false;
+  }
+  const now = Math.floor(Date.now() / 1000);
+  if (Math.abs(now - ts) > toleranceSeconds) {
+    return false;
+  }
+  const signedPayload = `${ts}.${payload}`;
+  return verifySignature(signedPayload, signature, secret);
+}
+export {
+  sql2 as sql,
+  exports_queue as queue,
+  parseJsonb,
+  logger,
+  jsonb,
+  getRawClient,
+  getEnv,
+  getDb,
+  exports_hmac as crypto,
+  closeDb,
+  WebhookPayloadSchema,
+  WebhookDeliveryError,
+  ValidationError,
+  UpdateStreamSchema,
+  StxTransferFilterSchema,
+  StxMintFilterSchema,
+  StxLockFilterSchema,
+  StxBurnFilterSchema,
+  StreamsError,
+  StreamResponseSchema,
+  StreamOptionsSchema,
+  StreamNotFoundError,
+  StreamMetricsSchema,
+  StreamFilterSchema,
+  RateLimitError,
+  PrintEventFilterSchema,
+  NftTransferFilterSchema,
+  NftMintFilterSchema,
+  NftBurnFilterSchema,
+  FtTransferFilterSchema,
+  FtMintFilterSchema,
+  FtBurnFilterSchema,
+  FilterEvaluationError,
+  DeployViewRequestSchema,
+  DatabaseError,
+  CreateStreamSchema,
+  ContractDeployFilterSchema,
+  ContractCallFilterSchema,
+  AuthorizationError,
+  AuthenticationError
+};
+
+//# debugId=52ED396A08F9D61564756E2164756E21
+//# sourceMappingURL=index.js.map