@secondlayer/sdk 6.0.0 → 6.2.0

package/dist/streams/index.js

@@ -1,7 +1,205 @@
 // src/streams/client.ts
 import { ed25519 } from "@secondlayer/shared";
 
+// src/errors.ts
+class ApiError extends Error {
+  status;
+  body;
+  code;
+  constructor(status, message, body, code) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.code = code;
+    this.name = "ApiError";
+  }
+}
+
+class VersionConflictError extends ApiError {
+  currentVersion;
+  expectedVersion;
+  constructor(currentVersion, expectedVersion, message = `Version conflict: expected ${expectedVersion}, current ${currentVersion}`) {
+    super(409, message, { currentVersion, expectedVersion });
+    this.currentVersion = currentVersion;
+    this.expectedVersion = expectedVersion;
+    this.name = "VersionConflictError";
+  }
+}
+
+// src/base.ts
+var DEFAULT_BASE_URL = "https://api.secondlayer.tools";
+function buildQuery(params) {
+  const search = new URLSearchParams;
+  for (const [name, value] of Object.entries(params)) {
+    if (value === undefined || value === null)
+      continue;
+    const serialized = Array.isArray(value) ? value.join(",") : String(value);
+    if (serialized.length === 0)
+      continue;
+    search.set(name, serialized);
+  }
+  const query = search.toString();
+  return query ? `?${query}` : "";
+}
+
+class BaseClient {
+  baseUrl;
+  apiKey;
+  origin;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.origin = options.origin ?? "cli";
+  }
+  static authHeaders(apiKey) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+    return headers;
+  }
+  async request(method, path, body) {
+    const response = await this.fetchResponse(method, path, body);
+    if (response.status === 204) {
+      return;
+    }
+    return response.json();
+  }
+  async requestText(method, path, body) {
+    const response = await this.fetchResponse(method, path, body);
+    return response.text();
+  }
+  async fetchResponse(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = BaseClient.authHeaders(this.apiKey);
+    headers["x-sl-origin"] = this.origin;
+    let serializedBody;
+    if (body !== undefined && body !== null) {
+      try {
+        serializedBody = JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new ApiError(0, `Failed to serialize request body: ${detail}`);
+      }
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: serializedBody
+      });
+    } catch {
+      throw new ApiError(0, `Cannot reach API at ${this.baseUrl}. Check your connection or try again.`);
+    }
+    if (!response.ok) {
+      if (response.status === 401) {
+        throw new ApiError(401, "API key invalid or expired.");
+      }
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        const msg = retryAfter ? `Rate limited. Wait ${retryAfter} seconds.` : "Rate limited. Try again later.";
+        throw new ApiError(429, msg);
+      }
+      if (response.status >= 500) {
+        throw new ApiError(response.status, `Server error. Try again or check status at ${this.baseUrl}/health`);
+      }
+      const errorBody = await response.text();
+      let message = `HTTP ${response.status}`;
+      let parsedBody = errorBody;
+      let code;
+      try {
+        const json = JSON.parse(errorBody);
+        parsedBody = json;
+        const err = json.error ?? json.message;
+        if (typeof err === "string") {
+          message = err;
+        } else if (err && typeof err === "object") {
+          message = JSON.stringify(err);
+        }
+        if (typeof json.code === "string") {
+          code = json.code;
+        }
+      } catch {
+        if (errorBody)
+          message = errorBody;
+      }
+      throw new ApiError(response.status, message, parsedBody, code);
+    }
+    return response;
+  }
+}
+
+// src/streams/errors.ts
+class AuthError extends Error {
+  status = 401;
+  constructor(message = "API key invalid or expired.") {
+    super(message);
+    this.name = "AuthError";
+  }
+}
+
+class RateLimitError extends Error {
+  retryAfter;
+  status = 429;
+  constructor(message = "Rate limited. Try again later.", retryAfter) {
+    super(message);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+}
+
+class ValidationError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ValidationError";
+  }
+}
+
+class StreamsServerError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "StreamsServerError";
+  }
+}
+
+class StreamsSignatureError extends Error {
+  constructor(message = "Streams response signature verification failed.") {
+    super(message);
+    this.name = "StreamsSignatureError";
+  }
+}
+
+// src/streams/cursor.ts
+var Cursor = {
+  atHeight(height) {
+    return `${height}:0`;
+  },
+  parse(cursor) {
+    const parts = cursor.split(":");
+    const blockHeight = Number(parts[0]);
+    const eventIndex = Number(parts[1]);
+    if (parts.length !== 2 || !Number.isInteger(blockHeight) || !Number.isInteger(eventIndex)) {
+      throw new ValidationError(`Invalid stream cursor "${cursor}"; expected "<block>:<index>" (e.g. "951475:3").`, 400);
+    }
+    return { blockHeight, eventIndex };
+  }
+};
+
 // src/streams/consumer.ts
+function reorgKey(reorg) {
+  return `${reorg.detected_at}|${reorg.fork_point_height}|${reorg.new_canonical_tip}`;
+}
 async function defaultSleep(ms, signal) {
   if (signal?.aborted)
     return;
@@ -18,10 +216,12 @@ async function defaultSleep(ms, signal) {
 async function consumeStreamsEvents(opts) {
   const sleep = opts.sleep ?? defaultSleep;
   const mode = opts.mode ?? "tail";
+  const finalizedOnly = opts.finalizedOnly ?? false;
   const emptyBackoffMs = opts.emptyBackoffMs ?? 500;
   const maxPages = opts.maxPages ?? Number.POSITIVE_INFINITY;
   const maxEmptyPolls = opts.maxEmptyPolls ?? Number.POSITIVE_INFINITY;
   let cursor = opts.fromCursor ?? null;
+  const handledReorgs = new Set;
   let pages = 0;
   let emptyPolls = 0;
   while (pages < maxPages && emptyPolls < maxEmptyPolls && !opts.signal?.aborted) {
@@ -36,14 +236,32 @@ async function consumeStreamsEvents(opts) {
       assetIdentifier: opts.assetIdentifier
     });
     pages++;
-    const returnedCursor = await opts.onBatch(envelope.events, envelope);
-    const nextCursor = returnedCursor ?? envelope.next_cursor;
+    if (!finalizedOnly && opts.onReorg) {
+      const fresh = envelope.reorgs.filter((reorg) => !handledReorgs.has(reorgKey(reorg))).sort((a, b) => a.fork_point_height - b.fork_point_height);
+      if (fresh.length > 0) {
+        const forkPoint = Math.min(...fresh.map((reorg) => reorg.fork_point_height));
+        const rewind = Cursor.atHeight(forkPoint);
+        for (const reorg of fresh) {
+          await opts.onReorg(reorg, { cursor: rewind });
+          handledReorgs.add(reorgKey(reorg));
+        }
+        cursor = rewind;
+        emptyPolls = 0;
+        continue;
+      }
+    }
+    const emitted = finalizedOnly ? envelope.events.filter((event) => event.finalized) : envelope.events;
+    const checkpoint = finalizedOnly ? emitted.at(-1)?.cursor ?? cursor : envelope.next_cursor;
+    const returnedCursor = await opts.onBatch(emitted, envelope, {
+      cursor: checkpoint
+    });
+    const nextCursor = returnedCursor ?? checkpoint;
     if (nextCursor && nextCursor !== cursor) {
       cursor = nextCursor;
       emptyPolls = 0;
       continue;
     }
-    if (envelope.events.length === 0) {
+    if (emitted.length === 0) {
       emptyPolls++;
       if (mode === "bounded") {
         return { cursor, pages, emptyPolls };
@@ -99,56 +317,6 @@ async function* streamStreamsEvents(opts) {
 
 // src/streams/dumps.ts
 import { createHash } from "node:crypto";
-
-// src/streams/errors.ts
-class AuthError extends Error {
-  status = 401;
-  constructor(message = "API key invalid or expired.") {
-    super(message);
-    this.name = "AuthError";
-  }
-}
-
-class RateLimitError extends Error {
-  retryAfter;
-  status = 429;
-  constructor(message = "Rate limited. Try again later.", retryAfter) {
-    super(message);
-    this.retryAfter = retryAfter;
-    this.name = "RateLimitError";
-  }
-}
-
-class ValidationError extends Error {
-  status;
-  body;
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "ValidationError";
-  }
-}
-
-class StreamsServerError extends Error {
-  status;
-  body;
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "StreamsServerError";
-  }
-}
-
-class StreamsSignatureError extends Error {
-  constructor(message = "Streams response signature verification failed.") {
-    super(message);
-    this.name = "StreamsSignatureError";
-  }
-}
-
-// src/streams/dumps.ts
 function createStreamsDumps(opts) {
   const baseUrl = opts.baseUrl?.replace(/\/+$/, "");
   function requireBaseUrl() {
@@ -187,8 +355,12 @@ function createStreamsDumps(opts) {
 function cursorTuple(cursor) {
   if (!cursor)
     return [-1, -1];
-  const [block, index] = cursor.split(":");
-  return [Number(block), Number(index)];
+  const parts = cursor.split(":");
+  const [block, index] = parts.map(Number);
+  if (parts.length !== 2 || !Number.isInteger(block) || !Number.isInteger(index)) {
+    throw new ValidationError(`Invalid stream cursor "${cursor}"; expected "<block>:<index>" (e.g. "951475:3").`, 400);
+  }
+  return [block, index];
 }
 function maxCursor(a, b) {
   const [ah, ai] = cursorTuple(a);
@@ -199,18 +371,6 @@ var DEFAULT_STREAMS_BASE_URL = "https://api.secondlayer.tools";
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
 }
-function appendSearchParam(params, name, value) {
-  if (value === undefined || value === null)
-    return;
-  params.set(name, String(value));
-}
-function appendListParam(params, name, value) {
-  if (value === undefined || value === null)
-    return;
-  const joined = Array.isArray(value) ? value.join(",") : value;
-  if (joined.length > 0)
-    params.set(name, joined);
-}
 async function responseBody(response) {
   const text = await response.text();
   if (text.length === 0)
@@ -332,23 +492,18 @@ function createStreamsClient(options) {
     });
   };
   async function listEvents(params = {}) {
-    const searchParams = new URLSearchParams;
-    appendSearchParam(searchParams, "cursor", params.cursor);
-    appendSearchParam(searchParams, "from_height", params.fromHeight);
-    appendSearchParam(searchParams, "to_height", params.toHeight);
-    appendSearchParam(searchParams, "limit", params.limit);
-    appendListParam(searchParams, "contract_id", params.contractId);
-    appendListParam(searchParams, "sender", params.sender);
-    appendListParam(searchParams, "recipient", params.recipient);
-    appendSearchParam(searchParams, "asset_identifier", params.assetIdentifier);
-    if (params.types?.length) {
-      searchParams.set("types", params.types.join(","));
-    }
-    if (params.notTypes?.length) {
-      searchParams.set("not_types", params.notTypes.join(","));
-    }
-    const query = searchParams.toString();
-    return request(`/v1/streams/events${query ? `?${query}` : ""}`);
+    return request(`/v1/streams/events${buildQuery({
+      cursor: params.cursor,
+      from_height: params.fromHeight,
+      to_height: params.toHeight,
+      limit: params.limit,
+      contract_id: params.contractId,
+      sender: params.sender,
+      recipient: params.recipient,
+      asset_identifier: params.assetIdentifier,
+      types: params.types,
+      not_types: params.notTypes
+    })}`);
   }
   return {
     events: {
@@ -360,6 +515,7 @@ function createStreamsClient(options) {
         return consumeStreamsEvents({
           fromCursor: params.fromCursor,
           mode: params.mode,
+          finalizedOnly: params.finalizedOnly,
           types: params.types,
           notTypes: params.notTypes,
           contractId: params.contractId,
@@ -369,6 +525,7 @@ function createStreamsClient(options) {
           batchSize: params.batchSize ?? 100,
           fetchEvents,
           onBatch: params.onBatch,
+          onReorg: params.onReorg,
           emptyBackoffMs: params.emptyBackoffMs,
           maxPages: params.maxPages,
           maxEmptyPolls: params.maxEmptyPolls,
@@ -423,11 +580,10 @@ function createStreamsClient(options) {
     },
     reorgs: {
       list(params) {
-        const searchParams = new URLSearchParams;
-        appendSearchParam(searchParams, "since", params.since);
-        appendSearchParam(searchParams, "limit", params.limit);
-        const query = searchParams.toString();
-        return request(`/v1/streams/reorgs${query ? `?${query}` : ""}`);
+        return request(`/v1/streams/reorgs${buildQuery({
+          since: params.since,
+          limit: params.limit
+        })}`);
       }
     },
     dumps,
@@ -439,127 +595,8 @@ function createStreamsClient(options) {
     }
   };
 }
-// src/streams/ft-transfer.ts
-function requireString(payload, field) {
-  const value = payload[field];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`ft_transfer payload missing ${field}`);
-  }
-  return value;
-}
-function parseAssetIdentifier(assetIdentifier) {
-  const [contractId, tokenName] = assetIdentifier.split("::");
-  if (!contractId) {
-    throw new Error("ft_transfer payload has malformed asset_identifier");
-  }
-  return {
-    contract_id: contractId,
-    token_name: tokenName && tokenName.length > 0 ? tokenName : null
-  };
-}
-function isFtTransfer(event) {
-  return event.event_type === "ft_transfer";
-}
-function decodeFtTransfer(event) {
-  if (!isFtTransfer(event)) {
-    throw new Error(`Expected ft_transfer event, got ${event.event_type}`);
-  }
-  const payload = event.payload;
-  const assetIdentifier = requireString(payload, "asset_identifier");
-  const sender = requireString(payload, "sender");
-  const recipient = requireString(payload, "recipient");
-  const amount = requireString(payload, "amount");
-  if (!/^(0|[1-9]\d*)$/.test(amount)) {
-    throw new Error("ft_transfer payload has malformed amount");
-  }
-  const { contract_id, token_name } = parseAssetIdentifier(assetIdentifier);
-  return {
-    cursor: event.cursor,
-    block_height: event.block_height,
-    tx_id: event.tx_id,
-    tx_index: event.tx_index,
-    event_index: event.event_index,
-    event_type: event.event_type,
-    decoded_payload: {
-      asset_identifier: assetIdentifier,
-      contract_id: event.contract_id ?? contract_id,
-      token_name,
-      sender,
-      recipient,
-      amount
-    },
-    source_cursor: event.cursor
-  };
-}
-// src/streams/nft-transfer.ts
-function requireString2(payload, field) {
-  const value = payload[field];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`nft_transfer payload missing ${field}`);
-  }
-  return value;
-}
-function requireHexValue(payload) {
-  const rawValue = payload.raw_value;
-  if (typeof rawValue === "string") {
-    if (!/^0x[0-9a-fA-F]*$/.test(rawValue)) {
-      throw new Error("nft_transfer payload has malformed value");
-    }
-    return rawValue;
-  }
-  const value = payload.value;
-  const hex = typeof value === "string" ? value : value && typeof value === "object" && typeof value.hex === "string" ? value.hex : null;
-  if (!hex) {
-    throw new Error("nft_transfer payload missing value");
-  }
-  if (!/^0x[0-9a-fA-F]*$/.test(hex)) {
-    throw new Error("nft_transfer payload has malformed value");
-  }
-  return hex;
-}
-function parseAssetIdentifier2(assetIdentifier) {
-  const [contractId, tokenName] = assetIdentifier.split("::");
-  if (!contractId) {
-    throw new Error("nft_transfer payload has malformed asset_identifier");
-  }
-  return {
-    contract_id: contractId,
-    token_name: tokenName && tokenName.length > 0 ? tokenName : null
-  };
-}
-function isNftTransfer(event) {
-  return event.event_type === "nft_transfer";
-}
-function decodeNftTransfer(event) {
-  if (!isNftTransfer(event)) {
-    throw new Error(`Expected nft_transfer event, got ${event.event_type}`);
-  }
-  const payload = event.payload;
-  const assetIdentifier = requireString2(payload, "asset_identifier");
-  const sender = requireString2(payload, "sender");
-  const recipient = requireString2(payload, "recipient");
-  const value = requireHexValue(payload);
-  const { contract_id, token_name } = parseAssetIdentifier2(assetIdentifier);
-  return {
-    cursor: event.cursor,
-    block_height: event.block_height,
-    tx_id: event.tx_id,
-    tx_index: event.tx_index,
-    event_index: event.event_index,
-    event_type: event.event_type,
-    decoded_payload: {
-      asset_identifier: assetIdentifier,
-      contract_id: event.contract_id ?? contract_id,
-      token_name,
-      sender,
-      recipient,
-      value
-    },
-    source_cursor: event.cursor
-  };
-}
 // src/streams/_payload.ts
-function requireString3(payload, field, eventType) {
+function requireString(payload, field, eventType) {
   const value = payload[field];
   if (typeof value !== "string" || value.length === 0) {
     throw new Error(`${eventType} payload missing ${field}`);
@@ -570,7 +607,7 @@ function optionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function requireAmountField(payload, field, eventType) {
-  const amount = requireString3(payload, field, eventType);
+  const amount = requireString(payload, field, eventType);
   if (!/^(0|[1-9]\d*)$/.test(amount)) {
     throw new Error(`${eventType} payload has malformed ${field}`);
   }
@@ -579,7 +616,7 @@ function requireAmountField(payload, field, eventType) {
 function requireAmount(payload, eventType) {
   return requireAmountField(payload, "amount", eventType);
 }
-function parseAssetIdentifier3(assetIdentifier, eventType) {
+function parseAssetIdentifier(assetIdentifier, eventType) {
   const [contractId, tokenName] = assetIdentifier.split("::");
   if (!contractId) {
     throw new Error(`${eventType} payload has malformed asset_identifier`);
@@ -589,7 +626,7 @@ function parseAssetIdentifier3(assetIdentifier, eventType) {
     token_name: tokenName && tokenName.length > 0 ? tokenName : null
   };
 }
-function requireHexValue2(payload, eventType) {
+function requireHexValue(payload, eventType) {
   const rawValue = payload.raw_value;
   if (typeof rawValue === "string") {
     if (!/^0x[0-9a-fA-F]*$/.test(rawValue)) {
@@ -620,6 +657,52 @@ function decodedRow(event, eventType, decoded_payload) {
   };
 }
 
+// src/streams/ft-transfer.ts
+function isFtTransfer(event) {
+  return event.event_type === "ft_transfer";
+}
+function decodeFtTransfer(event) {
+  if (!isFtTransfer(event)) {
+    throw new Error(`Expected ft_transfer event, got ${event.event_type}`);
+  }
+  const payload = event.payload;
+  const assetIdentifier = requireString(payload, "asset_identifier", "ft_transfer");
+  const sender = requireString(payload, "sender", "ft_transfer");
+  const recipient = requireString(payload, "recipient", "ft_transfer");
+  const amount = requireAmount(payload, "ft_transfer");
+  const { contract_id, token_name } = parseAssetIdentifier(assetIdentifier, "ft_transfer");
+  return decodedRow(event, "ft_transfer", {
+    asset_identifier: assetIdentifier,
+    contract_id: event.contract_id ?? contract_id,
+    token_name,
+    sender,
+    recipient,
+    amount
+  });
+}
+// src/streams/nft-transfer.ts
+function isNftTransfer(event) {
+  return event.event_type === "nft_transfer";
+}
+function decodeNftTransfer(event) {
+  if (!isNftTransfer(event)) {
+    throw new Error(`Expected nft_transfer event, got ${event.event_type}`);
+  }
+  const payload = event.payload;
+  const assetIdentifier = requireString(payload, "asset_identifier", "nft_transfer");
+  const sender = requireString(payload, "sender", "nft_transfer");
+  const recipient = requireString(payload, "recipient", "nft_transfer");
+  const value = requireHexValue(payload, "nft_transfer");
+  const { contract_id, token_name } = parseAssetIdentifier(assetIdentifier, "nft_transfer");
+  return decodedRow(event, "nft_transfer", {
+    asset_identifier: assetIdentifier,
+    contract_id: event.contract_id ?? contract_id,
+    token_name,
+    sender,
+    recipient,
+    value
+  });
+}
 // src/streams/stx-events.ts
 function isStxTransfer(event) {
   return event.event_type === "stx_transfer";
@@ -630,8 +713,8 @@ function decodeStxTransfer(event) {
   }
   const payload = event.payload;
   return decodedRow(event, "stx_transfer", {
-    sender: requireString3(payload, "sender", "stx_transfer"),
-    recipient: requireString3(payload, "recipient", "stx_transfer"),
+    sender: requireString(payload, "sender", "stx_transfer"),
+    recipient: requireString(payload, "recipient", "stx_transfer"),
     amount: requireAmount(payload, "stx_transfer"),
     memo: optionalString(payload.memo)
   });
@@ -645,7 +728,7 @@ function decodeStxMint(event) {
   }
   const payload = event.payload;
   return decodedRow(event, "stx_mint", {
-    recipient: requireString3(payload, "recipient", "stx_mint"),
+    recipient: requireString(payload, "recipient", "stx_mint"),
     amount: requireAmount(payload, "stx_mint")
   });
 }
@@ -658,7 +741,7 @@ function decodeStxBurn(event) {
   }
   const payload = event.payload;
   return decodedRow(event, "stx_burn", {
-    sender: requireString3(payload, "sender", "stx_burn"),
+    sender: requireString(payload, "sender", "stx_burn"),
     amount: requireAmount(payload, "stx_burn")
   });
 }
@@ -671,15 +754,15 @@ function decodeStxLock(event) {
   }
   const payload = event.payload;
   return decodedRow(event, "stx_lock", {
-    sender: requireString3(payload, "locked_address", "stx_lock"),
+    sender: requireString(payload, "locked_address", "stx_lock"),
     amount: requireAmountField(payload, "locked_amount", "stx_lock"),
     payload: { unlock_height: optionalString(payload.unlock_height) }
   });
 }
 // src/streams/token-mint-burn.ts
 function assetFields(event, eventType) {
-  const assetIdentifier = requireString3(event.payload, "asset_identifier", eventType);
-  const { contract_id, token_name } = parseAssetIdentifier3(assetIdentifier, eventType);
+  const assetIdentifier = requireString(event.payload, "asset_identifier", eventType);
+  const { contract_id, token_name } = parseAssetIdentifier(assetIdentifier, eventType);
   return {
     asset_identifier: assetIdentifier,
     contract_id: event.contract_id ?? contract_id,
@@ -695,7 +778,7 @@ function decodeFtMint(event) {
   }
   return decodedRow(event, "ft_mint", {
     ...assetFields(event, "ft_mint"),
-    recipient: requireString3(event.payload, "recipient", "ft_mint"),
+    recipient: requireString(event.payload, "recipient", "ft_mint"),
     amount: requireAmount(event.payload, "ft_mint")
   });
 }
@@ -708,7 +791,7 @@ function decodeFtBurn(event) {
   }
   return decodedRow(event, "ft_burn", {
     ...assetFields(event, "ft_burn"),
-    sender: requireString3(event.payload, "sender", "ft_burn"),
+    sender: requireString(event.payload, "sender", "ft_burn"),
     amount: requireAmount(event.payload, "ft_burn")
   });
 }
@@ -721,8 +804,8 @@ function decodeNftMint(event) {
   }
   return decodedRow(event, "nft_mint", {
     ...assetFields(event, "nft_mint"),
-    recipient: requireString3(event.payload, "recipient", "nft_mint"),
-    value: requireHexValue2(event.payload, "nft_mint")
+    recipient: requireString(event.payload, "recipient", "nft_mint"),
+    value: requireHexValue(event.payload, "nft_mint")
   });
 }
 function isNftBurn(event) {
@@ -734,8 +817,8 @@ function decodeNftBurn(event) {
   }
   return decodedRow(event, "nft_burn", {
     ...assetFields(event, "nft_burn"),
-    sender: requireString3(event.payload, "sender", "nft_burn"),
-    value: requireHexValue2(event.payload, "nft_burn")
+    sender: requireString(event.payload, "sender", "nft_burn"),
+    value: requireHexValue(event.payload, "nft_burn")
   });
 }
 // src/clarity.ts
@@ -834,8 +917,9 @@ export {
   StreamsServerError,
   STREAMS_EVENT_TYPES,
   RateLimitError,
+  Cursor,
   AuthError
 };
 
-//# debugId=E556011474C772DE64756E2164756E21
+//# debugId=CA2A679BA194AF3B64756E2164756E21
 //# sourceMappingURL=index.js.map