@secondlayer/sdk 6.7.0 → 6.9.0

package/README.md

@@ -243,14 +243,19 @@ const result = await sl.subgraphs.deploy({ name, sources, schema, handlerCode })
 
 ## Subscriptions
 
-Per-row HTTP webhooks from subgraph tables.
+Signed HTTP webhooks. Subscriptions are polymorphic — pick one kind:
+
+- **subgraph** — fires on rows written to a deployed subgraph table.
+- **chain** — fires on raw chain events with no subgraph. Forward-looking: it
+  starts at the chain tip and never backfills. The turnkey "webhook on a
+  contract / event / function / trait".
 
 ```typescript
 // List / get
 const { data } = await sl.subscriptions.list();
 const sub = await sl.subscriptions.get(id);
 
-// Create — sink a subgraph table to a signed webhook endpoint.
+// Create a SUBGRAPH subscription — sink a subgraph table to a signed endpoint.
 // `signingSecret` is returned ONCE; store it in the receiver's env.
 const { subscription, signingSecret } = await sl.subscriptions.create({
   name: "whale-alerts",
@@ -259,8 +264,48 @@ const { subscription, signingSecret } = await sl.subscriptions.create({
   url: "https://example.com/hooks/transfers",
   format: "standard-webhooks", // or inngest | trigger | cloudflare | cloudevents | raw
 });
+```
+
+### Chain subscriptions
+
+Pass `triggers` instead of `subgraphName`/`tableName`. The `trigger.*` builders
+are optional sugar — you can also pass raw objects (e.g.
+`{ type: "contract_call", contractId: "SP....amm", functionName: "swap-*" }`).
+All string fields accept `*` wildcards; `trait` scopes to contracts conforming
+to a SIP/trait (e.g. `"sip-010"`); amounts are non-negative integer strings
+(uint128-safe) or numbers.
+
+```typescript
+import { SecondLayer, trigger } from "@secondlayer/sdk";
+
+const sl = new SecondLayer({ apiKey: "sk-sl_..." });
+
+const { subscription, signingSecret } = await sl.subscriptions.create({
+  name: "amm-swaps",
+  url: "https://my-app.com/webhook",
+  triggers: [
+    trigger.contractCall({ contractId: "SP....amm", functionName: "swap-*" }),
+    trigger.ftTransfer({ trait: "sip-010", minAmount: "1000000" }),
+  ],
+});
+```
 
-// Lifecycle
+One builder per event type:
+`trigger.stxTransfer` / `stxMint` / `stxBurn` / `stxLock`,
+`trigger.ftTransfer` / `ftMint` / `ftBurn`,
+`trigger.nftTransfer` / `nftMint` / `nftBurn`,
+`trigger.contractCall`, `trigger.contractDeploy`, `trigger.printEvent`.
+
+Delivery envelope (chain subs only): each apply is `chain.{type}.apply` with
+body `{ action: "apply", block_hash, block_height, tx_id, canonical, trigger,
+event }`. On reorg you get `chain.reorg.rollback` with `{ action: "rollback",
+fork_point_height, orphaned: [{ tx_id, event }] }`. Delivery is at-least-once: a
+tx surviving a reorg re-delivers an apply under its new `block_hash`, so key
+consumer state on `(tx_id, block_hash)`. Per-subscription HMAC signing (Standard
+Webhooks) is unchanged for both kinds.
+
+```typescript
+// Lifecycle (both kinds)
 await sl.subscriptions.update(id, { filter: { amount: { gte: "1000000" } } });
 await sl.subscriptions.pause(id);
 await sl.subscriptions.resume(id);

package/dist/index.d.ts

@@ -31,6 +31,23 @@ interface SubgraphSource {
 	reason?: string;
 	updatedAt: string;
 }
+/** Status of a tracked reindex/backfill operation (poll until terminal). */
+interface SubgraphOperationStatus {
+	id: string;
+	subgraphName: string;
+	kind: "reindex" | "backfill";
+	status: "queued" | "running" | "completed" | "failed" | "cancelled";
+	fromBlock: number | null;
+	toBlock: number | null;
+	processedBlocks: number | null;
+	/** 0–1 fraction; null when no denominator is known yet. 1 when completed. */
+	progress: number | null;
+	error: string | null;
+	startedAt: string | null;
+	finishedAt: string | null;
+	createdAt: string;
+	updatedAt: string;
+}
 interface BundleSubgraphResponse {
 	ok: true;
 	name: string;
@@ -73,6 +90,13 @@ declare class Subgraphs extends BaseClient {
 	}): Promise<{
 		message: string
 	}>;
+	/** Recent reindex/backfill operations for a subgraph, newest first. */
+	operations(name: string): Promise<{
+		operations: SubgraphOperationStatus[]
+	}>;
+	/** Status of a single operation (poll the `operationId` returned by
+	*  reindex/backfill/stop until `status` is terminal). */
+	getOperation(name: string, operationId: string): Promise<SubgraphOperationStatus>;
 	deploy(data: DeploySubgraphRequest): Promise<DeploySubgraphResponse>;
 	getSource(name: string): Promise<SubgraphSource>;
 	/**
@@ -105,6 +129,41 @@ declare class Subgraphs extends BaseClient {
 	private createTableClient;
 }
 import { InferSubgraphClient as InferSubgraphClient2 } from "@secondlayer/subgraphs";
+import { SubgraphSummary as SubgraphSummary2 } from "@secondlayer/shared/schemas";
+/**
+* Typed client for the agent-reachable key mint (`POST /v1/api-keys`).
+*
+* Lets a headless agent self-provision a SCOPED `streams`/`index` read key
+* without the dashboard. Requires an owner credential — an account-level API
+* key (or a dashboard session). The minted key is always scoped (never an
+* account/superkey) and inherits the account plan's tier.
+*/
+/** Scope of a minted read key. */
+type ScopedKeyProduct = "streams" | "index";
+interface CreateApiKeyParams {
+	/** Scope of the minted key. Defaults to "streams". */
+	product?: ScopedKeyProduct;
+	/** Optional human-readable label for the key. */
+	name?: string;
+}
+interface CreateApiKeyResponse {
+	/** Plaintext key — returned ONCE. Store it now; only its hash is persisted. */
+	key: string;
+	prefix: string;
+	id: string;
+	product: string;
+	tier: string | null;
+	createdAt: string;
+}
+declare class ApiKeys extends BaseClient {
+	constructor(options?: Partial<SecondLayerOptions>);
+	/**
+	* Mint a new scoped read key. The configured `apiKey` must be an
+	* account-level (owner) key; the plaintext `key` in the response is shown
+	* only once.
+	*/
+	create(params?: CreateApiKeyParams): Promise<CreateApiKeyResponse>;
+}
 /**
 * Typed client for the contract-discovery API (`GET /v1/contracts`).
 *
@@ -278,6 +337,17 @@ type IndexTip = {
 	block_height: number
 	lag_seconds: number
 };
+type IndexUsage = {
+	product: "index"
+	tier: string
+	limits: {
+		rate_limit_per_second: number | null
+	}
+	usage: {
+		decoded_events_today: number
+		decoded_events_this_month: number
+	}
+};
 type FtTransfer = {
 	cursor: string
 	block_height: number
@@ -737,6 +807,8 @@ type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
 };
 declare class Index extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
+	/** Your own Index consumption (decoded events today + this month) and tier limits. */
+	usage(): Promise<IndexUsage>;
 	readonly ftTransfers: {
 		list: (params?: FtTransfersListParams) => Promise<FtTransfersEnvelope>
 		walk: (params?: FtTransfersWalkParams) => AsyncIterable<FtTransfer>
@@ -808,8 +880,7 @@ declare class Index extends BaseClient {
 	private getMempoolTx;
 	private walkMempool;
 }
-declare const STREAMS_EVENT_TYPES: readonly ["stx_transfer", "stx_mint", "stx_burn", "stx_lock", "ft_transfer", "ft_mint", "ft_burn", "nft_transfer", "nft_mint", "nft_burn", "print"];
-type StreamsEventType = (typeof STREAMS_EVENT_TYPES)[number];
+import { StreamsEventType } from "@secondlayer/shared";
 /** A Clarity value as Streams serves it: the canonical hex string, a typed
 *  object carrying that hex (`{ hex }`), or a decoded Clarity-JSON object.
 *  Decode helpers (`decodeNftTransfer`, etc.) resolve it to a concrete value. */
@@ -1137,9 +1208,24 @@ type StreamsClient = {
 	dumps: StreamsDumps
 	canonical(height: number): Promise<StreamsCanonicalBlock>
 	tip(): Promise<StreamsTip>
+	/** Your own Streams consumption (events today + this month) and tier limits. */
+	usage(): Promise<StreamsUsage>
+};
+type StreamsUsage = {
+	product: "streams"
+	tier: string
+	limits: {
+		rate_limit_per_second: number | null
+		retention_days: number | null
+	}
+	usage: {
+		events_today: number
+		events_this_month: number
+	}
 };
 import { CreateSubscriptionRequest, CreateSubscriptionResponse, DeadRow, DeliveryRow, ReplayResult, RotateSecretResponse, SubscriptionDetail, SubscriptionSummary, UpdateSubscriptionRequest } from "@secondlayer/shared/schemas/subscriptions";
-import { CreateSubscriptionRequest as CreateSubscriptionRequest2, CreateSubscriptionResponse as CreateSubscriptionResponse2, DeadRow as DeadRow2, DeliveryRow as DeliveryRow2, ReplayResult as ReplayResult2, RotateSecretResponse as RotateSecretResponse2, SubscriptionDetail as SubscriptionDetail2, SubscriptionFormat, SubscriptionRuntime, SubscriptionStatus, SubscriptionSummary as SubscriptionSummary2, UpdateSubscriptionRequest as UpdateSubscriptionRequest2 } from "@secondlayer/shared/schemas/subscriptions";
+import { ChainTrigger, ChainTriggerType, CreateSubscriptionRequest as CreateSubscriptionRequest2, CreateSubscriptionResponse as CreateSubscriptionResponse2, DeadRow as DeadRow2, DeliveryRow as DeliveryRow2, ReplayResult as ReplayResult2, RotateSecretResponse as RotateSecretResponse2, SubscriptionDetail as SubscriptionDetail2, SubscriptionFormat, SubscriptionKind, SubscriptionRuntime, SubscriptionStatus, SubscriptionSummary as SubscriptionSummary2, UpdateSubscriptionRequest as UpdateSubscriptionRequest2 } from "@secondlayer/shared/schemas/subscriptions";
+import { trigger } from "@secondlayer/shared/schemas/subscriptions";
 declare class Subscriptions extends BaseClient {
 	list(): Promise<{
 		data: SubscriptionSummary[]
@@ -1167,6 +1253,34 @@ declare class Subscriptions extends BaseClient {
 		ok: true
 	}>;
 }
+interface ContextAccount {
+	email: string;
+	plan: string;
+}
+interface ActiveSubgraphOperation {
+	subgraph: string;
+	operationId: string;
+	kind: SubgraphOperationStatus["kind"];
+	status: SubgraphOperationStatus["status"];
+	progress: number | null;
+}
+/**
+* A point-in-time orientation snapshot for an agent: who you are, the live tips,
+* and what you own. Each field is `null` when it couldn't be read (e.g. no key,
+* or a free-tier key for a Build+ surface) so the snapshot never throws.
+*/
+interface ContextSnapshot {
+	account: ContextAccount | null;
+	streamsTip: StreamsTip | null;
+	indexTip: IndexTip | null;
+	subgraphs: SubgraphSummary2[] | null;
+	subscriptions: {
+		count: number
+		byStatus: Record<string, number>
+	} | null;
+	/** In-flight reindex operations (bounded to subgraphs reporting `reindexing`). */
+	activeOperations: ActiveSubgraphOperation[] | null;
+}
 declare class SecondLayer extends BaseClient {
 	readonly streams: StreamsClient;
 	readonly index: Index;
@@ -1174,7 +1288,14 @@ declare class SecondLayer extends BaseClient {
 	readonly contracts: Contracts;
 	readonly subgraphs: Subgraphs;
 	readonly subscriptions: Subscriptions;
+	readonly apiKeys: ApiKeys;
 	constructor(options?: Partial<SecondLayerOptions>);
+	/**
+	* Assemble a {@link ContextSnapshot} — the same orientation an MCP agent reads
+	* from `secondlayer://context`, but available to any SDK/CLI consumer. Reads
+	* run concurrently and degrade to `null` per field on failure.
+	*/
+	context(): Promise<ContextSnapshot>;
 }
 /**
 * Returns a typed client for a subgraph defined with `defineSubgraph()`.
@@ -1624,4 +1745,4 @@ declare function toJsonSafe(value: unknown): unknown;
 /** Decode a hex-encoded Clarity value to JSON-safe JS (uints as strings,
 *  buffers as `0x…` hex, tuples as objects). Returns the input hex on failure. */
 declare function decodeClarityValue(hex: string): unknown;
-export { verifyWebhookSignature, toJsonSafe, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, TransactionsWalkParams, TransactionsListParams, TransactionsEnvelope, TransactionEnvelope, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, StackingWalkParams, StackingListParams, StackingEnvelope, SecondLayerOptions, SecondLayer, RotateSecretResponse2 as RotateSecretResponse, ReplayResult2 as ReplayResult, RateLimitError, Pox4CallsParams, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, MempoolWalkParams, MempoolTransactionEnvelope, MempoolListParams, MempoolEnvelope, IndexTransaction, IndexTip, IndexStackingAction, IndexPostCondition, IndexMempoolTransaction, IndexEventType, IndexEvent, IndexContractCall, IndexCanonicalBlock, IndexBlock, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, Datasets, DatasetRow, CursorListParams, CursorEnvelope, Cursor, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, ContractsListParams, ContractsEnvelope, Contracts, ContractSummary, ContractConformance, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, CanonicalWalkParams, CanonicalListParams, CanonicalEnvelope, CURSOR_SLUGS, BlocksWalkParams, BlocksListParams, BlocksEnvelope, BlockEnvelope, AuthError, ApiError };
+export { verifyWebhookSignature, trigger, toJsonSafe, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, TransactionsWalkParams, TransactionsListParams, TransactionsEnvelope, TransactionEnvelope, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionKind, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphOperationStatus, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsUsage, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, StackingWalkParams, StackingListParams, StackingEnvelope, SecondLayerOptions, SecondLayer, ScopedKeyProduct, RotateSecretResponse2 as RotateSecretResponse, ReplayResult2 as ReplayResult, RateLimitError, Pox4CallsParams, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, MempoolWalkParams, MempoolTransactionEnvelope, MempoolListParams, MempoolEnvelope, IndexUsage, IndexTransaction, IndexTip, IndexStackingAction, IndexPostCondition, IndexMempoolTransaction, IndexEventType, IndexEvent, IndexContractCall, IndexCanonicalBlock, IndexBlock, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, Datasets, DatasetRow, CursorListParams, CursorEnvelope, Cursor, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, CreateApiKeyResponse, CreateApiKeyParams, ContractsListParams, ContractsEnvelope, Contracts, ContractSummary, ContractConformance, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, ContextSnapshot, ContextAccount, ChainTriggerType, ChainTrigger, CanonicalWalkParams, CanonicalListParams, CanonicalEnvelope, CURSOR_SLUGS, BlocksWalkParams, BlocksListParams, BlocksEnvelope, BlockEnvelope, AuthError, ApiKeys, ApiError, ActiveSubgraphOperation };

package/dist/index.js

@@ -242,6 +242,12 @@ class Subgraphs extends BaseClient {
     const qs = options?.force ? "?force=true" : "";
     return this.request("DELETE", `/api/subgraphs/${name}${qs}`);
   }
+  async operations(name) {
+    return this.request("GET", `/api/subgraphs/${name}/operations`);
+  }
+  async getOperation(name, operationId) {
+    return this.request("GET", `/api/subgraphs/${name}/operations/${operationId}`);
+  }
   async deploy(data) {
     return this.request("POST", "/api/subgraphs", data);
   }
@@ -324,6 +330,19 @@ class Subgraphs extends BaseClient {
     };
   }
 }
+// src/api-keys/client.ts
+class ApiKeys extends BaseClient {
+  constructor(options = {}) {
+    super(options);
+  }
+  create(params = {}) {
+    return this.request("POST", "/v1/api-keys", {
+      product: params.product,
+      name: params.name
+    });
+  }
+}
+
 // src/contracts/client.ts
 class Contracts extends BaseClient {
   constructor(options = {}) {
@@ -473,6 +492,9 @@ class Index extends BaseClient {
   constructor(options = {}) {
     super(options);
   }
+  usage() {
+    return this.request("GET", "/v1/index/usage");
+  }
   ftTransfers = {
     list: (params = {}) => this.listFtTransfers(params),
     walk: (params = {}) => this.walkFtTransfers(params)
@@ -1331,12 +1353,15 @@ function createStreamsClient(options) {
     },
     tip() {
       return request("/v1/streams/tip");
+    },
+    usage() {
+      return request("/v1/streams/usage");
     }
   };
 }
 
 // src/subscriptions/client.ts
-import { on } from "@secondlayer/shared/schemas/subscriptions";
+import { trigger } from "@secondlayer/shared/schemas/subscriptions";
 
 class Subscriptions extends BaseClient {
   async list() {
@@ -1385,6 +1410,7 @@ class SecondLayer extends BaseClient {
   contracts;
   subgraphs;
   subscriptions;
+  apiKeys;
   constructor(options = {}) {
     super(options);
     this.streams = createStreamsClient({
@@ -1397,6 +1423,49 @@ class SecondLayer extends BaseClient {
     this.contracts = new Contracts(options);
     this.subgraphs = new Subgraphs(options);
     this.subscriptions = new Subscriptions(options);
+    this.apiKeys = new ApiKeys(options);
+  }
+  async context() {
+    const safe = (p) => p.then((v) => v).catch(() => null);
+    const [account, streamsTip, indexEnv, subgraphsRes, subscriptionsRes] = await Promise.all([
+      safe(this.request("GET", "/api/accounts/me")),
+      safe(this.streams.tip()),
+      safe(this.index.canonical.list({ limit: 1 })),
+      safe(this.subgraphs.list()),
+      safe(this.subscriptions.list())
+    ]);
+    const subgraphs = subgraphsRes?.data ?? null;
+    let subscriptions = null;
+    if (subscriptionsRes) {
+      const byStatus = {};
+      for (const s of subscriptionsRes.data) {
+        byStatus[s.status] = (byStatus[s.status] ?? 0) + 1;
+      }
+      subscriptions = { count: subscriptionsRes.data.length, byStatus };
+    }
+    let activeOperations = null;
+    if (subgraphs) {
+      const probed = await Promise.all(subgraphs.filter((s) => s.status === "reindexing").map(async (s) => {
+        const res = await safe(this.subgraphs.operations(s.name));
+        const op = res?.operations.find((o) => o.status === "queued" || o.status === "running");
+        return op ? {
+          subgraph: s.name,
+          operationId: op.id,
+          kind: op.kind,
+          status: op.status,
+          progress: op.progress
+        } : null;
+      }));
+      activeOperations = probed.filter((o) => o !== null);
+    }
+    return {
+      account,
+      streamsTip,
+      indexTip: indexEnv?.tip ?? null,
+      subgraphs,
+      subscriptions,
+      activeOperations
+    };
   }
 }
 
@@ -1690,19 +1759,9 @@ function decodePrint(event) {
   });
 }
 // src/streams/types.ts
-var STREAMS_EVENT_TYPES = [
-  "stx_transfer",
-  "stx_mint",
-  "stx_burn",
-  "stx_lock",
-  "ft_transfer",
-  "ft_mint",
-  "ft_burn",
-  "nft_transfer",
-  "nft_mint",
-  "nft_burn",
-  "print"
-];
+import {
+  STREAMS_EVENT_TYPES
+} from "@secondlayer/shared";
 // src/webhooks.ts
 import {
   verify
@@ -1748,6 +1807,7 @@ function verifyWebhookSignature(rawBody, headers, secret, toleranceSeconds = 300
 }
 export {
   verifyWebhookSignature,
+  trigger,
   toJsonSafe,
   isStxTransfer,
   isStxMint,
@@ -1788,8 +1848,9 @@ export {
   Contracts,
   CURSOR_SLUGS,
   AuthError,
+  ApiKeys,
   ApiError
 };
 
-//# debugId=C09FB8EE7112FE4664756E2164756E21
+//# debugId=209F8CDE1560C10F64756E2164756E21
 //# sourceMappingURL=index.js.map