@secondlayer/stacks 6.1.0 → 6.1.2

package/dist/src/index.cjs

@@ -19,13 +19,15 @@ var __toESM = (mod, isNodeMode, target) => {
       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
-      });
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    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;
@@ -61,78 +63,156 @@ var __export = (target, all) => {
     });
 };
 
-// src/filters/index.ts
-var exports_filters = {};
-__export(exports_filters, {
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  AddressVersion: () => AddressVersion,
+  BaseError: () => BaseError,
+  BroadcastError: () => BroadcastError,
+  HttpRequestError: () => HttpRequestError,
+  IndexSourceConfigError: () => IndexSourceConfigError,
+  MICROSTX_PER_STX: () => MICROSTX_PER_STX,
+  MalformedResponseError: () => MalformedResponseError,
+  ReadContractError: () => ReadContractError,
+  SerializationError: () => SerializationError,
+  SigningError: () => SigningError,
+  SimulationError: () => SimulationError,
+  TESTNET_ZERO_ADDRESS: () => TESTNET_ZERO_ADDRESS,
+  TimeoutError: () => TimeoutError,
+  TransactionAbortedError: () => TransactionAbortedError,
+  TransactionDroppedError: () => TransactionDroppedError,
+  TransactionError: () => TransactionError,
+  WaitForTransactionTimeoutError: () => WaitForTransactionTimeoutError,
+  WebSocketError: () => WebSocketError,
+  ZERO_ADDRESS: () => ZERO_ADDRESS,
+  broadcastWithNonceReset: () => broadcastWithNonceReset,
+  createClient: () => createClient,
+  createMultiSigClient: () => createMultiSigClient,
+  createNonceManager: () => createNonceManager,
+  createPublicClient: () => createPublicClient,
+  createWalletClient: () => createWalletClient,
+  custom: () => custom,
+  defineChain: () => defineChain,
+  devnet: () => devnet,
+  extendedApiSource: () => extendedApiSource,
+  fallback: () => fallback,
+  formatStx: () => formatStx,
+  getContractAddress: () => getContractAddress,
+  getTransaction: () => getTransaction,
+  hiroNonceSource: () => hiroNonceSource,
+  http: () => http,
+  indexSource: () => indexSource,
+  indexTxSource: () => indexTxSource,
+  isAddressEqual: () => isAddressEqual,
+  isNonceConflictError: () => isNonceConflictError,
+  isValidAddress: () => isValidAddress,
+  jsonRpcSource: () => jsonRpcSource,
+  mainnet: () => mainnet,
+  memoryStore: () => memoryStore,
+  mempoolAwareSource: () => mempoolAwareSource,
+  mocknet: () => mocknet,
+  multisigActions: () => multisigActions,
+  nextFreeNonce: () => nextFreeNonce,
   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
+  parseStx: () => parseStx,
+  postgresStore: () => postgresStore,
+  providerToAccount: () => providerToAccount,
+  publicActions: () => publicActions,
+  reconcileNonce: () => reconcileNonce,
+  redisStore: () => redisStore,
+  resolveNonce: () => resolveNonce,
+  startNonceReconciler: () => startNonceReconciler,
+  testnet: () => testnet,
+  waitForTransactionReceipt: () => waitForTransactionReceipt,
+  walletActions: () => walletActions,
+  webSocket: () => webSocket
 });
-module.exports = __toCommonJS(exports_filters);
+module.exports = __toCommonJS(exports_src);
+
+// src/clients/createClient.ts
+var BASE_KEYS = new Set([
+  "chain",
+  "account",
+  "transport",
+  "request",
+  "nonceManager",
+  "extend"
+]);
+function bindExtend(base) {
+  return (fn) => {
+    const extensions = fn(base);
+    const next = { ...base };
+    for (const [key, value] of Object.entries(extensions)) {
+      if (BASE_KEYS.has(key))
+        continue;
+      next[key] = value;
+    }
+    next.extend = bindExtend(next);
+    return next;
+  };
+}
+function createClient(config) {
+  const transport = config.transport({ chain: config.chain });
+  const client = {
+    chain: config.chain,
+    account: config.account,
+    transport,
+    request: transport.request,
+    nonceManager: config.nonceManager,
+    extend: null
+  };
+  client.extend = bindExtend(client);
+  return client;
+}
+// src/errors/base.ts
+function codeFromName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+
+class BaseError extends Error {
+  name = "StacksError";
+  #code;
+  shortMessage;
+  details;
+  constructor(shortMessage, options) {
+    const message = [
+      shortMessage,
+      options?.details ? `
+${options.details}` : ""
+    ].join("");
+    super(message, { cause: options?.cause });
+    if (options?.code !== undefined)
+      this.#code = options.code;
+    this.shortMessage = shortMessage;
+    this.details = options?.details;
+  }
+  get code() {
+    return this.#code ?? codeFromName(this.name);
+  }
+  set code(value) {
+    this.#code = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      shortMessage: this.shortMessage,
+      details: this.details,
+      cause: this.cause instanceof Error ? this.cause.message : undefined
+    };
+  }
+}
+
+// src/errors/response.ts
+class MalformedResponseError extends BaseError {
+  name = "MalformedResponseError";
+}
+
+class ReadContractError extends BaseError {
+  name = "ReadContractError";
+}
 
-// 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");
 
@@ -380,600 +460,108 @@ function c32addressDecode(c32addr) {
   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
+// src/clarity/types.ts
+var ClarityWireType = {
+  int: 0,
+  uint: 1,
+  buffer: 2,
+  true: 3,
+  false: 4,
+  address: 5,
+  contract: 6,
+  ok: 7,
+  err: 8,
+  none: 9,
+  some: 10,
+  list: 11,
+  tuple: 12,
+  ascii: 13,
+  utf8: 14
 };
-var ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
-var TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
-var MICROSTX_PER_STX = 1000000n;
+var wireTypeToClarity = Object.fromEntries(Object.entries(ClarityWireType).map(([k, v]) => [v, k]));
+function clarityTypeFromByte(byte) {
+  const type = wireTypeToClarity[byte];
+  if (!type)
+    throw new Error(`Unknown clarity wire type: ${byte}`);
+  return type;
+}
 
-// 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/clarity/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
 }
-
-// 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 withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
 }
-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 serializeAddress(c32Address) {
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
 }
-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 serializeLPString(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(lengthPrefix, content);
 }
-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 serializeCVBytes(value) {
+  switch (value.type) {
+    case "true":
+    case "false":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "int": {
+      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
     }
-  }
-}
-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");
+    case "uint": {
+      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
     }
-    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");
+    case "buffer": {
+      const bufBytes = hexToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
     }
-    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");
+    case "none":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "some":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "ok":
+    case "err":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "address":
+      return withTypeId(value.type, serializeAddress(value.value));
+    case "contract": {
+      const [addr, name] = value.value.split(".");
+      if (!addr || !name)
+        throw new Error(`Invalid contract principal: ${value.value}`);
+      return withTypeId(value.type, concatBytes(serializeAddress(addr), serializeLPString(name)));
     }
-    if (AMOUNT_FIELDS.has(key)) {
-      unsupported("Index events", key, "amount predicates are Webhooks/Subgraphs-only; filter client-side on the decoded rows");
+    case "list": {
+      const parts = [writeUInt32BE(value.value.length)];
+      for (const item of value.value) {
+        parts.push(serializeCVBytes(item));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
     }
-    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)");
+    case "tuple": {
+      const keys = Object.keys(value.value).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      const parts = [writeUInt32BE(keys.length)];
+      for (const key of keys) {
+        parts.push(serializeLPString(key));
+        parts.push(serializeCVBytes(value.value[key]));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
     }
-    if (key === "lockedAddress") {
-      out.sender = value;
-      continue;
+    case "ascii": {
+      const strBytes = asciiToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
     }
-    if (key === "caller" && spec.type !== "nested_contract_call") {
-      unsupported("Index events", "caller", "outer contract-call fields live on index.contractCalls");
+    case "utf8": {
+      const strBytes = utf8ToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
     }
-    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)
-};
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  webSocket: () => webSocket,
-  walletActions: () => walletActions,
-  waitForTransactionReceipt: () => waitForTransactionReceipt,
-  testnet: () => testnet,
-  startNonceReconciler: () => startNonceReconciler,
-  resolveNonce: () => resolveNonce,
-  redisStore: () => redisStore,
-  reconcileNonce: () => reconcileNonce,
-  publicActions: () => publicActions,
-  providerToAccount: () => providerToAccount,
-  postgresStore: () => postgresStore,
-  parseStx: () => parseStx,
-  on: () => on,
-  nextFreeNonce: () => nextFreeNonce,
-  multisigActions: () => multisigActions,
-  mocknet: () => mocknet,
-  mempoolAwareSource: () => mempoolAwareSource,
-  memoryStore: () => memoryStore,
-  mainnet: () => mainnet,
-  jsonRpcSource: () => jsonRpcSource,
-  isValidAddress: () => isValidAddress,
-  isNonceConflictError: () => isNonceConflictError,
-  isAddressEqual: () => isAddressEqual,
-  indexTxSource: () => indexTxSource,
-  indexSource: () => indexSource,
-  http: () => http,
-  hiroNonceSource: () => hiroNonceSource,
-  getTransaction: () => getTransaction,
-  getContractAddress: () => getContractAddress,
-  formatStx: () => formatStx,
-  fallback: () => fallback,
-  extendedApiSource: () => extendedApiSource,
-  devnet: () => devnet,
-  defineChain: () => defineChain,
-  custom: () => custom,
-  createWalletClient: () => createWalletClient,
-  createPublicClient: () => createPublicClient,
-  createNonceManager: () => createNonceManager,
-  createMultiSigClient: () => createMultiSigClient,
-  createClient: () => createClient,
-  broadcastWithNonceReset: () => broadcastWithNonceReset,
-  ZERO_ADDRESS: () => ZERO_ADDRESS,
-  WebSocketError: () => WebSocketError,
-  WaitForTransactionTimeoutError: () => WaitForTransactionTimeoutError,
-  TransactionError: () => TransactionError,
-  TransactionDroppedError: () => TransactionDroppedError,
-  TransactionAbortedError: () => TransactionAbortedError,
-  TimeoutError: () => TimeoutError,
-  TESTNET_ZERO_ADDRESS: () => TESTNET_ZERO_ADDRESS,
-  SimulationError: () => SimulationError,
-  SigningError: () => SigningError,
-  SerializationError: () => SerializationError,
-  ReadContractError: () => ReadContractError,
-  MalformedResponseError: () => MalformedResponseError,
-  MICROSTX_PER_STX: () => MICROSTX_PER_STX,
-  IndexSourceConfigError: () => IndexSourceConfigError,
-  HttpRequestError: () => HttpRequestError,
-  BroadcastError: () => BroadcastError,
-  BaseError: () => BaseError,
-  AddressVersion: () => AddressVersion
-});
-module.exports = __toCommonJS(exports_src);
-
-// src/clients/createClient.ts
-var BASE_KEYS = new Set([
-  "chain",
-  "account",
-  "transport",
-  "request",
-  "nonceManager",
-  "extend"
-]);
-function bindExtend(base) {
-  return (fn) => {
-    const extensions = fn(base);
-    const next = { ...base };
-    for (const [key, value] of Object.entries(extensions)) {
-      if (BASE_KEYS.has(key))
-        continue;
-      next[key] = value;
-    }
-    next.extend = bindExtend(next);
-    return next;
-  };
-}
-function createClient(config) {
-  const transport = config.transport({ chain: config.chain });
-  const client = {
-    chain: config.chain,
-    account: config.account,
-    transport,
-    request: transport.request,
-    nonceManager: config.nonceManager,
-    extend: null
-  };
-  client.extend = bindExtend(client);
-  return client;
-}
-// src/errors/base.ts
-function codeFromName(name) {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
-}
-
-class BaseError extends Error {
-  name = "StacksError";
-  #code;
-  shortMessage;
-  details;
-  constructor(shortMessage, options) {
-    const message = [
-      shortMessage,
-      options?.details ? `
-${options.details}` : ""
-    ].join("");
-    super(message, { cause: options?.cause });
-    if (options?.code !== undefined)
-      this.#code = options.code;
-    this.shortMessage = shortMessage;
-    this.details = options?.details;
-  }
-  get code() {
-    return this.#code ?? codeFromName(this.name);
-  }
-  set code(value) {
-    this.#code = value;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      shortMessage: this.shortMessage,
-      details: this.details,
-      cause: this.cause instanceof Error ? this.cause.message : undefined
-    };
-  }
-}
-
-// src/errors/response.ts
-class MalformedResponseError extends BaseError {
-  name = "MalformedResponseError";
-}
-
-class ReadContractError extends BaseError {
-  name = "ReadContractError";
-}
-
-// src/clarity/types.ts
-var ClarityWireType = {
-  int: 0,
-  uint: 1,
-  buffer: 2,
-  true: 3,
-  false: 4,
-  address: 5,
-  contract: 6,
-  ok: 7,
-  err: 8,
-  none: 9,
-  some: 10,
-  list: 11,
-  tuple: 12,
-  ascii: 13,
-  utf8: 14
-};
-var wireTypeToClarity = Object.fromEntries(Object.entries(ClarityWireType).map(([k, v]) => [v, k]));
-function clarityTypeFromByte(byte) {
-  const type = wireTypeToClarity[byte];
-  if (!type)
-    throw new Error(`Unknown clarity wire type: ${byte}`);
-  return type;
-}
-
-// src/clarity/serialize.ts
-var CLARITY_INT_SIZE = 128n;
-var CLARITY_INT_BYTE_SIZE = 16;
-function typeIdByte(type) {
-  return ClarityWireType[type];
-}
-function withTypeId(type, bytes) {
-  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
-}
-function serializeAddress(c32Address) {
-  const [version, hash1602] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
-}
-function serializeLPString(str, prefixBytes = 1) {
-  const content = utf8ToBytes(str);
-  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
-  return concatBytes(lengthPrefix, content);
-}
-function serializeCVBytes(value) {
-  switch (value.type) {
-    case "true":
-    case "false":
-      return new Uint8Array([typeIdByte(value.type)]);
-    case "int": {
-      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
-      return withTypeId(value.type, bytes);
-    }
-    case "uint": {
-      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
-      return withTypeId(value.type, bytes);
-    }
-    case "buffer": {
-      const bufBytes = hexToBytes(value.value);
-      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
-    }
-    case "none":
-      return new Uint8Array([typeIdByte(value.type)]);
-    case "some":
-      return withTypeId(value.type, serializeCVBytes(value.value));
-    case "ok":
-    case "err":
-      return withTypeId(value.type, serializeCVBytes(value.value));
-    case "address":
-      return withTypeId(value.type, serializeAddress(value.value));
-    case "contract": {
-      const [addr, name] = value.value.split(".");
-      if (!addr || !name)
-        throw new Error(`Invalid contract principal: ${value.value}`);
-      return withTypeId(value.type, concatBytes(serializeAddress(addr), serializeLPString(name)));
-    }
-    case "list": {
-      const parts = [writeUInt32BE(value.value.length)];
-      for (const item of value.value) {
-        parts.push(serializeCVBytes(item));
-      }
-      return withTypeId(value.type, concatBytes(...parts));
-    }
-    case "tuple": {
-      const keys = Object.keys(value.value).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-      const parts = [writeUInt32BE(keys.length)];
-      for (const key of keys) {
-        parts.push(serializeLPString(key));
-        parts.push(serializeCVBytes(value.value[key]));
-      }
-      return withTypeId(value.type, concatBytes(...parts));
-    }
-    case "ascii": {
-      const strBytes = asciiToBytes(value.value);
-      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
-    }
-    case "utf8": {
-      const strBytes = utf8ToBytes(value.value);
-      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
-    }
-    default:
-      throw new Error("Cannot serialize unknown clarity type");
+    default:
+      throw new Error("Cannot serialize unknown clarity type");
   }
 }
 function serializeCV(value) {
@@ -1079,8 +667,8 @@ var TenureChangeCause = {
 
 // src/transactions/wire/serialize.ts
 function serializeAddress2(c32Address) {
-  const [version, hash1602] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
 }
 function serializeLPString2(str, prefixBytes = 1) {
   const content = utf8ToBytes(str);
@@ -1119,8 +707,8 @@ function serializeSpendingCondition(condition) {
 }
 function serializeAuthField(field) {
   if (field.type === "publicKey") {
-    const typeId2 = field.pubKeyEncoding === 0 ? 0 : 1;
-    return concatBytes(writeUInt8(typeId2), hexToBytes(field.data));
+    const typeId = field.pubKeyEncoding === 0 ? 0 : 1;
+    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
   }
   const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
   return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
@@ -1319,40 +907,125 @@ async function getAccountInfo(client, params) {
   };
 }
 
-// src/actions/public/getBalance.ts
-async function getBalance(client, params) {
-  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, {
-    method: "GET"
-  });
-  const balance = data?.balance;
-  if (typeof balance !== "string" && typeof balance !== "number") {
-    throw new MalformedResponseError(`getBalance: /v2/accounts/${params.address} response is missing "balance"`);
-  }
-  return BigInt(balance);
+// src/actions/public/getBalance.ts
+async function getBalance(client, params) {
+  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, {
+    method: "GET"
+  });
+  const balance = data?.balance;
+  if (typeof balance !== "string" && typeof balance !== "number") {
+    throw new MalformedResponseError(`getBalance: /v2/accounts/${params.address} response is missing "balance"`);
+  }
+  return BigInt(balance);
+}
+
+// src/actions/public/getBlock.ts
+async function getBlock(client, params) {
+  if (params?.hash) {
+    return client.request(`/extended/v2/blocks/${encodeURIComponent(params.hash)}`, { method: "GET" });
+  }
+  if (params?.height !== undefined) {
+    return client.request(`/extended/v2/blocks/${encodeURIComponent(String(params.height))}`, { method: "GET" });
+  }
+  const data = await client.request("/extended/v2/blocks?limit=1", {
+    method: "GET"
+  });
+  const results = data?.results;
+  return Array.isArray(results) ? results[0] ?? null : data;
+}
+
+// src/actions/public/getBlockHeight.ts
+async function getBlockHeight(client) {
+  const data = await client.request("/v2/info", { method: "GET" });
+  if (typeof data?.stacks_tip_height !== "number") {
+    throw new MalformedResponseError('getBlockHeight: /v2/info response is missing "stacks_tip_height"');
+  }
+  return data.stacks_tip_height;
+}
+
+// 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)));
 }
-
-// src/actions/public/getBlock.ts
-async function getBlock(client, params) {
-  if (params?.hash) {
-    return client.request(`/extended/v2/blocks/${encodeURIComponent(params.hash)}`, { method: "GET" });
-  }
-  if (params?.height !== undefined) {
-    return client.request(`/extended/v2/blocks/${encodeURIComponent(String(params.height))}`, { method: "GET" });
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
   }
-  const data = await client.request("/extended/v2/blocks?limit=1", {
-    method: "GET"
-  });
-  const results = data?.results;
-  return Array.isArray(results) ? results[0] ?? null : data;
 }
-
-// src/actions/public/getBlockHeight.ts
-async function getBlockHeight(client) {
-  const data = await client.request("/v2/info", { method: "GET" });
-  if (typeof data?.stacks_tip_height !== "number") {
-    throw new MalformedResponseError('getBlockHeight: /v2/info response is missing "stacks_tip_height"');
+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}`);
   }
-  return data.stacks_tip_height;
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
+  }
+  return `${deployer}.${contractName}`;
 }
 
 // src/actions/public/getContractAbi.ts
@@ -1523,13 +1196,13 @@ function bufferCV(buffer) {
   return { type: "buffer", value: bytesToHex(buffer) };
 }
 function standardPrincipalCV(address) {
-  const [version, hash1602] = c32addressDecode(address);
-  const normalized = c32address(version, hash1602);
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
   return { type: "address", value: normalized };
 }
 function contractPrincipalCV(address, contractName) {
-  const [version, hash1602] = c32addressDecode(address);
-  const normalized = c32address(version, hash1602);
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
   if (utf8ToBytes(contractName).byteLength >= 128) {
     throw new Error("Contract name must be less than 128 bytes");
   }
@@ -1600,8 +1273,8 @@ var Cl = {
 // src/clarity/deserialize.ts
 function readAddress(reader) {
   const version = reader.readUInt8();
-  const hash1602 = bytesToHex(reader.readBytes(20));
-  return c32address(version, hash1602);
+  const hash160 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash160);
 }
 function readLPString(reader, prefixBytes = 1) {
   let length = 0;
@@ -2212,7 +1885,7 @@ async function simulateTransaction(client, params) {
   if (payload.payloadType === PayloadType.ContractCall) {
     const sender = params.sender ?? extractSender(transaction, client);
     const contract = `${payload.contractAddress}.${payload.contractName}`;
-    const [execution, fees2] = await Promise.all([
+    const [execution, fees] = await Promise.all([
       simulateCall(client, {
         contract,
         functionName: payload.functionName,
@@ -2222,7 +1895,7 @@ async function simulateTransaction(client, params) {
       }),
       estimateFee(client, { transaction })
     ]);
-    return { type: "contract-call", execution, fees: fees2 };
+    return { type: "contract-call", execution, fees };
   }
   const fees = await estimateFee(client, { transaction });
   if (payload.payloadType === PayloadType.SmartContract || payload.payloadType === PayloadType.VersionedSmartContract) {
@@ -2952,11 +2625,11 @@ function replayMultiSigSigHash(tx) {
   const condition = tx.auth.spendingCondition;
   if (isNonSequential(condition.hashMode)) {
     const preSign = nonSequentialPreSignHash(tx);
-    let curSigHash2 = preSign;
+    let curSigHash = preSign;
     for (const field of condition.fields) {
-      curSigHash2 = sigHashPostSign(curSigHash2, field.pubKeyEncoding, field.data);
+      curSigHash = sigHashPostSign(curSigHash, field.pubKeyEncoding, field.data);
     }
-    return curSigHash2;
+    return curSigHash;
   }
   let curSigHash = initialSigHash(tx);
   for (const field of condition.fields) {
@@ -3077,8 +2750,8 @@ async function signSequentialWithAccount(tx, condition, account, publicKeys, sig
   const fields = [...condition.fields];
   let curSigHash = initialSigHash(tx);
   for (const field of fields) {
-    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign2, field.pubKeyEncoding, field.data);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
   }
   for (let i = fields.length;i < signerIndex; i++) {
     const pubKeyField = {
@@ -3087,8 +2760,8 @@ async function signSequentialWithAccount(tx, condition, account, publicKeys, sig
       data: publicKeys[i]
     };
     fields.push(pubKeyField);
-    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign2, pubKeyField.pubKeyEncoding, pubKeyField.data);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
   }
   const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
   const sigBytes = await account.sign(hexToBytes(preSign));
@@ -3327,9 +3000,9 @@ function getOriginSigHash(tx) {
   if ("fields" in condition) {
     return replayMultiSigSigHash(tx);
   }
-  const initialSigHash2 = signBegin(tx);
+  const initialSigHash = signBegin(tx);
   const sc = condition;
-  const preSign = sigHashPreSign(initialSigHash2, AuthType.Standard, sc.fee, sc.nonce);
+  const preSign = sigHashPreSign(initialSigHash, AuthType.Standard, sc.fee, sc.nonce);
   return sigHashPostSign(preSign, sc.keyEncoding, sc.signature);
 }
 function signSponsor(tx, privateKey) {
@@ -3395,11 +3068,11 @@ async function sendTransaction(client, params) {
         throw error;
       }
     } else if (error instanceof TimeoutError) {
-      const txid3 = getTransactionId(params.transaction);
-      const receipt = await getTransaction(client, { txid: txid3 }).catch(() => null);
+      const txid = getTransactionId(params.transaction);
+      const receipt = await getTransaction(client, { txid }).catch(() => null);
       if (receipt === null)
         throw error;
-      data = { txid: txid3 };
+      data = { txid };
     } else {
       throw error;
     }
@@ -3411,16 +3084,16 @@ async function sendTransaction(client, params) {
       txid: data.txid ?? getTransactionId(params.transaction)
     });
   }
-  const txid2 = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
+  const txid = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
   if (params.wait) {
     const confirmations = params.wait === true ? 1 : params.wait;
     const receipt = await waitForTransactionReceipt(client, {
-      txid: txid2,
+      txid,
       confirmations
     });
-    return { txid: txid2, receipt };
+    return { txid, receipt };
   }
-  return { txid: txid2 };
+  return { txid };
 }
 
 // src/actions/wallet/nonceManager.ts
@@ -3674,10 +3347,180 @@ async function deployContract(client, params) {
     throw new Error(`Invalid contract name: ${params.contractName}`);
   if (isProviderAccount(account)) {
     assertNoFeeTierForProvider(params.fee);
-    const result = await account.provider.request("stx_deployContract", {
-      contractName: params.contractName,
-      codeBody: params.codeBody,
-      clarityVersion: params.clarityVersion
+    const result = await account.provider.request("stx_deployContract", {
+      contractName: params.contractName,
+      codeBody: params.codeBody,
+      clarityVersion: params.clarityVersion
+    });
+    return result.txid;
+  }
+  const managed = params.nonce === undefined && client.nonceManager !== undefined;
+  const nonce = params.nonce ?? await resolveNonce(client, account.address);
+  try {
+    const needsFeeResolution = params.fee === undefined || isFeeTier(params.fee);
+    const unsigned = buildContractDeploy({
+      contractName: params.contractName,
+      codeBody: params.codeBody,
+      clarityVersion: params.clarityVersion,
+      fee: needsFeeResolution ? 0n : params.fee,
+      nonce,
+      publicKey: account.publicKey,
+      chain: client.chain,
+      postConditionMode: params.postConditionMode,
+      postConditions: params.postConditions
+    });
+    if (needsFeeResolution) {
+      const { fee } = await resolveFee(client, unsigned, params.fee);
+      setUnsignedFee(unsigned, fee);
+    }
+    const signed = await signTransactionWithAccount(unsigned, account);
+    return await broadcastWithNonceReset(client, {
+      transaction: signed,
+      address: account.address
+    });
+  } catch (error) {
+    if (managed)
+      await releaseNonce(client, account.address, nonce);
+    throw error;
+  }
+}
+
+// src/actions/wallet/signMessage.ts
+var import_sha26 = require("@noble/hashes/sha2.js");
+
+// src/clarity/structuredData.ts
+var import_sha25 = require("@noble/hashes/sha2.js");
+var SIP018_PREFIX = new Uint8Array([
+  83,
+  73,
+  80,
+  48,
+  49,
+  56
+]);
+function hashStructuredData(structuredData) {
+  return import_sha25.sha256(serializeCVBytes(structuredData));
+}
+function isDomain(value) {
+  if (value.type !== "tuple")
+    return false;
+  const { name, version, "chain-id": chainId } = value.value;
+  return name?.type === "ascii" && version?.type === "ascii" && chainId?.type === "uint";
+}
+function encodeStructuredData(opts) {
+  if (!isDomain(opts.domain)) {
+    throw new Error("domain must be a tuple { name: ascii, version: ascii, chain-id: uint }");
+  }
+  return concatBytes(SIP018_PREFIX, hashStructuredData(opts.domain), hashStructuredData(opts.message));
+}
+function structuredDataHash(opts) {
+  return import_sha25.sha256(encodeStructuredData(opts));
+}
+async function signStructuredData(account, opts) {
+  const vrs = await account.sign(structuredDataHash(opts));
+  if (vrs.length !== 65) {
+    throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
+  }
+  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+}
+
+// src/actions/wallet/signMessage.ts
+async function signMessage(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  if (isProviderAccount(account)) {
+    const method = params.domain ? "stx_signStructuredMessage" : "stx_signMessage";
+    const result = await account.provider.request(method, {
+      message: params.message,
+      domain: params.domain
+    });
+    return result.signature;
+  }
+  const cv = typeof params.message === "string" ? Cl.stringAscii(params.message) : params.message;
+  const hash = params.domain ? structuredDataHash({
+    message: cv,
+    domain: Cl.tuple({
+      name: Cl.stringAscii(params.domain.name),
+      version: Cl.stringAscii(params.domain.version),
+      "chain-id": Cl.uint(params.domain.chainId)
+    })
+  }) : import_sha26.sha256(serializeCVBytes(cv));
+  const sigBytes = await account.sign(hash);
+  return bytesToHex(sigBytes);
+}
+
+// src/actions/wallet/signTransaction.ts
+async function signTransactionAction(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  if (isProviderAccount(account)) {
+    const hex = serializeTransactionHex(params.transaction);
+    const result = await account.provider.request("stx_signTransaction", {
+      transaction: hex
+    });
+    return deserializeTransaction(result.transaction, {
+      _multisig: params.transaction._multisig
+    });
+  }
+  const condition = params.transaction.auth.spendingCondition;
+  if ("fields" in condition) {
+    const publicKeys = params.signers ?? params.transaction._multisig?.publicKeys;
+    if (!publicKeys)
+      throw new Error("Multi-sig signing requires signers (publicKeys)");
+    return signMultiSigWithAccount(params.transaction, account, publicKeys);
+  }
+  return signTransactionWithAccount(params.transaction, account);
+}
+
+// src/actions/wallet/sponsorTransaction.ts
+async function sponsorTransaction(client, params) {
+  const { transaction } = params;
+  if (transaction.auth.authType !== AuthType.Sponsored) {
+    throw new Error("Transaction must have sponsored authorization");
+  }
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  if (isProviderAccount(account)) {
+    throw new Error("Provider accounts cannot sponsor transactions");
+  }
+  const managed = params.nonce == null && client.nonceManager !== undefined;
+  const nonce = params.nonce != null ? intToBigInt(params.nonce) : await resolveNonce(client, account.address);
+  let fee;
+  try {
+    ({ fee } = await resolveFee(client, transaction, params.fee));
+  } catch (error) {
+    if (managed)
+      await releaseNonce(client, account.address, nonce);
+    throw error;
+  }
+  const sponsorCondition = createSingleSigSpendingCondition(account.publicKey, nonce, fee);
+  const auth = transaction.auth;
+  const sponsored = {
+    ...transaction,
+    auth: {
+      ...auth,
+      sponsorSpendingCondition: sponsorCondition
+    }
+  };
+  return signSponsorWithAccount(sponsored, account);
+}
+
+// src/actions/wallet/transferStx.ts
+async function transferStx(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  if (!validateStacksAddress(params.to))
+    throw new Error(`Invalid recipient address: ${params.to}`);
+  if (isProviderAccount(account)) {
+    assertNoFeeTierForProvider(params.fee);
+    const result = await account.provider.request("stx_transferStx", {
+      recipient: params.to,
+      amount: String(params.amount),
+      memo: params.memo
     });
     return result.txid;
   }
@@ -3685,10 +3528,10 @@ async function deployContract(client, params) {
   const nonce = params.nonce ?? await resolveNonce(client, account.address);
   try {
     const needsFeeResolution = params.fee === undefined || isFeeTier(params.fee);
-    const unsigned = buildContractDeploy({
-      contractName: params.contractName,
-      codeBody: params.codeBody,
-      clarityVersion: params.clarityVersion,
+    const unsigned = buildTokenTransfer({
+      recipient: params.to,
+      amount: params.amount,
+      memo: params.memo,
       fee: needsFeeResolution ? 0n : params.fee,
       nonce,
       publicKey: account.publicKey,
@@ -3712,755 +3555,913 @@ async function deployContract(client, params) {
   }
 }
 
-// src/actions/wallet/signMessage.ts
-var import_sha26 = require("@noble/hashes/sha2.js");
-
-// src/clarity/structuredData.ts
-var import_sha25 = require("@noble/hashes/sha2.js");
-var SIP018_PREFIX = new Uint8Array([
-  83,
-  73,
-  80,
-  48,
-  49,
-  56
-]);
-function hashStructuredData(structuredData) {
-  return import_sha25.sha256(serializeCVBytes(structuredData));
+// src/clients/decorators/wallet.ts
+function walletActions(client) {
+  return {
+    sendTransaction: (params) => sendTransaction(client, params),
+    signTransaction: (params) => signTransactionAction(client, params),
+    transferStx: (params) => transferStx(client, params),
+    callContract: (params) => callContract(client, params),
+    deployContract: (params) => deployContract(client, params),
+    signMessage: (params) => signMessage(client, params),
+    sponsorTransaction: (params) => sponsorTransaction(client, params)
+  };
 }
-function isDomain(value) {
-  if (value.type !== "tuple")
-    return false;
-  const { name, version, "chain-id": chainId } = value.value;
-  return name?.type === "ascii" && version?.type === "ascii" && chainId?.type === "uint";
+
+// src/clients/createWalletClient.ts
+function createWalletClient(config) {
+  return createClient(config).extend(walletActions);
 }
-function encodeStructuredData(opts) {
-  if (!isDomain(opts.domain)) {
-    throw new Error("domain must be a tuple { name: ascii, version: ascii, chain-id: uint }");
+// src/clients/decorators/multisig.ts
+function multisigActions(client) {
+  const msConfig = client._multisigConfig;
+  if (!msConfig)
+    throw new Error("multisigActions requires a multi-sig client");
+  const { signers, requiredSignatures, hashMode } = msConfig;
+  async function resolveNonce(nonce) {
+    if (nonce !== undefined)
+      return nonce;
+    const address = makeMultiSigAddress(signers, requiredSignatures, client.chain);
+    if (client.nonceManager)
+      return client.nonceManager.consume({ client, address });
+    return getNonce(client, { address });
   }
-  return concatBytes(SIP018_PREFIX, hashStructuredData(opts.domain), hashStructuredData(opts.message));
+  return {
+    async transferStx(params) {
+      const nonce = await resolveNonce(params.nonce);
+      const unsigned = buildTokenTransfer({
+        recipient: params.to,
+        amount: params.amount,
+        memo: params.memo,
+        fee: params.fee ?? 0n,
+        nonce,
+        publicKeys: signers,
+        signaturesRequired: requiredSignatures,
+        hashMode,
+        chain: client.chain,
+        postConditionMode: params.postConditionMode,
+        postConditions: params.postConditions
+      });
+      if (params.fee === undefined) {
+        const estimates = await estimateFee(client, { transaction: unsigned });
+        const mid = estimates[1] ?? estimates[0];
+        if (mid) {
+          setUnsignedFee(unsigned, BigInt(mid.fee));
+        }
+      }
+      return unsigned;
+    },
+    async callContract(params) {
+      const [contractAddress, contractName] = parseContractId(params.contract);
+      const nonce = await resolveNonce(params.nonce);
+      const unsigned = buildContractCall({
+        contractAddress,
+        contractName,
+        functionName: params.functionName,
+        functionArgs: params.functionArgs ?? [],
+        fee: params.fee ?? 0n,
+        nonce,
+        publicKeys: signers,
+        signaturesRequired: requiredSignatures,
+        hashMode,
+        chain: client.chain,
+        postConditionMode: params.postConditionMode,
+        postConditions: params.postConditions
+      });
+      if (params.fee === undefined) {
+        const estimates = await estimateFee(client, { transaction: unsigned });
+        const mid = estimates[1] ?? estimates[0];
+        if (mid) {
+          setUnsignedFee(unsigned, BigInt(mid.fee));
+        }
+      }
+      return unsigned;
+    },
+    async deployContract(params) {
+      const nonce = await resolveNonce(params.nonce);
+      const unsigned = buildContractDeploy({
+        contractName: params.contractName,
+        codeBody: params.codeBody,
+        clarityVersion: params.clarityVersion,
+        fee: params.fee ?? 0n,
+        nonce,
+        publicKeys: signers,
+        signaturesRequired: requiredSignatures,
+        hashMode,
+        chain: client.chain,
+        postConditionMode: params.postConditionMode,
+        postConditions: params.postConditions
+      });
+      if (params.fee === undefined) {
+        const estimates = await estimateFee(client, { transaction: unsigned });
+        const mid = estimates[1] ?? estimates[0];
+        if (mid) {
+          setUnsignedFee(unsigned, BigInt(mid.fee));
+        }
+      }
+      return unsigned;
+    },
+    async sendTransaction(params) {
+      const finalized = finalizeMultiSig(params.transaction, signers);
+      return sendTransaction(client, {
+        transaction: finalized,
+        attachment: params.attachment
+      });
+    }
+  };
 }
-function structuredDataHash(opts) {
-  return import_sha25.sha256(encodeStructuredData(opts));
+
+// src/clients/createMultiSigClient.ts
+function createMultiSigClient(config) {
+  const client = createClient(config);
+  client._multisigConfig = {
+    signers: config.signers,
+    requiredSignatures: config.requiredSignatures,
+    hashMode: config.hashMode
+  };
+  return client.extend(multisigActions);
 }
-async function signStructuredData(account, opts) {
-  const vrs = await account.sign(structuredDataHash(opts));
-  if (vrs.length !== 65) {
-    throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
+// src/actions/wallet/nonceStores.ts
+var TAKE_IF_PRESENT = `local v = redis.call('GET', KEYS[1])
+if v == false then return false end
+redis.call('INCR', KEYS[1])
+return v`;
+var SEED_OR_TAKE = `local v = redis.call('GET', KEYS[1])
+if v == false then redis.call('SET', KEYS[1], ARGV[1]); v = ARGV[1] end
+redis.call('INCR', KEYS[1])
+return v`;
+var RELEASE_IF_LATEST = `local v = redis.call('GET', KEYS[1])
+if v ~= false and v == ARGV[1] then redis.call('SET', KEYS[1], ARGV[2]) end
+return v`;
+function redisStore(params) {
+  const { redis } = params;
+  const prefix = params.prefix ?? "stacks:nonce:";
+  return {
+    async reserve(key, getFloor) {
+      const k = prefix + key;
+      const present = await redis.send("EVAL", [TAKE_IF_PRESENT, "1", k]);
+      if (present != null)
+        return BigInt(present);
+      const floor = await getFloor();
+      const seeded = await redis.send("EVAL", [
+        SEED_OR_TAKE,
+        "1",
+        k,
+        floor.toString()
+      ]);
+      return BigInt(seeded);
+    },
+    async reset(key) {
+      await redis.send("DEL", [prefix + key]);
+    },
+    async release(key, nonce) {
+      await redis.send("EVAL", [
+        RELEASE_IF_LATEST,
+        "1",
+        prefix + key,
+        (nonce + 1n).toString(),
+        nonce.toString()
+      ]);
+    },
+    async peek(key) {
+      const v = await redis.send("GET", [prefix + key]);
+      return v == null ? undefined : BigInt(v);
+    }
+  };
+}
+function postgresStore(params) {
+  const { sql } = params;
+  const shouldEnsure = params.ensureTable ?? true;
+  let ensured = false;
+  async function ensureTable() {
+    if (!shouldEnsure || ensured)
+      return;
+    await sql`CREATE TABLE IF NOT EXISTS stacks_nonce_state (key text PRIMARY KEY, next numeric NOT NULL)`;
+    ensured = true;
   }
-  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+  return {
+    async reserve(key, getFloor) {
+      await ensureTable();
+      const updated = await sql`UPDATE stacks_nonce_state SET next = next + 1 WHERE key = ${key} RETURNING next - 1 AS nonce`;
+      const warm = updated[0];
+      if (warm)
+        return BigInt(String(warm.nonce));
+      const floor = await getFloor();
+      const seeded = await sql`INSERT INTO stacks_nonce_state (key, next) VALUES (${key}, ${(floor + 1n).toString()}) ON CONFLICT (key) DO UPDATE SET next = stacks_nonce_state.next + 1 RETURNING next - 1 AS nonce`;
+      const cold = seeded[0];
+      if (!cold)
+        throw new Error("postgresStore: insert returned no row");
+      return BigInt(String(cold.nonce));
+    },
+    async reset(key) {
+      await ensureTable();
+      await sql`DELETE FROM stacks_nonce_state WHERE key = ${key}`;
+    },
+    async release(key, nonce) {
+      await ensureTable();
+      await sql`UPDATE stacks_nonce_state SET next = ${nonce.toString()} WHERE key = ${key} AND next = ${(nonce + 1n).toString()}`;
+    },
+    async peek(key) {
+      await ensureTable();
+      const rows = await sql`SELECT next FROM stacks_nonce_state WHERE key = ${key}`;
+      const row = rows[0];
+      return row ? BigInt(String(row.next)) : undefined;
+    }
+  };
+}
+// src/actions/wallet/nonceSources.ts
+function resolveFetch(fetchImpl) {
+  const f = fetchImpl ?? globalThis.fetch;
+  if (!f)
+    throw new Error("No fetch implementation available; pass `fetchImpl`");
+  return f;
 }
-
-// src/actions/wallet/signMessage.ts
-async function signMessage(client, params) {
-  const account = client.account;
-  if (!account)
-    throw new Error("Account required");
-  if (isProviderAccount(account)) {
-    const method = params.domain ? "stx_signStructuredMessage" : "stx_signMessage";
-    const result = await account.provider.request(method, {
-      message: params.message,
-      domain: params.domain
-    });
-    return result.signature;
-  }
-  const cv = typeof params.message === "string" ? Cl.stringAscii(params.message) : params.message;
-  const hash = params.domain ? structuredDataHash({
-    message: cv,
-    domain: Cl.tuple({
-      name: Cl.stringAscii(params.domain.name),
-      version: Cl.stringAscii(params.domain.version),
-      "chain-id": Cl.uint(params.domain.chainId)
-    })
-  }) : import_sha26.sha256(serializeCVBytes(cv));
-  const sigBytes = await account.sign(hash);
-  return bytesToHex(sigBytes);
+function nextFreeNonce(confirmed, pending) {
+  const taken = new Set(pending.filter((n) => n >= confirmed).map((n) => n.toString()));
+  let n = confirmed;
+  while (taken.has(n.toString()))
+    n += 1n;
+  return n;
 }
-
-// src/actions/wallet/signTransaction.ts
-async function signTransactionAction(client, params) {
-  const account = client.account;
-  if (!account)
-    throw new Error("Account required");
-  if (isProviderAccount(account)) {
-    const hex = serializeTransactionHex(params.transaction);
-    const result = await account.provider.request("stx_signTransaction", {
-      transaction: hex
-    });
-    return deserializeTransaction(result.transaction, {
-      _multisig: params.transaction._multisig
-    });
-  }
-  const condition = params.transaction.auth.spendingCondition;
-  if ("fields" in condition) {
-    const publicKeys = params.signers ?? params.transaction._multisig?.publicKeys;
-    if (!publicKeys)
-      throw new Error("Multi-sig signing requires signers (publicKeys)");
-    return signMultiSigWithAccount(params.transaction, account, publicKeys);
-  }
-  return signTransactionWithAccount(params.transaction, account);
+function mempoolAwareSource(params) {
+  const getConfirmed = params.getConfirmed ?? (({ client, address }) => getNonce(client, { address }));
+  return {
+    async get({ client, address }) {
+      const confirmed = await getConfirmed({ client, address });
+      let pending = [];
+      try {
+        pending = await params.getPending({ client, address });
+      } catch (error) {
+        if (error instanceof IndexSourceConfigError)
+          throw error;
+        return confirmed;
+      }
+      return nextFreeNonce(confirmed, pending);
+    }
+  };
 }
-
-// src/actions/wallet/sponsorTransaction.ts
-async function sponsorTransaction(client, params) {
-  const { transaction } = params;
-  if (transaction.auth.authType !== AuthType.Sponsored) {
-    throw new Error("Transaction must have sponsored authorization");
-  }
-  const account = client.account;
-  if (!account)
-    throw new Error("Account required");
-  if (isProviderAccount(account)) {
-    throw new Error("Provider accounts cannot sponsor transactions");
-  }
-  const managed = params.nonce == null && client.nonceManager !== undefined;
-  const nonce = params.nonce != null ? intToBigInt(params.nonce) : await resolveNonce(client, account.address);
-  let fee;
-  try {
-    ({ fee } = await resolveFee(client, transaction, params.fee));
-  } catch (error) {
-    if (managed)
-      await releaseNonce(client, account.address, nonce);
-    throw error;
-  }
-  const sponsorCondition = createSingleSigSpendingCondition(account.publicKey, nonce, fee);
-  const auth = transaction.auth;
-  const sponsored = {
-    ...transaction,
-    auth: {
-      ...auth,
-      sponsorSpendingCondition: sponsorCondition
+function indexSource(params = {}) {
+  const maxPages = params.maxPages ?? 10;
+  const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
+  const source = mempoolAwareSource({
+    getConfirmed: params.getConfirmed,
+    async getPending({ client, address }) {
+      const request = indexRequestFn(client, params.baseUrl, "indexSource");
+      const out = [];
+      let cursor;
+      let pages = 0;
+      do {
+        const query = new URLSearchParams({
+          sender: address,
+          limit: "200"
+        });
+        if (cursor)
+          query.set("from_cursor", cursor);
+        let data;
+        try {
+          data = await request(`/v1/index/mempool?${query}`, {
+            method: "GET",
+            headers
+          });
+        } catch (error) {
+          if (indexNotFound(error, "indexSource"))
+            break;
+          throw error;
+        }
+        for (const tx of data.mempool ?? []) {
+          if (tx.nonce != null)
+            out.push(BigInt(tx.nonce));
+        }
+        cursor = data.next_cursor ?? undefined;
+        pages += 1;
+      } while (cursor && pages < maxPages);
+      return out;
+    }
+  });
+  return {
+    async get(args) {
+      indexRequestFn(args.client, params.baseUrl, "indexSource");
+      return source.get(args);
     }
   };
-  return signSponsorWithAccount(sponsored, account);
 }
-
-// src/actions/wallet/transferStx.ts
-async function transferStx(client, params) {
-  const account = client.account;
-  if (!account)
-    throw new Error("Account required");
-  if (!validateStacksAddress(params.to))
-    throw new Error(`Invalid recipient address: ${params.to}`);
-  if (isProviderAccount(account)) {
-    assertNoFeeTierForProvider(params.fee);
-    const result = await account.provider.request("stx_transferStx", {
-      recipient: params.to,
-      amount: String(params.amount),
-      memo: params.memo
-    });
-    return result.txid;
-  }
-  const managed = params.nonce === undefined && client.nonceManager !== undefined;
-  const nonce = params.nonce ?? await resolveNonce(client, account.address);
-  try {
-    const needsFeeResolution = params.fee === undefined || isFeeTier(params.fee);
-    const unsigned = buildTokenTransfer({
-      recipient: params.to,
-      amount: params.amount,
-      memo: params.memo,
-      fee: needsFeeResolution ? 0n : params.fee,
-      nonce,
-      publicKey: account.publicKey,
-      chain: client.chain,
-      postConditionMode: params.postConditionMode,
-      postConditions: params.postConditions
-    });
-    if (needsFeeResolution) {
-      const { fee } = await resolveFee(client, unsigned, params.fee);
-      setUnsignedFee(unsigned, fee);
+function hiroNonceSource(params) {
+  const baseUrl = params.baseUrl.replace(/\/$/, "");
+  const fetchImpl = resolveFetch(params.fetchImpl);
+  return {
+    async get({ address }) {
+      const res = await fetchImpl(`${baseUrl}/extended/v1/address/${address}/nonces`, {
+        headers: params.apiKey ? { "x-api-key": params.apiKey } : undefined
+      });
+      if (!res.ok) {
+        throw new Error(`hiroNonceSource: /nonces ${res.status}`);
+      }
+      const data = await res.json();
+      const missing = (data.detected_missing_nonces ?? []).map((n) => BigInt(n)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      if (missing[0] !== undefined)
+        return missing[0];
+      return BigInt(data.possible_next_nonce ?? 0);
     }
-    const signed = await signTransactionWithAccount(unsigned, account);
-    return await broadcastWithNonceReset(client, {
-      transaction: signed,
-      address: account.address
+  };
+}
+// src/transports/http.ts
+function http(url, config) {
+  return (params) => {
+    const resolvedUrl = url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
+    const mergedConfig = {
+      ...config,
+      url: resolvedUrl
+    };
+    return createTransport("http", {
+      ...mergedConfig,
+      request: buildRequestFn(resolvedUrl, mergedConfig)
     });
-  } catch (error) {
-    if (managed)
-      await releaseNonce(client, account.address, nonce);
-    throw error;
-  }
+  };
 }
-
-// src/clients/decorators/wallet.ts
-function walletActions(client) {
-  return {
-    sendTransaction: (params) => sendTransaction(client, params),
-    signTransaction: (params) => signTransactionAction(client, params),
-    transferStx: (params) => transferStx(client, params),
-    callContract: (params) => callContract(client, params),
-    deployContract: (params) => deployContract(client, params),
-    signMessage: (params) => signMessage(client, params),
-    sponsorTransaction: (params) => sponsorTransaction(client, params)
+// src/transports/custom.ts
+function custom(params) {
+  return () => createTransport("custom", { request: params.request });
+}
+// src/transports/fallback.ts
+function fallback(transports) {
+  return (params) => {
+    const resolved = transports.map((t) => t(params));
+    return createTransport("fallback", {
+      request: async (path, options) => {
+        let lastError;
+        for (const transport of resolved) {
+          try {
+            return await transport.request(path, options);
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+          }
+        }
+        throw lastError ?? new Error("All transports failed");
+      }
+    });
   };
 }
+// src/transports/webSocket.ts
+function subKey(params) {
+  const parts = [params.event];
+  if (params.tx_id)
+    parts.push(`tx_id:${params.tx_id}`);
+  if (params.address)
+    parts.push(`address:${params.address}`);
+  if (params.asset_identifier)
+    parts.push(`asset:${params.asset_identifier}`);
+  if (params.value)
+    parts.push(`value:${params.value}`);
+  return parts.join("|");
+}
 
-// src/clients/createWalletClient.ts
-function createWalletClient(config) {
-  return createClient(config).extend(walletActions);
-}
-// src/clients/decorators/multisig.ts
-function multisigActions(client) {
-  const msConfig = client._multisigConfig;
-  if (!msConfig)
-    throw new Error("multisigActions requires a multi-sig client");
-  const { signers, requiredSignatures, hashMode } = msConfig;
-  async function resolveNonce2(nonce) {
-    if (nonce !== undefined)
-      return nonce;
-    const address = makeMultiSigAddress(signers, requiredSignatures, client.chain);
-    if (client.nonceManager)
-      return client.nonceManager.consume({ client, address });
-    return getNonce(client, { address });
+class WebSocketChannel {
+  ws = null;
+  url;
+  nextId = 1;
+  pending = new Map;
+  subs = new Map;
+  destroyed = false;
+  reconnecting = false;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  reconnect;
+  reconnectMaxAttempts;
+  reconnectBaseDelay;
+  constructor(url, config) {
+    this.url = url;
+    this.reconnect = config?.reconnect ?? true;
+    this.reconnectMaxAttempts = config?.reconnectMaxAttempts ?? 10;
+    this.reconnectBaseDelay = config?.reconnectBaseDelay ?? 1000;
   }
-  return {
-    async transferStx(params) {
-      const nonce = await resolveNonce2(params.nonce);
-      const unsigned = buildTokenTransfer({
-        recipient: params.to,
-        amount: params.amount,
-        memo: params.memo,
-        fee: params.fee ?? 0n,
-        nonce,
-        publicKeys: signers,
-        signaturesRequired: requiredSignatures,
-        hashMode,
-        chain: client.chain,
-        postConditionMode: params.postConditionMode,
-        postConditions: params.postConditions
+  connect() {
+    if (this.ws?.readyState === WebSocket.OPEN)
+      return Promise.resolve();
+    if (this.ws?.readyState === WebSocket.CONNECTING) {
+      return new Promise((resolve, reject) => {
+        const onOpen = () => {
+          this.ws?.removeEventListener("error", onError);
+          resolve();
+        };
+        const onError = (e) => {
+          this.ws?.removeEventListener("open", onOpen);
+          reject(new WebSocketError("WebSocket connection failed", {
+            details: String(e)
+          }));
+        };
+        this.ws?.addEventListener("open", onOpen, { once: true });
+        this.ws?.addEventListener("error", onError, { once: true });
       });
-      if (params.fee === undefined) {
-        const estimates = await estimateFee(client, { transaction: unsigned });
-        const mid = estimates[1] ?? estimates[0];
-        if (mid) {
-          setUnsignedFee(unsigned, BigInt(mid.fee));
-        }
-      }
-      return unsigned;
-    },
-    async callContract(params) {
-      const [contractAddress, contractName] = parseContractId(params.contract);
-      const nonce = await resolveNonce2(params.nonce);
-      const unsigned = buildContractCall({
-        contractAddress,
-        contractName,
-        functionName: params.functionName,
-        functionArgs: params.functionArgs ?? [],
-        fee: params.fee ?? 0n,
-        nonce,
-        publicKeys: signers,
-        signaturesRequired: requiredSignatures,
-        hashMode,
-        chain: client.chain,
-        postConditionMode: params.postConditionMode,
-        postConditions: params.postConditions
+    }
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+      this.ws.addEventListener("open", () => {
+        this.reconnectAttempt = 0;
+        this.reconnecting = false;
+        resolve();
+      }, { once: true });
+      this.ws.addEventListener("error", (e) => {
+        reject(new WebSocketError("WebSocket connection failed", {
+          details: String(e)
+        }));
+      }, { once: true });
+      this.ws.addEventListener("message", (event) => {
+        this.handleMessage(event.data);
       });
-      if (params.fee === undefined) {
-        const estimates = await estimateFee(client, { transaction: unsigned });
-        const mid = estimates[1] ?? estimates[0];
-        if (mid) {
-          setUnsignedFee(unsigned, BigInt(mid.fee));
-        }
-      }
-      return unsigned;
-    },
-    async deployContract(params) {
-      const nonce = await resolveNonce2(params.nonce);
-      const unsigned = buildContractDeploy({
-        contractName: params.contractName,
-        codeBody: params.codeBody,
-        clarityVersion: params.clarityVersion,
-        fee: params.fee ?? 0n,
-        nonce,
-        publicKeys: signers,
-        signaturesRequired: requiredSignatures,
-        hashMode,
-        chain: client.chain,
-        postConditionMode: params.postConditionMode,
-        postConditions: params.postConditions
+      this.ws.addEventListener("close", () => {
+        if (!this.destroyed)
+          this.handleDisconnect();
       });
-      if (params.fee === undefined) {
-        const estimates = await estimateFee(client, { transaction: unsigned });
-        const mid = estimates[1] ?? estimates[0];
-        if (mid) {
-          setUnsignedFee(unsigned, BigInt(mid.fee));
+    });
+  }
+  handleMessage(raw) {
+    const data = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if ("id" in msg && msg.id != null) {
+      const rpc = msg;
+      const p = this.pending.get(rpc.id);
+      if (!p)
+        return;
+      this.pending.delete(rpc.id);
+      if (rpc.error) {
+        p.reject(new WebSocketError(rpc.error.message, {
+          details: `JSON-RPC error ${rpc.error.code}`
+        }));
+      } else {
+        p.resolve(rpc.result);
+      }
+      return;
+    }
+    const notif = msg;
+    if (!notif.method)
+      return;
+    for (const [, entry] of this.subs) {
+      if (entry.params.event === notif.method) {
+        for (const cb of entry.callbacks) {
+          try {
+            cb(notif.params);
+          } catch {}
         }
       }
-      return unsigned;
-    },
-    async sendTransaction(params) {
-      const finalized = finalizeMultiSig(params.transaction, signers);
-      return sendTransaction(client, {
-        transaction: finalized,
-        attachment: params.attachment
-      });
     }
-  };
-}
-
-// src/clients/createMultiSigClient.ts
-function createMultiSigClient(config) {
-  const client = createClient(config);
-  client._multisigConfig = {
-    signers: config.signers,
-    requiredSignatures: config.requiredSignatures,
-    hashMode: config.hashMode
-  };
-  return client.extend(multisigActions);
-}
-// src/actions/wallet/nonceStores.ts
-var TAKE_IF_PRESENT = `local v = redis.call('GET', KEYS[1])
-if v == false then return false end
-redis.call('INCR', KEYS[1])
-return v`;
-var SEED_OR_TAKE = `local v = redis.call('GET', KEYS[1])
-if v == false then redis.call('SET', KEYS[1], ARGV[1]); v = ARGV[1] end
-redis.call('INCR', KEYS[1])
-return v`;
-var RELEASE_IF_LATEST = `local v = redis.call('GET', KEYS[1])
-if v ~= false and v == ARGV[1] then redis.call('SET', KEYS[1], ARGV[2]) end
-return v`;
-function redisStore(params) {
-  const { redis } = params;
-  const prefix = params.prefix ?? "stacks:nonce:";
-  return {
-    async reserve(key, getFloor) {
-      const k = prefix + key;
-      const present = await redis.send("EVAL", [TAKE_IF_PRESENT, "1", k]);
-      if (present != null)
-        return BigInt(present);
-      const floor = await getFloor();
-      const seeded = await redis.send("EVAL", [
-        SEED_OR_TAKE,
-        "1",
-        k,
-        floor.toString()
-      ]);
-      return BigInt(seeded);
-    },
-    async reset(key) {
-      await redis.send("DEL", [prefix + key]);
-    },
-    async release(key, nonce) {
-      await redis.send("EVAL", [
-        RELEASE_IF_LATEST,
-        "1",
-        prefix + key,
-        (nonce + 1n).toString(),
-        nonce.toString()
-      ]);
-    },
-    async peek(key) {
-      const v = await redis.send("GET", [prefix + key]);
-      return v == null ? undefined : BigInt(v);
+  }
+  handleDisconnect() {
+    this.ws = null;
+    for (const [, p] of this.pending) {
+      p.reject(new WebSocketError("WebSocket disconnected"));
     }
-  };
-}
-function postgresStore(params) {
-  const { sql } = params;
-  const shouldEnsure = params.ensureTable ?? true;
-  let ensured = false;
-  async function ensureTable() {
-    if (!shouldEnsure || ensured)
+    this.pending.clear();
+    if (this.reconnect && this.subs.size > 0 && this.reconnectAttempt < this.reconnectMaxAttempts) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.destroyed || this.reconnecting)
       return;
-    await sql`CREATE TABLE IF NOT EXISTS stacks_nonce_state (key text PRIMARY KEY, next numeric NOT NULL)`;
-    ensured = true;
+    this.reconnecting = true;
+    const delay = this.reconnectBaseDelay * 2 ** this.reconnectAttempt;
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnecting = false;
+      try {
+        await this.connect();
+        await this.resubscribeAll();
+      } catch {
+        if (!this.destroyed && this.subs.size > 0) {
+          this.handleDisconnect();
+        }
+      }
+    }, delay);
   }
-  return {
-    async reserve(key, getFloor) {
-      await ensureTable();
-      const updated = await sql`UPDATE stacks_nonce_state SET next = next + 1 WHERE key = ${key} RETURNING next - 1 AS nonce`;
-      const warm = updated[0];
-      if (warm)
-        return BigInt(String(warm.nonce));
-      const floor = await getFloor();
-      const seeded = await sql`INSERT INTO stacks_nonce_state (key, next) VALUES (${key}, ${(floor + 1n).toString()}) ON CONFLICT (key) DO UPDATE SET next = stacks_nonce_state.next + 1 RETURNING next - 1 AS nonce`;
-      const cold = seeded[0];
-      if (!cold)
-        throw new Error("postgresStore: insert returned no row");
-      return BigInt(String(cold.nonce));
-    },
-    async reset(key) {
-      await ensureTable();
-      await sql`DELETE FROM stacks_nonce_state WHERE key = ${key}`;
-    },
-    async release(key, nonce) {
-      await ensureTable();
-      await sql`UPDATE stacks_nonce_state SET next = ${nonce.toString()} WHERE key = ${key} AND next = ${(nonce + 1n).toString()}`;
-    },
-    async peek(key) {
-      await ensureTable();
-      const rows = await sql`SELECT next FROM stacks_nonce_state WHERE key = ${key}`;
-      const row = rows[0];
-      return row ? BigInt(String(row.next)) : undefined;
+  async resubscribeAll() {
+    for (const [, entry] of this.subs) {
+      await this.sendRpc("subscribe", entry.params);
     }
-  };
-}
-// src/actions/wallet/nonceSources.ts
-function resolveFetch(fetchImpl) {
-  const f = fetchImpl ?? globalThis.fetch;
-  if (!f)
-    throw new Error("No fetch implementation available; pass `fetchImpl`");
-  return f;
-}
-function nextFreeNonce(confirmed, pending) {
-  const taken = new Set(pending.filter((n2) => n2 >= confirmed).map((n2) => n2.toString()));
-  let n = confirmed;
-  while (taken.has(n.toString()))
-    n += 1n;
-  return n;
-}
-function mempoolAwareSource(params) {
-  const getConfirmed = params.getConfirmed ?? (({ client, address }) => getNonce(client, { address }));
-  return {
-    async get({ client, address }) {
-      const confirmed = await getConfirmed({ client, address });
-      let pending = [];
-      try {
-        pending = await params.getPending({ client, address });
-      } catch (error) {
-        if (error instanceof IndexSourceConfigError)
-          throw error;
-        return confirmed;
+  }
+  sendRpc(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        return reject(new WebSocketError("WebSocket not connected"));
       }
-      return nextFreeNonce(confirmed, pending);
+      const id = this.nextId++;
+      const msg = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify(msg));
+    });
+  }
+  async subscribe(params, callback) {
+    if (this.destroyed) {
+      throw new WebSocketError("WebSocket channel has been destroyed");
     }
-  };
-}
-function indexSource(params = {}) {
-  const maxPages = params.maxPages ?? 10;
-  const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
-  const source = mempoolAwareSource({
-    getConfirmed: params.getConfirmed,
-    async getPending({ client, address }) {
-      const request = indexRequestFn(client, params.baseUrl, "indexSource");
-      const out = [];
-      let cursor;
-      let pages = 0;
-      do {
-        const query = new URLSearchParams({
-          sender: address,
-          limit: "200"
-        });
-        if (cursor)
-          query.set("from_cursor", cursor);
-        let data;
-        try {
-          data = await request(`/v1/index/mempool?${query}`, {
-            method: "GET",
-            headers
-          });
-        } catch (error) {
-          if (indexNotFound(error, "indexSource"))
-            break;
-          throw error;
-        }
-        for (const tx of data.mempool ?? []) {
-          if (tx.nonce != null)
-            out.push(BigInt(tx.nonce));
+    await this.connect();
+    const key = subKey(params);
+    let entry = this.subs.get(key);
+    if (entry) {
+      entry.callbacks.add(callback);
+    } else {
+      entry = { params, callbacks: new Set([callback]) };
+      this.subs.set(key, entry);
+      await this.sendRpc("subscribe", params);
+    }
+    return {
+      unsubscribe: () => {
+        const e = this.subs.get(key);
+        if (!e)
+          return;
+        e.callbacks.delete(callback);
+        if (e.callbacks.size === 0) {
+          this.subs.delete(key);
+          if (this.ws?.readyState === WebSocket.OPEN) {
+            this.sendRpc("unsubscribe", params).catch(() => {});
+          }
+          if (this.subs.size === 0)
+            this.closeQuietly();
         }
-        cursor = data.next_cursor ?? undefined;
-        pages += 1;
-      } while (cursor && pages < maxPages);
-      return out;
+      }
+    };
+  }
+  closeQuietly() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
     }
-  });
-  return {
-    async get(args) {
-      indexRequestFn(args.client, params.baseUrl, "indexSource");
-      return source.get(args);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    for (const [, p] of this.pending) {
+      p.reject(new WebSocketError("WebSocket channel destroyed"));
     }
+    this.pending.clear();
+    this.subs.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+}
+function deriveWsUrl(httpUrl) {
+  return `${httpUrl.replace(/^http/, "ws").replace(/\/$/, "")}/extended/v1/ws`;
+}
+function webSocket(url, config) {
+  return (params) => {
+    const httpUrl = config?.url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
+    const wsUrl = url ?? params?.chain?.rpcUrls.default.ws?.[0] ?? deriveWsUrl(httpUrl);
+    const resolvedHttpConfig = {
+      ...config,
+      url: httpUrl
+    };
+    const channel = new WebSocketChannel(wsUrl, config);
+    const { apiKey: _apiKey, ...exposedConfig } = resolvedHttpConfig;
+    const transport = {
+      type: "webSocket",
+      request: buildRequestFn(httpUrl, resolvedHttpConfig),
+      config: exposedConfig,
+      subscribe: (subParams, callback) => channel.subscribe(subParams, callback),
+      destroy: () => channel.destroy()
+    };
+    return transport;
   };
 }
-function hiroNonceSource(params) {
-  const baseUrl = params.baseUrl.replace(/\/$/, "");
-  const fetchImpl = resolveFetch(params.fetchImpl);
-  return {
-    async get({ address }) {
-      const res = await fetchImpl(`${baseUrl}/extended/v1/address/${address}/nonces`, {
-        headers: params.apiKey ? { "x-api-key": params.apiKey } : undefined
-      });
-      if (!res.ok) {
-        throw new Error(`hiroNonceSource: /nonces ${res.status}`);
-      }
-      const data = await res.json();
-      const missing = (data.detected_missing_nonces ?? []).map((n) => BigInt(n)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-      if (missing[0] !== undefined)
-        return missing[0];
-      return BigInt(data.possible_next_nonce ?? 0);
-    }
-  };
+// src/filters/index.ts
+var exports_filters = {};
+__export(exports_filters, {
+  CHAIN_EVENT_FILTER_TYPES: () => CHAIN_EVENT_FILTER_TYPES,
+  DECODED_EVENT_TYPES: () => DECODED_EVENT_TYPES,
+  VM_EVENT_TYPES: () => VM_EVENT_TYPES,
+  VM_NODE_TO_STORED_TYPE: () => VM_NODE_TO_STORED_TYPE,
+  assertAssetIdentifier: () => assertAssetIdentifier,
+  assertContractId: () => assertContractId,
+  assertPrincipalish: () => assertPrincipalish,
+  assetId: () => assetId,
+  fromSubgraphSource: () => fromSubgraphSource,
+  hasWildcard: () => hasWildcard,
+  isPrincipal: () => isPrincipal,
+  makeChainEventFilter: () => makeChainEventFilter,
+  on: () => on
+});
+
+// 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/filters/validate.ts
+function assetId(value) {
+  assertAssetIdentifier("assetIdentifier", value);
+  return value;
+}
+function isPrincipal(value) {
+  return parsePrincipal(value) !== null;
 }
-// src/transports/http.ts
-function http(url, config) {
-  return (params) => {
-    const resolvedUrl = url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
-    const mergedConfig = {
-      ...config,
-      url: resolvedUrl
-    };
-    return createTransport("http", {
-      ...mergedConfig,
-      request: buildRequestFn(resolvedUrl, mergedConfig)
-    });
-  };
+function hasWildcard(value) {
+  return value.includes("*");
 }
-// src/transports/custom.ts
-function custom(params) {
-  return () => createTransport("custom", { request: params.request });
+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).`);
+  }
 }
-// src/transports/fallback.ts
-function fallback(transports) {
-  return (params) => {
-    const resolved = transports.map((t) => t(params));
-    return createTransport("fallback", {
-      request: async (path, options) => {
-        let lastError;
-        for (const transport of resolved) {
-          try {
-            return await transport.request(path, options);
-          } catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-          }
-        }
-        throw lastError ?? new Error("All transports failed");
-      }
-    });
-  };
+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.`);
+  }
 }
-// src/transports/webSocket.ts
-function subKey(params) {
-  const parts = [params.event];
-  if (params.tx_id)
-    parts.push(`tx_id:${params.tx_id}`);
-  if (params.address)
-    parts.push(`address:${params.address}`);
-  if (params.asset_identifier)
-    parts.push(`asset:${params.asset_identifier}`);
-  if (params.value)
-    parts.push(`value:${params.value}`);
-  return parts.join("|");
+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).`);
+  }
 }
 
-class WebSocketChannel {
-  ws = null;
-  url;
-  nextId = 1;
-  pending = new Map;
-  subs = new Map;
-  destroyed = false;
-  reconnecting = false;
-  reconnectAttempt = 0;
-  reconnectTimer = null;
-  reconnect;
-  reconnectMaxAttempts;
-  reconnectBaseDelay;
-  constructor(url, config) {
-    this.url = url;
-    this.reconnect = config?.reconnect ?? true;
-    this.reconnectMaxAttempts = config?.reconnectMaxAttempts ?? 10;
-    this.reconnectBaseDelay = config?.reconnectBaseDelay ?? 1000;
+// 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);
+      }
+    }
   }
-  connect() {
-    if (this.ws?.readyState === WebSocket.OPEN)
-      return Promise.resolve();
-    if (this.ws?.readyState === WebSocket.CONNECTING) {
-      return new Promise((resolve, reject) => {
-        const onOpen = () => {
-          this.ws?.removeEventListener("error", onError);
-          resolve();
-        };
-        const onError = (e) => {
-          this.ws?.removeEventListener("open", onOpen);
-          reject(new WebSocketError("WebSocket connection failed", {
-            details: String(e)
-          }));
-        };
-        this.ws?.addEventListener("open", onOpen, { once: true });
-        this.ws?.addEventListener("error", onError, { once: true });
-      });
+}
+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");
+      }
     }
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(this.url);
-      this.ws.addEventListener("open", () => {
-        this.reconnectAttempt = 0;
-        this.reconnecting = false;
-        resolve();
-      }, { once: true });
-      this.ws.addEventListener("error", (e) => {
-        reject(new WebSocketError("WebSocket connection failed", {
-          details: String(e)
-        }));
-      }, { once: true });
-      this.ws.addEventListener("message", (event) => {
-        this.handleMessage(event.data);
-      });
-      this.ws.addEventListener("close", () => {
-        if (!this.destroyed)
-          this.handleDisconnect();
-      });
-    });
   }
-  handleMessage(raw) {
-    const data = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-    let msg;
-    try {
-      msg = JSON.parse(data);
-    } catch {
-      return;
+}
+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 ("id" in msg && msg.id != null) {
-      const rpc = msg;
-      const p = this.pending.get(rpc.id);
-      if (!p)
-        return;
-      this.pending.delete(rpc.id);
-      if (rpc.error) {
-        p.reject(new WebSocketError(rpc.error.message, {
-          details: `JSON-RPC error ${rpc.error.code}`
-        }));
-      } else {
-        p.resolve(rpc.result);
-      }
-      return;
+    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");
     }
-    const notif = msg;
-    if (!notif.method)
-      return;
-    for (const [, entry] of this.subs) {
-      if (entry.params.event === notif.method) {
-        for (const cb of entry.callbacks) {
-          try {
-            cb(notif.params);
-          } catch {}
-        }
-      }
+    if (AMOUNT_FIELDS.has(key)) {
+      unsupported("Index events", key, "amount predicates are Webhooks/Subgraphs-only; filter client-side on the decoded rows");
     }
-  }
-  handleDisconnect() {
-    this.ws = null;
-    for (const [, p] of this.pending) {
-      p.reject(new WebSocketError("WebSocket disconnected"));
+    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)");
     }
-    this.pending.clear();
-    if (this.reconnect && this.subs.size > 0 && this.reconnectAttempt < this.reconnectMaxAttempts) {
-      this.scheduleReconnect();
+    if (key === "lockedAddress") {
+      out.sender = value;
+      continue;
     }
-  }
-  scheduleReconnect() {
-    if (this.destroyed || this.reconnecting)
-      return;
-    this.reconnecting = true;
-    const delay = this.reconnectBaseDelay * 2 ** this.reconnectAttempt;
-    this.reconnectAttempt++;
-    this.reconnectTimer = setTimeout(async () => {
-      this.reconnecting = false;
-      try {
-        await this.connect();
-        await this.resubscribeAll();
-      } catch {
-        if (!this.destroyed && this.subs.size > 0) {
-          this.handleDisconnect();
-        }
-      }
-    }, delay);
-  }
-  async resubscribeAll() {
-    for (const [, entry] of this.subs) {
-      await this.sendRpc("subscribe", entry.params);
+    if (key === "caller" && spec.type !== "nested_contract_call") {
+      unsupported("Index events", "caller", "outer contract-call fields live on index.contractCalls");
     }
+    out[key] = value;
   }
-  sendRpc(method, params) {
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        return reject(new WebSocketError("WebSocket not connected"));
-      }
-      const id = this.nextId++;
-      const msg = {
-        jsonrpc: "2.0",
-        id,
-        method,
-        params
-      };
-      this.pending.set(id, { resolve, reject });
-      this.ws.send(JSON.stringify(msg));
-    });
-  }
-  async subscribe(params, callback) {
-    if (this.destroyed) {
-      throw new WebSocketError("WebSocket channel has been destroyed");
+  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");
     }
-    await this.connect();
-    const key = subKey(params);
-    let entry = this.subs.get(key);
-    if (entry) {
-      entry.callbacks.add(callback);
-    } else {
-      entry = { params, callbacks: new Set([callback]) };
-      this.subs.set(key, entry);
-      await this.sendRpc("subscribe", params);
+    if (key === "factory") {
+      unsupported("Streams", "factory", "dynamic factory discovery is a Subgraphs-only concept");
     }
-    return {
-      unsubscribe: () => {
-        const e = this.subs.get(key);
-        if (!e)
-          return;
-        e.callbacks.delete(callback);
-        if (e.callbacks.size === 0) {
-          this.subs.delete(key);
-          if (this.ws?.readyState === WebSocket.OPEN) {
-            this.sendRpc("unsubscribe", params).catch(() => {});
-          }
-          if (this.subs.size === 0)
-            this.closeQuietly();
-        }
-      }
-    };
-  }
-  closeQuietly() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
+    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;
   }
-  destroy() {
-    this.destroyed = true;
-    if (this.reconnectTimer)
-      clearTimeout(this.reconnectTimer);
-    for (const [, p] of this.pending) {
-      p.reject(new WebSocketError("WebSocket channel destroyed"));
+  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");
     }
-    this.pending.clear();
-    this.subs.clear();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
+    if (key === "caller") {
+      out.sender = value;
+      continue;
     }
+    out[key] = value;
   }
+  return { ...out, ...extra };
 }
-function deriveWsUrl(httpUrl) {
-  return `${httpUrl.replace(/^http/, "ws").replace(/\/$/, "")}/extended/v1/ws`;
+function toSubgraphSource(spec) {
+  return Object.fromEntries([
+    ["type", spec.type],
+    ...specEntries(spec)
+  ]);
 }
-function webSocket(url, config) {
-  return (params) => {
-    const httpUrl = config?.url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
-    const wsUrl = url ?? params?.chain?.rpcUrls.default.ws?.[0] ?? deriveWsUrl(httpUrl);
-    const resolvedHttpConfig = {
-      ...config,
-      url: httpUrl
-    };
-    const channel = new WebSocketChannel(wsUrl, config);
-    const { apiKey: _apiKey, ...exposedConfig } = resolvedHttpConfig;
-    const transport = {
-      type: "webSocket",
-      request: buildRequestFn(httpUrl, resolvedHttpConfig),
-      config: exposedConfig,
-      subscribe: (subParams, callback) => channel.subscribe(subParams, callback),
-      destroy: () => channel.destroy()
-    };
-    return transport;
-  };
+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)
+};
 // src/accounts/providerToAccount.ts
 async function providerToAccount(provider) {
   const result = await provider.request("stx_getAddresses");
@@ -4588,5 +4589,5 @@ function parseStx(stx) {
   return parseUnits(stx, 6);
 }
 
-//# debugId=3FA35CAE5C34437464756E2164756E21
+//# debugId=BBEDE03C59EADB7164756E2164756E21
 //# sourceMappingURL=index.cjs.map