@secondlayer/sdk 6.19.0 → 6.21.0

package/dist/subgraphs/index.d.ts

@@ -52,6 +52,16 @@ interface SubgraphOperationStatus {
 	createdAt: string;
 	updatedAt: string;
 }
+/** /v1 cursor envelope for subgraph table reads. */
+interface SubgraphRowsEnvelope<T = unknown> {
+	rows: T[];
+	next_cursor: string | null;
+	tip: {
+		block_height: number
+		subgraph_height: number
+		blocks_behind: number
+	};
+}
 interface BundleSubgraphResponse {
 	ok: true;
 	name: string;
@@ -94,6 +104,29 @@ declare class Subgraphs extends BaseClient {
 	}): Promise<{
 		message: string
 	}>;
+	/**
+	* Publish: claim the name in the global public namespace and open anon
+	* reads on /v1/subgraphs/:name. 409 PUBLIC_NAME_TAKEN if another account
+	* holds the public name.
+	*/
+	publish(name: string): Promise<{
+		name: string
+		visibility: "public"
+		url: string
+	}>;
+	/** Make reads private again (owning account's bearer key required). */
+	unpublish(name: string): Promise<{
+		name: string
+		visibility: "private"
+	}>;
+	/**
+	* Open /v1 read: cursor-paginated rows. Anon works for public subgraphs;
+	* pass an apiKey on the client for private ones. Resume with the returned
+	* `next_cursor`.
+	*/
+	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
+		cursor?: string
+	}): Promise<SubgraphRowsEnvelope<T>>;
 	/** Recent reindex/backfill operations for a subgraph, newest first. */
 	operations(name: string): Promise<{
 		operations: SubgraphOperationStatus[]
@@ -240,150 +273,6 @@ declare class Contracts extends BaseClient {
 		includeAbi?: boolean
 	}): Promise<ContractSummary | null>;
 }
-/**
-* Typed client for the Foundation Datasets REST API (`/v1/datasets/*`).
-*
-* Most datasets are cursor-paginated event lists with a uniform `list`/`walk`
-* surface; a few (bns names/namespaces/resolve, network-health) are
-* offset/single-object/summary and get bespoke methods. Query params are typed
-* per dataset; rows are `DatasetRow` (JSON) in v1 — per-dataset row interfaces
-* are a fast-follow.
-*/
-/** A dataset row — flat JSON object. Per-dataset interfaces are a follow-up. */
-type DatasetRow = Record<string, unknown>;
-/** Filters shared by every cursor-paginated dataset. */
-interface CursorListParams {
-	cursor?: string;
-	limit?: number;
-	fromBlock?: number;
-	toBlock?: number;
-}
-interface CursorEnvelope {
-	rows: DatasetRow[];
-	next_cursor: string | null;
-	tip?: {
-		block_height: number
-	};
-}
-type RangeFilters = CursorListParams;
-type StxTransfersParams = RangeFilters & {
-	sender?: string
-	recipient?: string
-};
-type SbtcEventsParams = RangeFilters & {
-	topic?: string
-	address?: string
-};
-type SbtcTokenEventsParams = RangeFilters & {
-	eventType?: string
-	sender?: string
-	recipient?: string
-};
-type Pox4CallsParams = RangeFilters & {
-	functionName?: string
-	stacker?: string
-	delegateTo?: string
-	signerKey?: string
-	rewardCycle?: number
-	/** Any-role: matches caller OR stacker OR delegate_to. */
-	address?: string
-};
-type BurnchainRewardsParams = RangeFilters & {
-	/** Filter to one Bitcoin reward address. */
-	recipient?: string
-};
-type BurnchainRewardSlotsParams = RangeFilters & {
-	/** Filter to one reward-set Bitcoin address. */
-	holder?: string
-};
-type BnsEventsParams = RangeFilters & {
-	topic?: string
-	namespace?: string
-	name?: string
-	owner?: string
-};
-type BnsNamespaceEventsParams = RangeFilters & {
-	status?: string
-	namespace?: string
-};
-type BnsMarketplaceEventsParams = RangeFilters & {
-	action?: string
-	bnsId?: string
-};
-type CursorDataset<P> = {
-	list: (params?: P) => Promise<CursorEnvelope>
-	walk: (params?: P & {
-		batchSize?: number
-		signal?: AbortSignal
-	}) => AsyncIterable<DatasetRow>
-};
-declare class Datasets extends BaseClient {
-	private catalogPromise?;
-	constructor(options?: Partial<SecondLayerOptions>);
-	/** Dataset catalog + freshness (the discovery endpoint). */
-	listDatasets(): Promise<unknown>;
-	/**
-	* Generic read by slug for ANY catalog dataset — cursor or bespoke. Resolves
-	* the slug against the live `/v1/datasets` catalog (so datasets added
-	* server-side work with no SDK change), issues the GET, and normalizes the
-	* response into a uniform `{ rows, next_cursor, tip }` envelope. Single-object
-	* datasets (bns/resolve, network-health/summary) come back as 0-or-1 rows.
-	* Accepts both family (`sbtc-events`) and path (`sbtc/events`) slug forms.
-	* Prefer this over {@link query} unless you specifically need cursor-only
-	* semantics.
-	*/
-	get(slug: string, params?: Record<string, unknown>): Promise<CursorEnvelope>;
-	/**
-	* Generic cursor query by slug — used by the CLI. Params are passed through as
-	* REST query keys (snake_case), so callers can use the documented filter names
-	* directly. Throws for non-cursor (bespoke) datasets — use {@link get} for
-	* those (and for slugs added to the catalog after this SDK was built).
-	*/
-	query(slug: string, params?: Record<string, unknown>): Promise<CursorEnvelope>;
-	readonly stxTransfers: CursorDataset<StxTransfersParams>;
-	readonly sbtcEvents: CursorDataset<SbtcEventsParams>;
-	readonly sbtcTokenEvents: CursorDataset<SbtcTokenEventsParams>;
-	readonly pox4Calls: CursorDataset<Pox4CallsParams>;
-	readonly burnchainRewards: CursorDataset<BurnchainRewardsParams>;
-	readonly burnchainRewardSlots: CursorDataset<BurnchainRewardSlotsParams>;
-	readonly bnsEvents: CursorDataset<BnsEventsParams>;
-	readonly bnsNamespaceEvents: CursorDataset<BnsNamespaceEventsParams>;
-	readonly bnsMarketplaceEvents: CursorDataset<BnsMarketplaceEventsParams>;
-	/** BNS names — offset-paginated. */
-	bnsNames(params?: {
-		namespace?: string
-		owner?: string
-		limit?: number
-		offset?: number
-	}): Promise<{
-		names: DatasetRow[]
-	}>;
-	/** All BNS namespaces (no pagination). */
-	bnsNamespaces(): Promise<{
-		namespaces: DatasetRow[]
-	}>;
-	/** Resolve a fully-qualified BNS name → single record. */
-	bnsResolve(fqn: string): Promise<{
-		name: DatasetRow | null
-	}>;
-	/** Network health summary. */
-	networkHealth(): Promise<{
-		summary: DatasetRow
-	}>;
-	private requestPath;
-	/** Resolve a slug → relative path + row key. Known cursor slugs take a
-	*  network-free fast path; anything else is matched against the live catalog
-	*  by family name or path tail. */
-	private resolveDataset;
-	/** Fetch + cache the catalog families. Caches the in-flight promise so
-	*  concurrent first-calls share one request; no TTL — agent sessions are
-	*  short-lived, and a new client picks up newly added datasets. */
-	private loadCatalog;
-	/** Map camelCase filter fields to snake_case query keys (dropping pagination
-	*  controls) and build the canonical query suffix. */
-	private paramsToQuery;
-	private cursorDataset;
-}
 import { RewardSet } from "@secondlayer/shared/node/consensus";
 import { MerkleProofStep } from "@secondlayer/shared/node/nakamoto";
 /**
@@ -920,6 +809,30 @@ type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
 	batchSize?: number
 	signal?: AbortSignal
 };
+/**
+* `index.ftTransfers` — callable shorthand for `.list()`, with `.list`/`.walk`
+* still available: `await sl.index.ftTransfers({ contractId })`.
+*
+* The API accepts `contract_id`/`sender`/`recipient` equality filters only —
+* no amount filtering and no asset-slug resolution on /v1/index/ft-transfers.
+*/
+interface FtTransfersResource {
+	(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
+	list(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
+	walk(params?: FtTransfersWalkParams): AsyncIterable<FtTransfer>;
+}
+/** `index.nftTransfers` — callable shorthand for `.list()` (see {@link FtTransfersResource}). */
+interface NftTransfersResource {
+	(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
+	list(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
+	walk(params?: NftTransfersWalkParams): AsyncIterable<NftTransfer>;
+}
+/** `index.events` — callable shorthand for `.list()`; `eventType` is required. */
+interface IndexEventsResource {
+	(params: EventsListParams): Promise<EventsEnvelope>;
+	list(params: EventsListParams): Promise<EventsEnvelope>;
+	walk(params: EventsWalkParams): AsyncIterable<IndexEvent>;
+}
 /** Per-event-type filter vocabulary in the {@link IndexDiscovery} doc. */
 type IndexEventTypeFilters = {
 	columns?: string[]
@@ -944,19 +857,13 @@ declare class Index extends BaseClient {
 	* learn what's queryable (and which types accept `trait`) instead of hardcoding.
 	*/
 	discover(): Promise<IndexDiscovery>;
-	readonly ftTransfers: {
-		list: (params?: FtTransfersListParams) => Promise<FtTransfersEnvelope>
-		walk: (params?: FtTransfersWalkParams) => AsyncIterable<FtTransfer>
-	};
-	readonly nftTransfers: {
-		list: (params?: NftTransfersListParams) => Promise<NftTransfersEnvelope>
-		walk: (params?: NftTransfersWalkParams) => AsyncIterable<NftTransfer>
-	};
-	/** Generic decoded events by `event_type` (the full /v1/index/events surface). */
-	readonly events: {
-		list: (params: EventsListParams) => Promise<EventsEnvelope>
-		walk: (params: EventsWalkParams) => AsyncIterable<IndexEvent>
-	};
+	/** Callable: `index.ftTransfers(params)` ≡ `index.ftTransfers.list(params)`. */
+	readonly ftTransfers: FtTransfersResource;
+	/** Callable: `index.nftTransfers(params)` ≡ `index.nftTransfers.list(params)`. */
+	readonly nftTransfers: NftTransfersResource;
+	/** Generic decoded events by `event_type` (the full /v1/index/events surface).
+	*  Callable: `index.events(params)` ≡ `index.events.list(params)`. */
+	readonly events: IndexEventsResource;
 	readonly contractCalls: {
 		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
 		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
@@ -1338,6 +1245,36 @@ type StreamsEventsConsumeParams = {
 	maxEmptyPolls?: number
 	signal?: AbortSignal
 };
+/**
+* One yielded page from {@link StreamsClient.consume} — the
+* `GET /v1/streams/events` envelope verbatim, with `next_cursor` renamed to
+* `cursor` (the checkpoint to persist and resume from).
+*/
+type StreamsBatch = {
+	/** Canonical events of this page, in cursor order. */
+	events: StreamsEvent[]
+	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
+	cursor: string | null
+	tip: StreamsTip
+	/** Chain reorgs reported alongside this page; empty when none. */
+	reorgs: StreamsReorg[]
+};
+type StreamsConsumeParams = {
+	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
+	cursor?: string | null
+	types?: readonly StreamsEventType[]
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
+	/** Events per page (the `limit` query param). Default 100. */
+	batchSize?: number
+	/** Poll interval while caught up at the tip, in ms. Default 2000. */
+	intervalMs?: number
+	/** Abort to end the iteration. */
+	signal?: AbortSignal
+};
 type StreamsEventsConsumeResult = {
 	cursor: string | null
 	pages: number
@@ -1405,6 +1342,21 @@ type StreamsDumps = {
 	download(file: StreamsDumpFile): Promise<Uint8Array>
 };
 type StreamsClient = {
+	/**
+	* Follow Streams as an async iterator of page batches.
+	*
+	* Yields one {@link StreamsBatch} per `GET /v1/streams/events` page — the
+	* existing envelope (`events`, `next_cursor` → `cursor`, `tip`, `reorgs`)
+	* with zero extra API calls. Batches are chosen over per-block groupings
+	* because the envelope is page-keyed, so every yield is exactly one fetch.
+	* Empty pages are skipped; at the tip the iterator re-polls every
+	* `intervalMs` (default 2000) until aborted via `signal`.
+	*
+	* Reorgs are surfaced on the batch (`batch.reorgs`) but the cursor is not
+	* rewound automatically — use `events.consume` with `onReorg` for managed
+	* rollback semantics.
+	*/
+	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
 	events: {
 		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
 		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
@@ -1547,7 +1499,6 @@ interface ContextSnapshot {
 declare class SecondLayer extends BaseClient {
 	readonly streams: StreamsClient;
 	readonly index: Index;
-	readonly datasets: Datasets;
 	readonly contracts: Contracts;
 	readonly subgraphs: Subgraphs;
 	readonly subscriptions: Subscriptions;
@@ -1559,6 +1510,21 @@ declare class SecondLayer extends BaseClient {
 	* from `secondlayer://context`, but available to any SDK/CLI consumer. Reads
 	* run concurrently and degrade to `null` per field on failure.
 	*/
+	/**
+	* Up to 10 public reads in one round trip (`POST /v1/batch`). Each item
+	* keeps its own auth/quota/x402 semantics; forwarded credentials (API key,
+	* PAYMENT-BALANCE/SESSION) apply to every item.
+	*/
+	batch(requests: Array<{
+		path: string
+		params?: Record<string, string | number | boolean>
+	}>): Promise<{
+		results: Array<{
+			path: string | null
+			status: number
+			body: unknown
+		}>
+	}>;
 	context(): Promise<ContextSnapshot>;
 }
 /**

package/dist/subgraphs/index.js

@@ -281,6 +281,19 @@ class Subgraphs extends BaseClient {
     const qs = options?.force ? "?force=true" : "";
     return this.request("DELETE", `/api/subgraphs/${name}${qs}`);
   }
+  async publish(name) {
+    return this.request("POST", `/api/subgraphs/${name}/publish`);
+  }
+  async unpublish(name) {
+    return this.request("POST", `/api/subgraphs/${name}/unpublish`);
+  }
+  async rows(name, table, params = {}) {
+    const { cursor, ...rest } = params;
+    const qs = buildSubgraphQueryString(rest);
+    const sep = qs ? "&" : "?";
+    const cursorQs = cursor ? `${sep}cursor=${encodeURIComponent(cursor)}` : "";
+    return this.request("GET", `/v1/subgraphs/${name}/${table}${qs}${cursorQs}`);
+  }
   async operations(name) {
     return this.request("GET", `/api/subgraphs/${name}/operations`);
   }
@@ -429,164 +442,6 @@ class Contracts extends BaseClient {
   }
 }
 
-// src/datasets/client.ts
-var PARAM_KEYS = {
-  fromBlock: "from_block",
-  toBlock: "to_block",
-  functionName: "function_name",
-  delegateTo: "delegate_to",
-  signerKey: "signer_key",
-  rewardCycle: "reward_cycle",
-  eventType: "event_type",
-  bnsId: "bns_id"
-};
-var CURSOR_SLUGS = {
-  "stx-transfers": { path: "stx-transfers", rowKey: "events" },
-  "sbtc-events": { path: "sbtc/events", rowKey: "events" },
-  "sbtc-token-events": { path: "sbtc/token-events", rowKey: "events" },
-  "pox-4-calls": { path: "pox-4/calls", rowKey: "calls" },
-  "burnchain-rewards": { path: "burnchain/rewards", rowKey: "rewards" },
-  "burnchain-reward-slots": {
-    path: "burnchain/reward-slots",
-    rowKey: "slots"
-  },
-  "bns-events": { path: "bns/events", rowKey: "events" },
-  "bns-namespace-events": { path: "bns/namespace-events", rowKey: "events" },
-  "bns-marketplace-events": {
-    path: "bns/marketplace-events",
-    rowKey: "events"
-  }
-};
-function catalogPathTail(path) {
-  return path.replace(/^\/?v1\/datasets\//, "").replace(/^\/+/, "");
-}
-
-class Datasets extends BaseClient {
-  catalogPromise;
-  constructor(options = {}) {
-    super(options);
-  }
-  listDatasets() {
-    return this.request("GET", "/v1/datasets");
-  }
-  async get(slug, params = {}) {
-    const { path, rowKey } = await this.resolveDataset(slug);
-    const env = await this.requestPath(path, this.paramsToQuery(params));
-    const value = env[rowKey];
-    const rows = Array.isArray(value) ? value : value == null ? [] : [value];
-    return {
-      rows,
-      next_cursor: env.next_cursor ?? null,
-      tip: env.tip
-    };
-  }
-  async query(slug, params = {}) {
-    const d = CURSOR_SLUGS[slug];
-    if (!d) {
-      throw new Error(`unknown cursor dataset "${slug}" (use one of: ${Object.keys(CURSOR_SLUGS).join(", ")})`);
-    }
-    const env = await this.requestPath(d.path, this.paramsToQuery(params));
-    return {
-      rows: env[d.rowKey] ?? [],
-      next_cursor: env.next_cursor ?? null,
-      tip: env.tip
-    };
-  }
-  stxTransfers = this.cursorDataset("stx-transfers", "events");
-  sbtcEvents = this.cursorDataset("sbtc/events", "events");
-  sbtcTokenEvents = this.cursorDataset("sbtc/token-events", "events");
-  pox4Calls = this.cursorDataset("pox-4/calls", "calls");
-  burnchainRewards = this.cursorDataset("burnchain/rewards", "rewards");
-  burnchainRewardSlots = this.cursorDataset("burnchain/reward-slots", "slots");
-  bnsEvents = this.cursorDataset("bns/events", "events");
-  bnsNamespaceEvents = this.cursorDataset("bns/namespace-events", "events");
-  bnsMarketplaceEvents = this.cursorDataset("bns/marketplace-events", "events");
-  bnsNames(params = {}) {
-    return this.requestPath("bns/names", buildQuery({
-      namespace: params.namespace,
-      owner: params.owner,
-      limit: params.limit,
-      offset: params.offset
-    }));
-  }
-  bnsNamespaces() {
-    return this.requestPath("bns/namespaces", "");
-  }
-  bnsResolve(fqn) {
-    return this.requestPath("bns/resolve", buildQuery({ fqn }));
-  }
-  networkHealth() {
-    return this.requestPath("network-health/summary", "");
-  }
-  requestPath(path, query) {
-    return this.request("GET", `/v1/datasets/${path}${query}`);
-  }
-  async resolveDataset(slug) {
-    const cursor = CURSOR_SLUGS[slug];
-    if (cursor)
-      return { path: cursor.path, rowKey: cursor.rowKey };
-    const families = await this.loadCatalog();
-    const tail = catalogPathTail(slug);
-    const match = families.find((f) => f.family === slug || catalogPathTail(f.path) === tail);
-    if (!match) {
-      throw new Error(`unknown dataset "${slug}" (available: ${families.map((f) => f.family).join(", ")})`);
-    }
-    return { path: catalogPathTail(match.path), rowKey: match.row_key };
-  }
-  loadCatalog() {
-    this.catalogPromise ??= (async () => {
-      const raw = await this.listDatasets();
-      const families = raw.families;
-      if (!Array.isArray(families)) {
-        throw new Error("dataset catalog response missing families[]");
-      }
-      return families;
-    })();
-    return this.catalogPromise;
-  }
-  paramsToQuery(params) {
-    const mapped = {};
-    for (const [k, v] of Object.entries(params)) {
-      if (v === undefined || v === null || k === "batchSize" || k === "signal")
-        continue;
-      mapped[PARAM_KEYS[k] ?? k] = v;
-    }
-    return buildQuery(mapped);
-  }
-  cursorDataset(path, rowKey) {
-    const list = async (params = {}) => {
-      const envelope = await this.requestPath(path, this.paramsToQuery(params));
-      return {
-        rows: envelope[rowKey] ?? [],
-        next_cursor: envelope.next_cursor ?? null,
-        tip: envelope.tip
-      };
-    };
-    const walk = async function* (params = {}) {
-      const batchSize = params.batchSize ?? 200;
-      let cursor = params.cursor ?? null;
-      let first = true;
-      while (!params.signal?.aborted) {
-        const env = await list({
-          ...params,
-          limit: batchSize,
-          cursor: first ? params.cursor : cursor ?? undefined
-        });
-        for (const row of env.rows) {
-          if (params.signal?.aborted)
-            return;
-          yield row;
-        }
-        if (!env.next_cursor || env.next_cursor === cursor || env.rows.length < batchSize)
-          return;
-        cursor = env.next_cursor;
-        first = false;
-      }
-    }.bind(this);
-    return { list, walk };
-  }
-}
-
 // src/index-api/client.ts
 function firstWalkFromHeight(params) {
   if (params.fromHeight !== undefined)
@@ -606,18 +461,18 @@ class Index extends BaseClient {
   discover() {
     return this.request("GET", "/v1/index");
   }
-  ftTransfers = {
+  ftTransfers = Object.assign((params = {}) => this.listFtTransfers(params), {
     list: (params = {}) => this.listFtTransfers(params),
     walk: (params = {}) => this.walkFtTransfers(params)
-  };
-  nftTransfers = {
+  });
+  nftTransfers = Object.assign((params = {}) => this.listNftTransfers(params), {
     list: (params = {}) => this.listNftTransfers(params),
     walk: (params = {}) => this.walkNftTransfers(params)
-  };
-  events = {
+  });
+  events = Object.assign((params) => this.listEvents(params), {
     list: (params) => this.listEvents(params),
     walk: (params) => this.walkEvents(params)
-  };
+  });
   contractCalls = {
     list: (params = {}) => this.listContractCalls(params),
     walk: (params = {}) => this.walkContractCalls(params)
@@ -1182,6 +1037,38 @@ async function consumeStreamsEvents(opts) {
   }
   return { cursor, pages, emptyPolls };
 }
+async function* iterateStreamsBatches(opts) {
+  const sleep = opts.sleep ?? defaultSleep;
+  let cursor = opts.fromCursor ?? null;
+  while (!opts.signal?.aborted) {
+    const envelope = await opts.fetchEvents({
+      cursor,
+      limit: opts.batchSize,
+      types: opts.types,
+      notTypes: opts.notTypes,
+      contractId: opts.contractId,
+      sender: opts.sender,
+      recipient: opts.recipient,
+      assetIdentifier: opts.assetIdentifier
+    });
+    const checkpoint = envelope.next_cursor ?? cursor;
+    if (envelope.events.length > 0 || envelope.reorgs.length > 0) {
+      yield {
+        events: envelope.events,
+        cursor: checkpoint,
+        tip: envelope.tip,
+        reorgs: envelope.reorgs
+      };
+    }
+    const advanced = checkpoint !== null && checkpoint !== cursor;
+    cursor = checkpoint;
+    if (!advanced && envelope.events.length === 0) {
+      if (opts.signal?.aborted)
+        return;
+      await sleep(opts.intervalMs, opts.signal);
+    }
+  }
+}
 async function* streamStreamsEvents(opts) {
   const sleep = opts.sleep ?? defaultSleep;
   const emptyBackoffMs = opts.emptyBackoffMs ?? 500;
@@ -1559,6 +1446,21 @@ function createStreamsClient(options) {
     })}`);
   }
   return {
+    consume(params = {}) {
+      return iterateStreamsBatches({
+        fromCursor: params.cursor,
+        batchSize: params.batchSize ?? 100,
+        intervalMs: params.intervalMs ?? 2000,
+        types: params.types,
+        notTypes: params.notTypes,
+        contractId: params.contractId,
+        sender: params.sender,
+        recipient: params.recipient,
+        assetIdentifier: params.assetIdentifier,
+        signal: params.signal,
+        fetchEvents
+      });
+    },
     events: {
       list: listEvents,
       byTxId(txId) {
@@ -1711,7 +1613,6 @@ class Subscriptions extends BaseClient {
 class SecondLayer extends BaseClient {
   streams;
   index;
-  datasets;
   contracts;
   subgraphs;
   subscriptions;
@@ -1726,13 +1627,15 @@ class SecondLayer extends BaseClient {
       dumpsBaseUrl: options.dumpsBaseUrl
     });
     this.index = new Index(options);
-    this.datasets = new Datasets(options);
     this.contracts = new Contracts(options);
     this.subgraphs = new Subgraphs(options);
     this.subscriptions = new Subscriptions(options);
     this.apiKeys = new ApiKeys(options);
     this.projects = new Projects(options);
   }
+  async batch(requests) {
+    return this.request("POST", "/v1/batch", { requests });
+  }
   async context() {
     const safe = (p) => p.then((v) => v).catch(() => null);
     const [
@@ -1815,5 +1718,5 @@ export {
   Subgraphs
 };
 
-//# debugId=7ABB6E8514AEA9F664756E2164756E21
+//# debugId=0E36F58DBAA5692064756E2164756E21
 //# sourceMappingURL=index.js.map