@secondlayer/stacks 6.0.0 → 6.1.0

package/dist/src/filters/index.cjs

@@ -1,3 +1,727 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 
-//# debugId=DDDF1E5FDE06A0EC64756E2164756E21
+// src/filters/index.ts
+var exports_filters = {};
+__export(exports_filters, {
+  on: () => on,
+  makeChainEventFilter: () => makeChainEventFilter,
+  isPrincipal: () => isPrincipal,
+  hasWildcard: () => hasWildcard,
+  fromSubgraphSource: () => fromSubgraphSource,
+  assetId: () => assetId,
+  assertPrincipalish: () => assertPrincipalish,
+  assertContractId: () => assertContractId,
+  assertAssetIdentifier: () => assertAssetIdentifier,
+  VM_NODE_TO_STORED_TYPE: () => VM_NODE_TO_STORED_TYPE,
+  VM_EVENT_TYPES: () => VM_EVENT_TYPES,
+  DECODED_EVENT_TYPES: () => DECODED_EVENT_TYPES,
+  CHAIN_EVENT_FILTER_TYPES: () => CHAIN_EVENT_FILTER_TYPES
+});
+module.exports = __toCommonJS(exports_filters);
+
+// src/filters/event-types.ts
+var DECODED_EVENT_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "print"
+];
+var VM_EVENT_TYPES = [
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+];
+var VM_NODE_TO_STORED_TYPE = {
+  contract_call_event: "nested_contract_call",
+  var_set_event: "var_set",
+  map_set_event: "map_set",
+  map_insert_event: "map_insert",
+  map_delete_event: "map_delete"
+};
+var CHAIN_EVENT_FILTER_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "contract_call",
+  "contract_deploy",
+  "print_event",
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete",
+  "sbtc_deposit",
+  "sbtc_withdrawal_create",
+  "sbtc_withdrawal_accept",
+  "sbtc_withdrawal_reject",
+  "sbtc_withdrawal_swept_confirmed"
+];
+// src/utils/c32.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function readUInt32BE(bytes, offset = 0) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function readUInt16BE(bytes, offset = 0) {
+  return (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+
+// src/utils/c32.ts
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = hex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
+      const nextBits = 1 + carry;
+      const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
+      res.unshift(C32[currentCode + nextLowBits]);
+      carry = nextBits;
+    } else {
+      carry = 0;
+    }
+  }
+  let leadingZeros = 0;
+  while (leadingZeros < res.length && res[leadingZeros] === "0")
+    leadingZeros++;
+  const stripped = res.slice(leadingZeros);
+  const bytes = hexToBytes(hex);
+  let zeroBytesCount = 0;
+  while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
+    zeroBytesCount++;
+  const prefix = Array(zeroBytesCount).fill(C32[0]);
+  return [...prefix, ...stripped].join("");
+}
+function c32decode(c32input) {
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/utils/constants.ts
+var MAX_U128 = (1n << 128n) - 1n;
+var MAX_I128 = (1n << 127n) - 1n;
+var MIN_I128 = -(1n << 127n);
+var AddressVersion = {
+  MainnetSingleSig: 22,
+  MainnetMultiSig: 20,
+  TestnetSingleSig: 26,
+  TestnetMultiSig: 21
+};
+var ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+var TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+var MICROSTX_PER_STX = 1000000n;
+
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha22.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha23.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+// src/utils/address.ts
+function publicKeyToAddress(publicKey, network = "mainnet") {
+  const bytes = typeof publicKey === "string" ? hexToBytes(without0x(publicKey)) : publicKey;
+  const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
+  return c32address(version, bytesToHex(hash160(bytes)));
+}
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var isValidAddress = validateStacksAddress;
+function parsePrincipal(value) {
+  const parts = value.split(".");
+  if (parts.length > 2)
+    return null;
+  const [address, contractName] = parts;
+  if (!validateStacksAddress(address))
+    return null;
+  if (contractName === undefined)
+    return { address };
+  if (!CONTRACT_NAME_REGEX.test(contractName))
+    return null;
+  return { address, contractName };
+}
+function parseContractId(contractId) {
+  const parsed = parsePrincipal(contractId);
+  if (!parsed?.contractName)
+    throw new Error(`Invalid contract identifier: ${contractId}`);
+  return [parsed.address, parsed.contractName];
+}
+function isClarityName(name) {
+  const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
+  return regex.test(name) && name.length < 128;
+}
+function isAddressEqual(a, b) {
+  const [versionA, hashA] = c32addressDecode(a);
+  const [versionB, hashB] = c32addressDecode(b);
+  return versionA === versionB && hashA.toLowerCase() === hashB.toLowerCase();
+}
+function addressToVersion(address) {
+  return c32addressDecode(address)[0];
+}
+function getContractAddress(deployer, contractName) {
+  if (!validateStacksAddress(deployer)) {
+    throw new Error(`Invalid deployer address: ${deployer}`);
+  }
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
+  }
+  return `${deployer}.${contractName}`;
+}
+
+// src/filters/validate.ts
+function assetId(value) {
+  assertAssetIdentifier("assetIdentifier", value);
+  return value;
+}
+function isPrincipal(value) {
+  return parsePrincipal(value) !== null;
+}
+function hasWildcard(value) {
+  return value.includes("*");
+}
+function assertPrincipalish(field, value) {
+  if (hasWildcard(value))
+    return;
+  if (!isPrincipal(value)) {
+    throw new Error(`${field} "${value}" is not a valid Stacks principal (SP…/ST…, optionally .contract-name).`);
+  }
+}
+function assertAssetIdentifier(field, value) {
+  if (hasWildcard(value))
+    return;
+  const [contractId, assetName, ...rest] = value.split("::");
+  if (!contractId || !assetName || rest.length > 0 || !contractId.includes(".") || !isPrincipal(contractId)) {
+    throw new Error(`${field} "${value}" is not a valid asset identifier (SP….contract-name::asset-name). Passing a bare contract id here matches zero rows — use contractId for that.`);
+  }
+}
+function assertContractId(field, value) {
+  if (hasWildcard(value))
+    return;
+  if (value.includes("::")) {
+    throw new Error(`${field} "${value}" is an asset identifier, not a contract id — use assetIdentifier for that.`);
+  }
+  if (!value.includes(".") || !isPrincipal(value)) {
+    throw new Error(`${field} "${value}" is not a valid contract id (SP….contract-name).`);
+  }
+}
+
+// src/filters/factories.ts
+var PRINCIPAL_FIELDS = new Set([
+  "sender",
+  "recipient",
+  "caller",
+  "deployer",
+  "lockedAddress"
+]);
+var AMOUNT_FIELDS = new Set(["minAmount", "maxAmount"]);
+var DECORATIVE_FIELDS = new Set(["abi", "prints"]);
+function specEntries(spec) {
+  return Object.entries(spec).filter(([key, value]) => key !== "type" && value !== undefined);
+}
+function validateSpec(spec) {
+  for (const [key, value] of specEntries(spec)) {
+    if (PRINCIPAL_FIELDS.has(key)) {
+      assertPrincipalish(key, value);
+    } else if (key === "assetIdentifier") {
+      assertAssetIdentifier(key, value);
+    } else if (key === "contractId") {
+      for (const id of Array.isArray(value) ? value : [value]) {
+        assertContractId(key, id);
+      }
+    }
+  }
+}
+function unsupported(surface, field, hint) {
+  throw new Error(`${field} cannot be expressed on ${surface} — ${hint}. Drop the field from the filter or use the surface that supports it.`);
+}
+function assertNoWildcards(surface, spec) {
+  for (const [key, value] of specEntries(spec)) {
+    const candidates = Array.isArray(value) ? value : [value];
+    for (const candidate of candidates) {
+      if (typeof candidate === "string" && hasWildcard(candidate)) {
+        unsupported(surface, `${key} wildcard "${candidate}"`, "wildcard patterns are Webhooks/Subgraphs-only");
+      }
+    }
+  }
+}
+function assertNotTraitAndContract(surface, spec) {
+  const trait = "trait" in spec ? spec.trait : undefined;
+  const contract = "contractId" in spec ? spec.contractId : undefined;
+  if (trait !== undefined && contract !== undefined) {
+    unsupported(surface, "trait with contractId", "the Index treats them as mutually exclusive — drop one, or use a subgraph source, which ANDs the pair");
+  }
+}
+function toChainTrigger(spec) {
+  const out = {};
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (key === "factory") {
+      unsupported("Webhooks", "factory", "dynamic factory discovery is a Subgraphs-only concept — a trigger targets addresses known when it is created");
+    }
+    if (Array.isArray(value)) {
+      unsupported("Webhooks", `${key} set`, "a chain trigger targets ONE contract — create one subscription per contract, or use Index/Subgraphs which accept the set");
+    }
+    out[key] = typeof value === "bigint" ? value.toString() : value;
+  }
+  return { type: spec.type, ...out };
+}
+function toIndexParams(spec, extra = {}) {
+  assertNoWildcards("Index events", spec);
+  assertNotTraitAndContract("Index events", spec);
+  const out = {
+    eventType: spec.type === "print_event" ? "print" : spec.type
+  };
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (key === "factory") {
+      unsupported("Index events", "factory", "dynamic factory discovery is a Subgraphs-only concept");
+    }
+    if (AMOUNT_FIELDS.has(key)) {
+      unsupported("Index events", key, "amount predicates are Webhooks/Subgraphs-only; filter client-side on the decoded rows");
+    }
+    if (key === "topic") {
+      unsupported("Index events", "topic", "per-topic reads are Subgraphs/Webhooks-only (or read the contract's print feed and switch on topic)");
+    }
+    if (key === "lockedAddress") {
+      out.sender = value;
+      continue;
+    }
+    if (key === "caller" && spec.type !== "nested_contract_call") {
+      unsupported("Index events", "caller", "outer contract-call fields live on index.contractCalls");
+    }
+    out[key] = value;
+  }
+  return { ...out, ...extra };
+}
+var VM_MEMBERS = new Set([
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+]);
+var VM_INDEX_ONLY_FIELDS = new Set([
+  "functionName",
+  "caller",
+  "sender",
+  "map",
+  "varName"
+]);
+function toStreamsParams(spec, extra = {}) {
+  assertNoWildcards("Streams", spec);
+  const out = {
+    types: [spec.type === "print_event" ? "print" : spec.type]
+  };
+  const isVm = VM_MEMBERS.has(spec.type);
+  if (isVm)
+    out.clock = "vm";
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (isVm && VM_INDEX_ONLY_FIELDS.has(key)) {
+      unsupported("Streams", key, "vm payload predicates are Index/Subgraphs/Subscriptions-only; Streams clock=vm narrows by types and contractId");
+    }
+    if (key === "factory") {
+      unsupported("Streams", "factory", "dynamic factory discovery is a Subgraphs-only concept");
+    }
+    if (AMOUNT_FIELDS.has(key)) {
+      unsupported("Streams", key, "amount predicates are Webhooks/Subgraphs-only");
+    }
+    if (key === "trait") {
+      unsupported("Streams", "trait", "Streams has no trait resolution — Index and Subgraphs do");
+    }
+    if (key === "topic") {
+      unsupported("Streams", "topic", "per-topic filtering is Subgraphs/Webhooks-only");
+    }
+    if (key === "lockedAddress") {
+      unsupported("Streams", "lockedAddress", "stx_lock address filtering is Webhooks/Subgraphs-only");
+    }
+    out[key] = value;
+  }
+  return { ...out, ...extra };
+}
+function toContractCallsParams(spec, extra = {}) {
+  assertNoWildcards("Index contract-calls", spec);
+  assertNotTraitAndContract("Index contract-calls", spec);
+  const out = {};
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (key === "factory") {
+      unsupported("Index contract-calls", "factory", "dynamic factory discovery is a Subgraphs-only concept");
+    }
+    if (key === "caller") {
+      out.sender = value;
+      continue;
+    }
+    out[key] = value;
+  }
+  return { ...out, ...extra };
+}
+function toSubgraphSource(spec) {
+  return Object.fromEntries([
+    ["type", spec.type],
+    ...specEntries(spec)
+  ]);
+}
+var DECODED_MEMBERS = new Set([
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "print_event"
+]);
+function makeChainEventFilter(type, fields) {
+  const spec = { type, ...fields };
+  validateSpec(spec);
+  const filter = { ...spec };
+  filter.toChainTrigger = () => toChainTrigger(spec);
+  if (DECODED_MEMBERS.has(type) || VM_MEMBERS.has(type)) {
+    filter.toIndexParams = (extra) => toIndexParams(spec, extra);
+    filter.toStreamsParams = (extra) => toStreamsParams(spec, extra);
+  }
+  if (type === "contract_call") {
+    filter.toContractCallsParams = (extra) => toContractCallsParams(spec, extra);
+  }
+  if (!type.startsWith("sbtc_")) {
+    filter.toSubgraphSource = () => toSubgraphSource(spec);
+  }
+  return filter;
+}
+function fromSubgraphSource(source) {
+  const { type, ...fields } = source;
+  return makeChainEventFilter(type, fields);
+}
+var on = {
+  stxTransfer: (fields = {}) => makeChainEventFilter("stx_transfer", fields),
+  stxMint: (fields = {}) => makeChainEventFilter("stx_mint", fields),
+  stxBurn: (fields = {}) => makeChainEventFilter("stx_burn", fields),
+  stxLock: (fields = {}) => makeChainEventFilter("stx_lock", fields),
+  ftTransfer: (fields = {}) => makeChainEventFilter("ft_transfer", fields),
+  ftMint: (fields = {}) => makeChainEventFilter("ft_mint", fields),
+  ftBurn: (fields = {}) => makeChainEventFilter("ft_burn", fields),
+  nftTransfer: (fields = {}) => makeChainEventFilter("nft_transfer", fields),
+  nftMint: (fields = {}) => makeChainEventFilter("nft_mint", fields),
+  nftBurn: (fields = {}) => makeChainEventFilter("nft_burn", fields),
+  contractCall: (fields = {}) => makeChainEventFilter("contract_call", fields),
+  contractDeploy: (fields = {}) => makeChainEventFilter("contract_deploy", fields),
+  print: (fields = {}) => makeChainEventFilter("print_event", fields),
+  nestedCall: (fields = {}) => makeChainEventFilter("nested_contract_call", fields),
+  varSet: (fields = {}) => makeChainEventFilter("var_set", fields),
+  mapSet: (fields = {}) => makeChainEventFilter("map_set", fields),
+  mapInsert: (fields = {}) => makeChainEventFilter("map_insert", fields),
+  mapDelete: (fields = {}) => makeChainEventFilter("map_delete", fields),
+  sbtcDeposit: (fields = {}) => makeChainEventFilter("sbtc_deposit", fields),
+  sbtcWithdrawalCreate: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_create", fields),
+  sbtcWithdrawalAccept: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_accept", fields),
+  sbtcWithdrawalReject: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_reject", fields),
+  sbtcWithdrawalSweptConfirmed: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_swept_confirmed", fields)
+};
+
+//# debugId=595EBA32B5604B7664756E2164756E21
 //# sourceMappingURL=index.cjs.map